Zen MCP Server 全面测评报告：多模型协同开发的革命性工具

class Order:
    def __init__(self, items, tax_rate=0.08, discount=0):
        self.items = items
        self.tax_rate = tax_rate
        self.discount = discount
        self.status = "pending"
    
    def calculate_total(self):
        subtotal = sum(item['price'] * item['quantity'] for item in self.items)
        discount_amount = subtotal * self.discount
        subtotal_after_discount = subtotal - discount_amount
        tax = subtotal_after_discount * self.tax_rate
        return subtotal_after_discount + tax
    
    def apply_discount(self, discount_code):
        if discount_code == "SAVE10":
            self.discount = 0.1
        elif discount_code == "SAVE20":
            self.discount = 0.2
        else:
            self.discount = 0
    
    def set_status(self, new_status):
        statuses = ["pending", "paid", "shipped", "delivered", "cancelled"]
        if new_status in statuses:
            self.status = new_status
        else:
            raise ValueError(f"Invalid status: {new_status}")
    
    def add_item(self, product_id, price, quantity=1):
        self.items.append({"product_id": product_id, "price": price, "quantity": quantity})
    
    def remove_item(self, product_id):
        self.items = [item for item in self.items if item['product_id'] != product_id]

/zen:refactor --file order.py --language python --tasks "add_type_hints,fix_discount_logic,add_decimal_processing,add_error_handling"

from decimal import Decimal
from typing import List, Dict, Optional, Literal

class Order:
    """Represents an customer order with items, pricing, and status tracking."""
    
    def __init__(self, items: List[Dict[str, object]], tax_rate: Decimal = Decimal('0.08'), 
                 discount: Decimal = Decimal('0')) -> None:
        self.items = items
        self.tax_rate = tax_rate
        self.discount = discount
        self.status: Literal["pending", "paid", "shipped", "delivered", "cancelled"] = "pending"
        self._applied_discount_codes = set()  # Track applied discount codes to prevent reuse
    
    def calculate_total(self) -> Decimal:
        """Calculate the total order amount after discount and tax."""
        if not self.items:
            return Decimal('0')
            
        subtotal = sum(Decimal(str(item['price'])) * Decimal(str(item['quantity'])) for item in self.items)
        discount_amount = subtotal * self.discount
        subtotal_after_discount = subtotal - discount_amount
        tax = subtotal_after_discount * self.tax_rate
        return subtotal_after_discount + tax
    
    def apply_discount(self, discount_code: str) -> bool:
        """Apply a discount code if valid and not already applied."""
        if discount_code in self._applied_discount_codes:
            return False  # Discount already applied
            
        discount_map = {"SAVE10": Decimal('0.1'), "SAVE20": Decimal('0.2')}
        
        if discount_code in discount_map:
            self.discount = discount_map[discount_code]
            self._applied_discount_codes.add(discount_code)
            return True
        return False
    
    def set_status(self, new_status: Literal["pending", "paid", "shipped", "delivered", "cancelled"]) -> None:
        """Update the order status with validation."""
        valid_statuses = {"pending", "paid", "shipped", "delivered", "cancelled"}
        if new_status not in valid_statuses:
            raise ValueError(f"Invalid status: {new_status}. Must be one of {valid_statuses}")
        self.status = new_status
    
    def add_item(self, product_id: str, price: float, quantity: int = 1) -> None:
        """Add an item to the order."""
        if price <= 0:
            raise ValueError("Price must be positive")
        if quantity <= 0:
            raise ValueError("Quantity must be positive")
            
        self.items.append({
            "product_id": product_id, 
            "price": Decimal(str(price)), 
            "quantity": quantity
        })
    
    def remove_item(self, product_id: str) -> bool:
        """Remove an item from the order by product ID."""
        initial_count = len(self.items)
        self.items = [item for item in self.items if item['product_id'] != product_id]
        return len(self.items) < initial_count  # Return True if item was removed
    
    def get_summary(self) -> Dict[str, object]:
        """Return a summary of the order."""
        return {
            "item_count": sum(item['quantity'] for item in self.items),
            "subtotal": self.calculate_total() / (1 + self.tax_rate),
            "tax": self.calculate_total() - (self.calculate_total() / (1 + self.tax_rate)),
            "discount": self.discount,
            "total": self.calculate_total(),
            "status": self.status
        }

/zen:testgen --file order_refactored.py --framework pytest --coverage comprehensive

import pytest
from decimal import Decimal
from order_refactored import Order

class TestOrder:
    """Test cases for the Order class."""
    
    def test_empty_order_total(self):
        """Test calculating total for an empty order."""
        order = Order(items=[])
        assert order.calculate_total() == Decimal('0')
    
    def test_single_item_order(self):
        """Test order with a single item."""
        items = [{"product_id": "1", "price": 10.0, "quantity": 2}]
        order = Order(items=items)
        # 2 * $10 = $20 subtotal, + 8% tax = $21.60
        assert order.calculate_total() == Decimal('21.60')
    
    def test_discount_application(self):
        """Test applying a valid discount code."""
        items = [{"product_id": "1", "price": 100.0, "quantity": 1}]
        order = Order(items=items)
        
        # Apply discount and verify
        assert order.apply_discount("SAVE10") is True
        assert order.discount == Decimal('0.1')
        # $100 - 10% = $90, + 8% tax = $97.20
        assert order.calculate_total() == Decimal('97.20')
    
    def test_double_discount_prevention(self):
        """Test that discount codes can't be applied multiple times."""
        items = [{"product_id": "1", "price": 100.0, "quantity": 1}]
        order = Order(items=items)
        
        # First application should work
        assert order.apply_discount("SAVE10") is True
        # Second application should fail
        assert order.apply_discount("SAVE10") is False
        # Discount should remain at 10%, not 20%
        assert order.discount == Decimal('0.1')
    
    def test_invalid_discount_code(self):
        """Test applying an invalid discount code."""
        items = [{"product_id": "1", "price": 100.0, "quantity": 1}]
        order = Order(items=items)
        
        assert order.apply_discount("INVALID") is False
        assert order.discount == Decimal('0')  # Discount should remain unchanged
    
    def test_status_management(self):
        """Test updating order status with validation."""
        order = Order(items=[])
        
        # Valid status changes
        order.set_status("paid")
        assert order.status == "paid"
        
        order.set_status("shipped")
        assert order.status == "shipped"
        
        # Invalid status should raise ValueError
        with pytest.raises(ValueError):
            order.set_status("invalid_status")
    
    def test_add_remove_items(self):
        """Test adding and removing items from order."""
        order = Order(items=[])
        
        # Add items
        order.add_item("prod1", 10.0, 2)
        order.add_item("prod2", 15.0, 1)
        assert len(order.items) == 2
        
        # Remove item
        assert order.remove_item("prod1") is True
        assert len(order.items) == 1
        assert order.items[0]['product_id'] == "prod2"
        
        # Remove non-existent item
        assert order.remove_item("prod3") is False
        assert len(order.items) == 1
    
    def test_item_validation(self):
        """Test validation when adding items."""
        order = Order(items=[])
        
        # Should raise error for invalid price
        with pytest.raises(ValueError):
            order.add_item("prod1", -5.0, 1)
        
        # Should raise error for invalid quantity
        with pytest.raises(ValueError):
            order.add_item("prod1", 10.0, 0)
    
    def test_order_summary(self):
        """Test getting order summary."""
        items = [{"product_id": "1", "price": 10.0, "quantity": 2}]
        order = Order(items=items)
        order.apply_discount("SAVE10")
        order.set_status("paid")
        
        summary = order.get_summary()
        
        assert summary['item_count'] == 2
        assert summary['status'] == "paid"
        assert summary['discount'] == Decimal('0.1')
        # Verify calculations in summary
        assert summary['subtotal'] == Decimal('18.00')  # $20 - 10% = $18
        assert summary['tax'] == Decimal('1.44')        # 8% of $18 = $1.44
        assert summary['total'] == Decimal('19.44')     # $18 + $1.44 = $19.44

/zen:secaudit --file order_refactored.py --language python --level strict