[ExpectedException(typeof(ArgumentOutOfRangeException))] // 指定计划抛出的异常
public void TestMethod1()
{
Mock<IDiscountHelper> mocker = new Mock<IDiscountHelper>(); // 创建Mock对象，伪造一个IDiscountHelper的实现
/* 装载实现的GetDiscount方法。
* Mock的装载方式是倒序，因此要最先写最基础的场景，往下装载特殊的场景。
*/
mocker.Setup(m => m.GetDiscount(It.IsAny<decimal>())).Returns<decimal>(total => total); // 装载方法
mocker.Setup(m => m.GetDiscount(It.Is<decimal>(v => v == 0))).Throws<ArgumentOutOfRangeException>(); // 参数等于0时，抛出异常
mocker.Setup(m => m.GetDiscount(It.Is<decimal>(v => v > 100))).Returns<decimal>(total => total * 0.9M); // 参数大于100时，返回九折
mocker.Setup(m => m.GetDiscount(It.IsInRange<decimal>(10, 100, Range.Inclusive))).Returns<decimal>(total => total - 5); // 参数在10与100之间，包括10和100，返回-5
var test = new LinqValueCalculator(mocker.Object);
//decimal zero = test.ValueProducts(InitProducts(0M));
decimal five = test.ValueProducts(InitProducts(5M));
decimal ten = test.ValueProducts(InitProducts(10M));
decimal fifty = test.ValueProducts(InitProducts(50M));
decimal hundred = test.ValueProducts(InitProducts(100M));
decimal twoHundred = test.ValueProducts(InitProducts(200M));
Assert.AreEqual(5M, five, "Test Five failed");
Assert.AreEqual(5M, ten, "Test Ten failed");
Assert.AreEqual(45M, fifty, "Test Fifty failed");
Assert.AreEqual(95M, hundred, "Test Hundred failed");
Assert.AreEqual(200 * 0.9M, twoHundred, "Test TwoHundred failed");
test.ValueProducts(InitProducts(0M));
}
public void PassThroughVariableDiscounts()
{
// Организация
var mock = new Mock <IDiscountHelper>();
mock.Setup(helper => helper.ApplyDiscount(It.IsAny <decimal>()))
.Returns <decimal>(total => total);
mock.Setup(helper => helper.ApplyDiscount(It.Is <decimal>(arg => arg == 0)))
.Throws <ArgumentOutOfRangeException>();
mock.Setup(helper => helper.ApplyDiscount(It.Is <decimal>(arg => arg > 100)))
.Returns <decimal>(arg => arg * 0.9M);
mock.Setup(helper => helper.ApplyDiscount(It.IsInRange <decimal>(10, 100, Range.Inclusive)))
.Returns <decimal>(arg => arg - 5);
IValueCalculator target = new LinqValueCalculator(mock.Object);
// Действие
var fiveDollarDiscount = target.ValueProducts(CreateProducts(5));
var tenDollarDiscount = target.ValueProducts(CreateProducts(10));
var fiftyDollarDiscount = target.ValueProducts(CreateProducts(50));
var hundredDollarDiscount = target.ValueProducts(CreateProducts(100));
var fiveHundredDollarDiscount = target.ValueProducts(CreateProducts(500));
// Утверждение
Assert.AreEqual(5, fiveDollarDiscount, "$5 Fail");
Assert.AreEqual(5, tenDollarDiscount, "$10 Fail");
Assert.AreEqual(45, fiftyDollarDiscount, "$50 Fail");
Assert.AreEqual(95, hundredDollarDiscount, "$100 Fail");
Assert.AreEqual(450, fiveHundredDollarDiscount, "$500 Fail");
target.ValueProducts(CreateProducts(0));
}
public void Sum_Product_Correctly()
{
// arrange
//var discounter = new MinumiumDiscountHelper();
//var target = new LinqValueCalculator(discounter);
//var goalTotal = products.Sum(p => p.Price);
// create strongly typed object:: it can be any type, it only must implement
// the interface
Mock <IDiscountHelper> mok = new Mock <IDiscountHelper>();
// define how the object should behave, so to isolate a single behaviour
// and keep focused on the unit test
mok.Setup(m => m.ApplayDiscount(It.IsAny <decimal>()))
.Returns <decimal>(total => total);
var target = new LinqValueCalculator(mok.Object);
// act
var result = target.ValueProducts(products);
// Assert
Assert.AreEqual(products.Sum(p => p.Price), result, "Sum of products is incorrect");
}
public void Sum_Products_Correctly()
//{
// var disounter=new MinimumDiscountHelper();
// var target = new LinqValueCalculator(disounter);
// var goalTotal = products.Sum(e => e.Price);
{ // Arrange
//create a mock IDiscountHelper implementation
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
//specify the way that MCOK behaves,Setup method to add a method to my mock object.
//When I call the Setup method, Moq passes me the interface that I have asked it to implement
//d ApplyDiscount method, only method in the IDiscountHelper interface, and the method I need to test the
//LinqValueCalculator class.
//The It class defines a number of methods that are used with generic type parameters
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
//lambda expression, Moq passes me a value of the type I receive in the ApplyDiscount
//I create a pass-through method , in which I return the value that is passed to the mock
//ApplyDiscount method without performing any operations on it.
var target = new LinqValueCalculator(mock.Object);
// Object property returns an implementation of the IDiscountHelper interface
// where the ApplyDiscount method returns the value of the decimal parameter it is passed.
// action
var result = target.ValueProducts(products);
Assert.AreEqual(products.Sum(e => e.Price), result);
//---------------------- Complex Example----------------------------------
}
public void Sum_Products_Correctly()
{
////arrange
//var discounter = new MinimumDiscountHelper();
//var target = new LinqValueCalculator(discounter);
//var goalTotal = products.Sum(e => e.Price);
////act
//var result = target.ValueProducts(products);
////assert
//Assert.AreEqual(goalTotal, result);
//arrange
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
var target = new LinqValueCalculator(mock.Object);
//act
var result = target.ValueProducts(products);
//assert
Assert.AreEqual(products.Sum(e => e.Price), result);
}
public void Pass_Through_Variable_Discounts()
{
//arrange
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>()))
.Returns <decimal>(total => total);
mock.Setup(m => m.ApplyDiscount(It.Is <decimal>(v => v == 0)))
.Throws <ArgumentOutOfRangeException>();
mock.Setup(m => m.ApplyDiscount(It.Is <decimal>(v => v > 100)))
.Returns <decimal>(total => (total * 0.9m));
mock.Setup(m => m.ApplyDiscount(It.IsInRange <decimal>(10, 100, Range.Inclusive)))
.Returns <decimal>(total => total - 5);
var target = new LinqValueCalculator(mock.Object);
//act
decimal FiveDollarDiscount = target.ValueProducts(createProduct(5));
decimal TenDollarDiscount = target.ValueProducts(createProduct(10));
decimal FiftyDollarDiscount = target.ValueProducts(createProduct(50));
decimal HundredDollarDiscount = target.ValueProducts(createProduct(100));
decimal FiveHundredDollarDiscount = target.ValueProducts(createProduct(500));
//assert
Assert.AreEqual(5, FiveDollarDiscount, "$5 Fail");
Assert.AreEqual(10, TenDollarDiscount, "$10 Fail");
Assert.AreEqual(50, FiftyDollarDiscount, "$50 Fail");
Assert.AreEqual(100, HundredDollarDiscount, "$100 Fail");
Assert.AreEqual(500, FiveHundredDollarDiscount, "$500 Fail");
target.ValueProducts(createProduct(0));
}
public void Pass_Trough_Variable_Discounts()
{
// arrange
var mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
mock.Setup(m => m.ApplyDiscount(It.Is <decimal>(v => v == 0))).Throws <ArgumentOutOfRangeException>();
mock.Setup(m => m.ApplyDiscount(It.Is <decimal>(v => v > 100))).Returns <decimal>(total => total * 0.9M);
mock.Setup(m => m.ApplyDiscount(It.IsInRange(10, 100, Range.Exclusive))).Returns <decimal>(total => total - 5);
var target = new LinqValueCalculator(mock.Object);
// act
var fiveDollarDiscount = target.ValueProducts(CreateProduct(5));
var tenDollarDiscount = target.ValueProducts(CreateProduct(10));
var fiftyDollarDiscount = target.ValueProducts(CreateProduct(50));
var hundredDollarDiscount = target.ValueProducts(CreateProduct(100));
var fiveHundredDollarDiscount = target.ValueProducts(CreateProduct(500));
// assert
Assert.AreEqual(5, fiveDollarDiscount);
Assert.AreEqual(10, tenDollarDiscount);
Assert.AreEqual(50, fiftyDollarDiscount);
Assert.AreEqual(100, hundredDollarDiscount);
Assert.AreEqual(500, fiveHundredDollarDiscount);
}
public void Sum_Products_Correctly()
{
//准备
#region 使用 Moq
// 1、创建模仿对象
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
// 2、选择方法:Setup，并通过 It 类设置需要的参数信息
// 3、定义结果：Returns，并用 lambda 表达式在 Return 方法中建立具体行为
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
// 4、使用模仿对象：mock.Object，通过获取 Object 属性的值来获取具体实现，如这里的实现是 IDiscountHelper 接口的实现
var target = new LinqValueCalculator(mock.Object);
// *** 优点：使用 Moq 会使单元测试只检查 LinqValueCalculator 对象的行为，并不依赖任何 Models 文件夹中 IDiscountHelper 的真实实现。***
#endregion End 使用 Moq
//var dicounter = new MinimumDiscountHelper();
//var target = new LinqValueCalculator(dicounter);
var goalTotal = _products.Sum(e => e.Price);
//动作
var result = target.ValueProducts(_products);
//断言
Assert.AreEqual(goalTotal, result);
}
public void ValueProducts_WorksWithMinimumDiscountHelper()
{
// Arrange
var mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.Is <decimal>(p => p < 0)))
.Throws <ArgumentOutOfRangeException>();
mock.Setup(m => m.ApplyDiscount(It.IsInRange <decimal>(0, 9, Range.Inclusive)))
.Returns <decimal>(p => p);
mock.Setup(m => m.ApplyDiscount(It.IsInRange <decimal>(10, 100, Range.Inclusive)))
.Returns <decimal>(p => p - 5);
mock.Setup(m => m.ApplyDiscount(It.Is <decimal>(p => p > 100)))
.Returns <decimal>(p => p * 0.9M);
var calc = new LinqValueCalculator(mock.Object);
// Act
var discounted200Dol = calc.ValueProducts(GetProducts(200));
var discounted100Dol = calc.ValueProducts(GetProducts(100));
var discounted50Dol = calc.ValueProducts(GetProducts(50));
var discounted10Dol = calc.ValueProducts(GetProducts(10));
var discounted7Dol = calc.ValueProducts(GetProducts(7));
var discounted0Dol = calc.ValueProducts(GetProducts(0));
// Assert
Assert.AreEqual(180, discounted200Dol, "$200 wrong");
Assert.AreEqual(95, discounted100Dol, "$100 wrong");
Assert.AreEqual(45, discounted50Dol, "$50 wrong");
Assert.AreEqual(5, discounted10Dol, "$10 wrong");
Assert.AreEqual(7, discounted7Dol, "$7 wrong");
Assert.AreEqual(0, discounted0Dol, "$0 wrong");
calc.ValueProducts(GetProducts(-5));
}
public void PassThroughVariableDiscounts()
{
//arrange
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(mockedObject => mockedObject.ApplyDiscount(It.IsAny <decimal>()))
.Returns <decimal>(valuePassed => valuePassed);
mock.Setup(mockedObject => mockedObject.ApplyDiscount(It.Is <decimal>(value => value == 0)))
.Throws <System.ArgumentOutOfRangeException>();
mock.Setup(mockedObject => mockedObject.ApplyDiscount(It.Is <decimal>(value => value > 100)))
.Returns <decimal>(passedVal => (passedVal * 0.9M));
mock.Setup(mockedObject => mockedObject.ApplyDiscount(It.IsInRange <decimal>(10, 100, Range.Inclusive)))
.Returns <decimal>(passedVal => (passedVal - 5M));
var target = new LinqValueCalculator(mock.Object);
//act
decimal fiveDollarDiscount = target.ValueProducts(createProduct(5));
decimal tenDollarDiscount = target.ValueProducts(createProduct(10));
decimal fiftyDollarDiscount = target.ValueProducts(createProduct(50));
decimal hundredDollarDiscount = target.ValueProducts(createProduct(100));
decimal fiveHundredDollarDiscount = target.ValueProducts(createProduct(500));
//assert
Assert.AreEqual(5, fiveDollarDiscount);
Assert.AreEqual(5, tenDollarDiscount);
Assert.AreEqual(45, fiftyDollarDiscount);
Assert.AreEqual(95, hundredDollarDiscount);
Assert.AreEqual(450, fiveHundredDollarDiscount);
target.ValueProducts(createProduct(0));
}
public void Pass_Throungh_Variable_Discount()
{
// Arrange
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>()))
.Returns <decimal>(total => total);
mock.Setup(m => m.ApplyDiscount(It.Is <decimal>(v => v == 0)))
.Throws <System.ArgumentOutOfRangeException>();
mock.Setup(m => m.ApplyDiscount(It.Is <decimal>(v => v > 100)))
.Returns <decimal>(total => total * 0.9M);
mock.Setup(m => m.ApplyDiscount(It.IsInRange <decimal>(10, 100, Range.Inclusive))).Returns <decimal>(total => total - 5);
var target = new LinqValueCalculator(mock.Object);
// Act
decimal doolars100 = target.ValueProduct(CreateNewProductsSetPrice(100));
decimal dollars0 = target.ValueProduct(CreateNewProductsSetPrice(0));
decimal dollars10 = target.ValueProduct(CreateNewProductsSetPrice(10));
decimal dollars500 = target.ValueProduct(CreateNewProductsSetPrice(500));
decimal dollars5 = target.ValueProduct(CreateNewProductsSetPrice(5));
// Assert
Assert.AreEqual(95, doolars100, "fail100$");
Assert.AreEqual(0, dollars0, "exeption 0$");
Assert.AreEqual(5, dollars10, "fail 10$");
Assert.AreEqual(5, dollars5, "fail 5$");
Assert.AreEqual(500, dollars500, "fail 500$");
target.ValueProduct(CreateNewProductsSetPrice(0));
}
public void Sum_Products_Correctly()
{
// arrange
// makes a new strongly typed Mock<IDiscountHelper> object
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
// specifying behavior of object
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())) // tells Moq to apply the behavior being defined whenever it encounters a decimal
.Returns <decimal>(total => total); // returns defines the results
var target = new LinqValueCalculator(mock.Object); // reads the value of the Object property of the Mock<IDiscountHelper> object
#region Without using Moq
/* Without Using Moq
* var discounter = new MinimumDiscountHelper();
* var target = new LinqValueCalculator(discounter);
* var goalTotal = products.Sum(e => e.Price);
*/
#endregion
// act
var result = target.ValueProducts(products);
// assert
Assert.AreEqual(products.Sum(e => e.Price), result);
#region Without using Moq
// Assert.AreEqual(goalTotal, result);
#endregion
// benefit of this Moqis that the unit test only checks the behavior of the LinqValueCalculator object and does not depend on any of the real
// implementations of the IDiscountHelper interface in the Models folder...
// this makes it easier to tell where a problem is occuring if a test fails
}
public void PassThroughVariableDiscounts()
{
// var discounter = new MinimumDiscountHelper();
// var target = new LinqValueCalculator(discounter);
// var goalToal = products.Sum(prod => prod.Price);
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(moq => moq.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
mock.Setup(moq => moq.ApplyDiscount(It.Is <decimal>(v => v == 0))).Throws <ArgumentOutOfRangeException>();
mock.Setup(moq => moq.ApplyDiscount(It.Is <decimal>(v => v > 100))).Returns <decimal>(total => total * 0.9M);
mock.Setup(moq => moq.ApplyDiscount(It.IsInRange <decimal>(10, 100, Range.Inclusive))).Returns <decimal>(total => total - 5);
var target = new LinqValueCalculator(mock.Object);
var FiveDollarDiscount = target.ValueProducts(createProduct(5));
var TenDollarDiscount = target.ValueProducts(createProduct(10));
var FiftyDollarDiscount = target.ValueProducts(createProduct(50));
var HundredDollarDiscount = target.ValueProducts(createProduct(100));
var FiveHundredDollarDiscount = target.ValueProducts(createProduct(500));
Assert.AreEqual(5, FiveDollarDiscount, "Niepowodzenie 5 zł ");
Assert.AreEqual(5, TenDollarDiscount, "Niepowodzenie 10 zł ");
Assert.AreEqual(45, FiftyDollarDiscount, "Niepowodzenie 50 zł ");
Assert.AreEqual(95, HundredDollarDiscount, "Niepowodzenie 100 zł ");
Assert.AreEqual(450, FiveHundredDollarDiscount, "Niepowodzenie 500 zł ");
target.ValueProducts(createProduct(0));
}
public void Pass_Through_Variable_Discounts()
{
Mock<IDiscountHelper> mock = new Mock<IDiscountHelper>();
// Условие, если ничего другое не подходит
mock.Setup(m => m.ApplyDiscount(It.IsAny<decimal>()))
.Returns<decimal>(total => total);
// Условие, если переданное значение не является положительным
mock.Setup(m => m.ApplyDiscount(It.Is<decimal>(p => p <= 0)))
.Throws<System.ArgumentOutOfRangeException>();
// Условие, если переданное значение больше 100
mock.Setup(m => m.ApplyDiscount(It.Is<decimal>(p => p > 100)))
.Returns<decimal>(total => total * 0.9m);
// Условие, если переданное значение входит в интервал от 10 до 100 включительно
mock.Setup(m => m.ApplyDiscount(It.IsInRange<decimal>(10, 100, Range.Inclusive)))
.Returns<decimal>(total => total - 5);
var target = new LinqValueCalculator(mock.Object);
// Создание тестируемых значений
decimal FiveDollarsDiscount = target.ValueProducts(createProduct(5));
decimal TenDollarsDiscount = target.ValueProducts(createProduct(10));
decimal FiftenDollarsDiscount = target.ValueProducts(createProduct(50));
decimal OneHandredDollarsDiscount = target.ValueProducts(createProduct(100));
decimal TwoHandredDollarsDiscount = target.ValueProducts(createProduct(200));
Assert.AreEqual(5, FiveDollarsDiscount, "Five dollars discount wrong");
Assert.AreEqual(5, TenDollarsDiscount, "Five dollars discount wrong");
Assert.AreEqual(45, FiftenDollarsDiscount, "Five dollars discount wrong");
Assert.AreEqual(95, OneHandredDollarsDiscount, "Five dollars discount wrong");
Assert.AreEqual(180, TwoHandredDollarsDiscount, "Five dollars discount wrong");
target.ValueProducts(createProduct(0));
}
public void Pass_Through_Variable_Discounts()
{
// Arrange
// create and setup the mock object to mimic functionality of the MinimalDiscountHelper (as of when the test was created)
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
mock.Setup(m => m.ApplyDiscount(It.Is <decimal>(v => v == 0))).Throws <System.ArgumentOutOfRangeException>();
mock.Setup(m => m.ApplyDiscount(It.Is <decimal>(v => v > 100))).Returns <decimal>(total => total * 0.9M);
mock.Setup(m => m.ApplyDiscount(It.IsInRange <decimal>(10, 100, Range.Inclusive))).Returns <decimal>(total => total - 5);
var target = new LinqValueCalculator(mock.Object);
// Act
decimal FiveDollarDiscount = target.ValueProducts(createProduct(5));
decimal TenDollarDiscount = target.ValueProducts(createProduct(10));
decimal FiftyDollarDiscount = target.ValueProducts(createProduct(50));
decimal HundredDollarDiscount = target.ValueProducts(createProduct(100));
decimal FiveHundredDollarDiscount = target.ValueProducts(createProduct(500));
// Assertion
Assert.AreEqual(5, FiveDollarDiscount, "$5 Fail");
Assert.AreEqual(5, TenDollarDiscount, "$10 Fail");
Assert.AreEqual(45, FiftyDollarDiscount, "$50 Fail");
Assert.AreEqual(95, HundredDollarDiscount, "$100 Fail");
Assert.AreEqual(450, FiveHundredDollarDiscount, "$500 Fail");
target.ValueProducts(createProduct(0));
}
public void Pass_Through_Variable_Discounts()
{
// arrange
var discountMock = new Mock <IDiscountHelper>();
discountMock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>()))
.Returns <decimal>(t => t);
discountMock.Setup(m => m.ApplyDiscount(It.Is <decimal>(v => v == 0)))
.Throws <ArgumentOutOfRangeException>();
discountMock.Setup(m => m.ApplyDiscount(It.Is <decimal>(v => v > 100)))
.Returns <decimal>(t => t * 0.9M);
discountMock.Setup(m => m.ApplyDiscount(It.IsInRange <decimal>(10, 100, Range.Inclusive)))
.Returns <decimal>(t => t - 5);
var target = new LinqValueCalculator(discountMock.Object);
// act
var fiveDollarDiscount = target.ValueProducts(CreateProduct(5));
var tenDollarDiscount = target.ValueProducts(CreateProduct(10));
var fiftyDollarDiscount = target.ValueProducts(CreateProduct(50));
var hundredDollarDiscount = target.ValueProducts(CreateProduct(100));
var fiveHundredDollarDiscount = target.ValueProducts(CreateProduct(500));
// Assert
Assert.AreEqual(5, fiveDollarDiscount, "$5 потеряем");
Assert.AreEqual(5, tenDollarDiscount, "$10 потеряем");
Assert.AreEqual(45, fiftyDollarDiscount, "$50 потеряем");
Assert.AreEqual(95, hundredDollarDiscount, "$100 потеряем");
Assert.AreEqual(450, fiveHundredDollarDiscount, "$500 Fail");
target.ValueProducts(CreateProduct(0));
}
public void Sum_Products_Correctly()
{
// arrange
//Bước đầu tiên là cho Moq biết mình muốn làm việc với loại
//đối tượng nào. Moq dựa rất nhiều vào các tham số kiểu, và
//ta có thể thấy điều này theo cách mà ta nói với Moq rằng
//ta muốn tạo ra một thực thi giả lập IDiscountHelper
//chúng ta tạo ra một đối tượng Mock <IDiscountHelper>
//để nói cho Moq biết type mà Moq sẽ xử lý
//Đây là interface IDiscountHelper cho unit test của
//ta, nhưng nó có thể là bất kỳ loại nào mà bạn muốn
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
//Chúng cần xác định cách hoạt động của đối tượng vừa tạo.
//Đây là trọng tâm của quá trình mô phỏng và nó cho phép chúng ta
//đảm bảo rằng ta thiết lập một hành vi cơ sở trong đối tượng giả,
//mà ta có thể sử dụng để kiểm tra chức năng của đối tượng đích của
//ta trong Unit test.
//Lớp It định nghĩa một số phương thức được sử dụng với các tham số
//kiểu generic. Trong trường hợp này, ta đã gọi phương thức IsAny
//bằng cách sử dụng decimal làm kiểu generic. Điều này để Moq
//áp dụng các hành vi ta định nghĩa bất cứ khi nào ta gọi phương thức
//ApplyDiscount với bất kỳ giá trị thập phân nào.
//Phương thức Returns cho phép ta chỉ định kết quả mà Moq sẽ trả về
//khi ta gọi phương thức giả của mình. Tôi chỉ định loại kết quả bằng
//cách sử dụng tham số kiểu và chỉ định kết quả bằng cách sử dụng
//biểu thức lambda.
//Returns<decimal> nói với Moq rằng ta sẽ trả về một giá trị thập phân.
//Đối với biểu thức lambda, Moq chuyển cho ta một giá trị của kiểu
//nhận được trong phương thức ApplyDiscount. Ta tạo ra một phương thức
//pass-through trong bên dưới, trong đó ta trả về giá trị được truyền vào
//phương thức ApplyDiscount giả lập mà không thực hiện bất kỳ thao
//tác nào trên nó.
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>()))
.Returns <decimal>(total => total);
//Bước cuối cùng là sử dụng đối tượng giả trong thử nghiệm,
// bằng cách đọc giá trị của thuộc tính Object của đối tượng
// Mock <IDiscountHelper>:
var target = new LinqValueCalculator(mock.Object);
// act
var result = target.ValueProducts(products);
// assert
Assert.AreEqual(products.Sum(e => e.Price), result);
//Tóm tắt ví dụ: thuộc tính Object trả về một triển khai của
//interface IDiscountHelper trong đó phương thức ApplyDiscount
//trả về giá trị của tham số thập phân mà nó được truyền.
//Điều này giúp ta dễ dàng để thực hiện kiểm tra đơn vị
//bởi vì ta có thể tổng hợp giá của các đối tượng
//sản phẩm thử nghiệm của chính mình và kiểm tra xem
//ta có nhận được cùng một giá trị trở lại từ đối tượng
//LinqValueCalculator hay không.
}
public void SumProductsCorrectly()
{
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>()))
.Returns <decimal>(total => total);
var target = new LinqValueCalculator(mock.Object);
var result = target.ValueProducts(products);
Assert.AreEqual(products.Sum(e => e.Price), result);
}
// GET: Home
public ActionResult Index()
{
LinqValueCalculator calc = new LinqValueCalculator();
ShoppingCart cart = new ShoppingCart(calc)
{
Products = products
};
decimal totalValue = cart.CalculateProductTotal();
return(View(totalValue));
}
public void ValueProducts_TotalPrice500_Return500()
{
var mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>()))
.Returns <decimal>(price => price);
var calc = new LinqValueCalculator(mock.Object);
Assert.AreEqual(500, calc.ValueProducts(products));
}
public void Sum_Products_Corretly()
{
Mock<IDiscountHelper> mock = new Mock<IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny<decimal>()))
.Returns<decimal>(total => total);
var target = new LinqValueCalculator(mock.Object);
var result = target.ValueProducts(products);
Assert.AreEqual(result, products.Sum(p => p.Price));
}
public void TestMethod1()
{
Mock <IDiscounterHelper> mock = new Mock <IDiscounterHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
var target = new LinqValueCalculator(mock.Object);
var goal = products.Sum(s => s.Price);
var result = target.ValueProducts(products);
Assert.AreEqual(goal, result);
}
public void IsSumThe_Same_With_Dummy_Discounter()
{
//Arrange
IDiscountCalculator calc = GetDiscounter(0);
LinqValueCalculator linqCalc = new LinqValueCalculator(calc);
//Act
decimal finalPrice = linqCalc.GetTotalValueOfProducts(_products);
//Assert
Assert.AreEqual(80, finalPrice);
}
public void IsSumThe_Same_With_Dummy_Discounter_Return_Value_For_10_Percentage_Discount()
{
//Arrange
IDiscountCalculator calc = GetDiscounter(10);
LinqValueCalculator linqCalc = new LinqValueCalculator(calc);
//Act
decimal finalPrice = linqCalc.GetTotalValueOfProducts(_products);
//Assert
Assert.AreEqual(72, finalPrice);
}
public ActionResult DependencyInjection()
{
IValueCalculator calc = new LinqValueCalculator(); // Implement Dependency Injection
ShoppingCart cart = new ShoppingCart(calc)
{
Products = products
};
decimal totalValue = cart.CalculateProductTotal();
return(View("Index", totalValue));
}
public void Sum_Products_Correctly()
{
// arrange
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
LinqValueCalculator target = new LinqValueCalculator(mock.Object);
// act
decimal result = target.ValueProducts(this.products);
// assert
Assert.AreEqual(this.products.Sum(e => e.Price), result);
}
// GET: Home (default View)
public ActionResult Index()
{
LinqValueCalculator calc = new LinqValueCalculator();
SumOfTable tab = new SumOfTable(calc)
{
Products = products
};
decimal totalValue = tab.CalculateProductTotal();
//return default view (Views/Home/Index)
return(View(totalValue));
}
public void SumProductsCorrectly()
{
// Организация
var mock = new Mock <IDiscountHelper>();
mock.Setup(helper => helper.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
IValueCalculator target = new LinqValueCalculator(mock.Object);
// Действие
var result = target.ValueProducts(_products);
// Утверждение
Assert.AreEqual(_products.Sum(product => product.Price), result);
}
public void Sum_Products_Correctly()
{
//arrange
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
var target = new LinqValueCalculator(mock.Object);
var goalTotal = _products.Sum(p => p.Price);
//act
var result = target.ValueProducts(_products);
Assert.AreEqual(goalTotal, result);
}
public void Can_Sum_Product_Corretly()
{
//Arrange
// Repository
DiscountHelper repo = new DiscountHelper();
decimal ExpectedValue = products.Sum(m => m.price) + 0.9M;
//Act
//callin class
LinqValueCalculator target = new LinqValueCalculator(repo);
decimal ActualValue = target.ProductValue(products);
//Assert
Assert.AreEqual(ExpectedValue, ActualValue);
}
public void Sum_Products_Correctly()
{
// Arrange (добавляем имитированный объект)
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>()))
.Returns <decimal>(total => total);
var target = new LinqValueCalculator(mock.Object);
// Act
var result = target.ValueProducts(products);
// Assert
Assert.AreEqual(products.Sum(e => e.Price), result);
}
public void Sum_Products_Correctly()
{
// arrange
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total); // используем метод Setup, чтобы добавить метод в наш mock-объект
// It метод в каких параметрах мы заинтересованы
// Метод Returns позволяет определить результат, который будет возвращен
var target = new LinqValueCalculator(mock.Object); // считывая свойство Object объекта Mock<IDiscountHelper>
// act
var result = target.ValueProducts(products);
// assert
Assert.AreEqual(products.Sum(x => x.Price), result);
}
public void CorrectlySumsProducts()
{
//arrange
Mock <IDiscountHelper> mock = new Mock <IDiscountHelper>();
mock.Setup(mockedClass => mockedClass.ApplyDiscount(It.IsAny <decimal>()))
.Returns <decimal>(originalValuePassedToMockedFunction => originalValuePassedToMockedFunction);
var target = new LinqValueCalculator(mock.Object);
//act
var result = target.ValueProducts(this.products);
//assert
Assert.AreEqual(this.products.Sum(p => p.Price), result);
}
