ASP.NET MVC5（七）SportsStore购物车

public class CartModelBinder : IModelBinder
{
    private const string sessionKey = "Cart";

    public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
    {
        // 通过会话获取Cart
        Cart cart = null;
        if (controllerContext.HttpContext.Session != null)
        {
            cart = (Cart)controllerContext.HttpContext.Session[sessionKey];
        }

        // 若会话中没有Cart，创建一个
        if (cart == null)
        {
            cart = new Cart();
            if (controllerContext.HttpContext.Session != null)
            {
                controllerContext.HttpContext.Session[sessionKey] = cart;
            }
        }

        // 返回cart
        return cart;
    }
}

protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();
    RouteConfig.RegisterRoutes(RouteTable.Routes);

    ModelBinders.Binders.Add(typeof(Cart), new CartModelBinder());	// 使用CartModelBinder类创建Cart对象
}

public class CartController : Controller
{
    private IProductRepository repository;

    public CartController(IProductRepository repo)
    {
        repository = repo;
    }

    public ViewResult Index(Cart cart, string returnUrl)
    {
        return View(new CartIndexViewModel
        {
            ReturnUrl = returnUrl,
            Cart = cart
        });
    }

    public RedirectToRouteResult AddToCart(Cart cart, int productId, string returnUrl)
    {
        Product product = repository.Products.FirstOrDefault(p => p.ProductID == productId);
        if (product != null)
        {
            cart.AddItem(product, 1);
        }
        return RedirectToAction("Index", new { returnUrl });
    }

    public RedirectToRouteResult RemoveFromCart(Cart cart, int productId, string returnUrl)
    {
        Product product = repository.Products.FirstOrDefault(p => p.ProductID == productId);
        if (product != null)
        {
            cart.Remove(product);
        }
        return RedirectToAction("Index", new { returnUrl });
    }
}

[TestClass]
public class CartTests
{
    // ...其他测试方法

    /// <summary>
    /// 测试添加到购物车
    /// </summary>
    [TestMethod]
    public void Can_Add_To_Cart()
    {
        // 准备——创建模仿存储库
        Mock<IProductRepository> mock = new Mock<IProductRepository>();
        mock.Setup(m => m.Products).Returns(new Product[] {
            new Product { ProductID = 1, Name = "P1", Category = "Apples" },
        }.AsQueryable());

        // 准备——创建Cart
        Cart cart = new Cart();

        // 准备——创建控制器
        CartController target = new CartController(mock.Object);

        // 动作——对cart添加一个产品
        target.AddToCart(cart, 1, null);

        // 断言
        Assert.AreEqual(cart.Lines.Count(), 1);
        Assert.AreEqual(cart.Lines.ToArray()[0].Product.ProductID, 1);
    }

    /// <summary>
    /// 测试添加购物车后重定向到Index视图
    /// </summary>
    [TestMethod]
    public void Adding_Product_To_Cart_Goes_To_Cart_Screen()
    {
        // 准备——创建模仿存储库
        Mock<IProductRepository> mock = new Mock<IProductRepository>();
        mock.Setup(m => m.Products).Returns(new Product[] {
            new Product { ProductID = 1, Name = "P1", Category = "Apples" },
        }.AsQueryable());

        // 准备——创建Cart
        Cart cart = new Cart();

        // 准备——创建控制器
        CartController target = new CartController(mock.Object);

        // 动作——向cart添加一个产品
        RedirectToRouteResult result = target.AddToCart(cart, 1, "myUrl");

        // 断言
        Assert.AreEqual(result.RouteValues["action"], "Index");
        Assert.AreEqual(result.RouteValues["returnUrl"], "myUrl");
    }

    /// <summary>
    /// 测试returnUrl是否正确传递到Index动作方法
    /// </summary>
    [TestMethod]
    public void Can_View_Cart_Contents()
    {
        // 准备——创建Cart
        Cart cart = new Cart();

        // 准备——创建控制器
        CartController target = new CartController(null);

        // 动作——调用Index动作方法
        CartIndexViewModel result = (CartIndexViewModel)target.Index(cart, "myUrl").ViewData.Model;

        // 断言
        Assert.AreSame(result.Cart, cart);
        Assert.AreEqual(result.ReturnUrl, "myUrl");
    }
}

public PartialViewResult Summary(Cart cart)
{
    return PartialView(cart);
}

public class ShippingDetails
{
    [Required(ErrorMessage = "Please enter a name")]
    public string Name { get; set; }

    [Required(ErrorMessage = "Please enter the first address line")]
    public string Line1 { get; set; }
    public string Line2 { get; set; }
    public string Line3 { get; set; }

    [Required(ErrorMessage = "Please enter a city name")]
    public string City { get; set; }

    [Required(ErrorMessage = "Please enter a state name")]
    public string State { get; set; }
    public string Zip { get; set; }

    [Required(ErrorMessage = "Please enter a country name")]
    public string Country { get; set; }
    public bool GiftWrap { get; set; }
}

public ViewResult Checkout()
{
    return View(new ShippingDetails());
}

//...
[Display(Name = "Line 1")]
public string Line1 { get; set; }
[Display(Name = "Line 2")]
public string Line2 { get; set; }
[Display(Name = "Line 3")]
public string Line3 { get; set; }
//...

public interface IOrderProcessor
{
    void ProcessOrder(Cart cart, ShippingDetails shippingDetails);
}

/// <summary>
/// 配置.NET邮件类
/// </summary>
public class EmailSettings
{
    public string MailToAddress = "orders@example.com";
    public string MailFromAddress = "sportsstore@example.com";
    public bool UseSsl = true;
    public string Username = "MySmtpUsername";
    public string Password = "MySmtpPassword";
    public string ServerName = "smtp.example.com";
    public int ServerPort = 587;
    public bool WriteAsFile = false;	// 如果没有SMTP服务器，此项可设置为true，将邮件消息作为文件写到指定目录
    public string FileLocation = @"e:\sports_store_emails";
}

public class EmailOrderProcessor : IOrderProcessor
{
    private EmailSettings emailSettings;

    public EmailOrderProcessor(EmailSettings settings)
    {
        emailSettings = settings;
    }

    public void ProcessOrder(Cart cart, ShippingDetails shipppingInfo)
    {
        using (var smtpClient = new SmtpClient())
        {
            smtpClient.EnableSsl = emailSettings.UseSsl;
            smtpClient.Host = emailSettings.ServerName;
            smtpClient.Port = emailSettings.ServerPort;
            smtpClient.UseDefaultCredentials = false;
            smtpClient.Credentials = new NetworkCredential(emailSettings.Username, emailSettings.Password);

            if (emailSettings.WriteAsFile)
            {
                smtpClient.DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory;
                smtpClient.PickupDirectoryLocation = emailSettings.FileLocation;
                smtpClient.EnableSsl = false;
            }

            StringBuilder body = new StringBuilder()
                .AppendLine("A new order has been submitted")
                .AppendLine("---")
                .AppendLine("Items:");

            foreach (var line in cart.Lines)
            {
                var subtotal = line.Product.Price * line.Quantity;
                body.AppendFormat("{0} x {1} (subtotal: {2:c})",
                                  line.Quantity,
                                  line.Product.Name,
                                  subtotal);
            }

            body.AppendFormat("Total order value: {0:c}", cart.ComputeTotalValue())
                .AppendLine("---")
                .AppendLine("Ship to:")
                .AppendLine(shipppingInfo.Name)
                .AppendLine(shipppingInfo.Line1)
                .AppendLine(shipppingInfo.Line2 ?? "")
                .AppendLine(shipppingInfo.Line3 ?? "")
                .AppendLine(shipppingInfo.City)
                .AppendLine(shipppingInfo.State ?? "")
                .AppendLine(shipppingInfo.Country)
                .AppendLine(shipppingInfo.Zip)
                .AppendLine("---")
                .AppendFormat("Gift wrap: {0}", shipppingInfo.GiftWrap ? "yes" : "No");

            MailMessage mailMessage = new MailMessage(
                emailSettings.MailFromAddress,  // From
                emailSettings.MailToAddress,    // To
                "New order submitted!",         // Subject
                body.ToString());               // Body

            if (emailSettings.WriteAsFile)
            {
                mailMessage.BodyEncoding = Encoding.ASCII;
            }

            smtpClient.Send(mailMessage);
        }
    }
}

private void AddBindings()
{
    kernel.Bind<IProductRepository>().To<EFProductRepository>();

    EmailSettings emailSettings = new EmailSettings
    {
        WriteAsFile = bool.Parse(ConfigurationManager.AppSettings["Email.WriteAsFile"] ?? "false")
    };

    kernel.Bind<IOrderProcessor>().To<EmailOrderProcessor>().WithConstructorArgument("settings", emailSettings);
}

public class CartController : Controller
{
    private IProductRepository repository;
    private IOrderProcessor orderProcessor;

    public CartController(IProductRepository repo, IOrderProcessor proc)
    {
        repository = repo;
        orderProcessor = proc;
    }

    // ...

    [HttpPost]
    public ViewResult Checkout(Cart cart, ShippingDetails shippingDetails)
    {
        if (cart.Lines.Count() == 0)
        {
            ModelState.AddModelError("", "Sorry, your cart is empty!");
        }
        if (ModelState.IsValid)
        {
            orderProcessor.ProcessOrder(cart, shippingDetails);
            cart.Clear();
            return View("Completed");
        }
        else
        {
            return View(shippingDetails);
        }
    }
}

[TestClass]
public class CartTests
{
    // 其他测试方法...

    /// <summary>
    /// 测试确保不能对空购物车进行结算。返回视图是默认视图，且传递给视图的模型状态被标记为非法
    /// </summary>
    [TestMethod]
    public void Cannot_Checkout_Empty_Cart()
    {
        // 准备——创建一个模仿的订单处理器
        Mock<IOrderProcessor> mock = new Mock<IOrderProcessor>();

        // 准备——创建一个空的购物车
        Cart cart = new Cart();

        // 准备——创建一个运输信息实例
        ShippingDetails shippingDetails = new ShippingDetails();

        // 准备——创建一个控制器实例
        CartController target = new CartController(null, mock.Object);

        // 动作
        ViewResult result = target.Checkout(cart, shippingDetails);

        // 断言——检查，订单尚未传递给处理器
        mock.Verify(m => m.ProcessOrder(It.IsAny<Cart>(), It.IsAny<ShippingDetails>()), Times.Never());

        // 断言——检查，该方法返回的是默认视图
        Assert.AreEqual("", result.ViewName);

        // 断言——检查，给视图传递的是一个非法模型
        Assert.AreEqual(false, result.ViewData.ModelState.IsValid);
    }

    /// <summary>
    /// 把错误注入到视图模型，模仿客户输入非法运货数据
    /// </summary>
    [TestMethod]
    public void Cannot_Checkout_Invalid_ShippingDetails()
    {
        // 准备——创建一个模仿的订单处理器
        Mock<IOrderProcessor> mock = new Mock<IOrderProcessor>();

        // 准备——创建含有一个物品的购物车
        Cart cart = new Cart();
        cart.AddItem(new Product(), 1);

        // 准备——创建一个控制器实例
        CartController target = new CartController(null, mock.Object);

        // 准备——把一个错误添加到模型
        target.ModelState.AddModelError("error", "error");

        // 动作——试图结算
        ViewResult result = target.Checkout(cart, new ShippingDetails());

        // 断言——检查，订单尚未传递给处理器
        mock.Verify(m => m.ProcessOrder(It.IsAny<Cart>(), It.IsAny<ShippingDetails>()), Times.Never());

        // 断言——检查，方法返回的是默认视图
        Assert.AreEqual("", result.ViewName);

        // 断言——检查，我们正在把一个非法模型传递给视图
        Assert.AreEqual(false, result.ViewData.ModelState.IsValid);
    }

    /// <summary>
    /// 确保在适当的时候能够处理订单
    /// </summary>
    [TestMethod]
    public void Can_Checkout_And_Submit_Order()
    {
        // 准备——创建一个模仿订单处理器
        Mock<IOrderProcessor> mock = new Mock<IOrderProcessor>();

        // 准备——创建含有一个物品的购物车
        Cart cart = new Cart();
        cart.AddItem(new Product(), 1);

        // 准备——创建一个控制器实例
        CartController target = new CartController(null, mock.Object);

        // 动作——试图结算
        ViewResult result = target.Checkout(cart, new ShippingDetails());

        // 断言——检查，订单已经被传递给处理器
        mock.Verify(m => m.ProcessOrder(It.IsAny<Cart>(), It.IsAny<ShippingDetails>()), Times.Once());

        // 断言——检查，方法返回的是“Completed”视图
        Assert.AreEqual("Completed", result.ViewName);

        // 断言——检查，我们正在把一个有效的模型传递给视图
        Assert.AreEqual(true, result.ViewData.ModelState.IsValid);
    }
}