`
wangdeshui
  • 浏览: 255015 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Mock工具笔记

阅读更多

1.准备被测试的类

Product 类

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

 

namespace TestTypeMock

{

    public class Product

    {

        public string Name { get; set; }

        public long ProductId { get; set; }

        public decimal Price { get; set; }

        public int CategoryId { get; set; }

 

        public decimal Discount(decimal discountPercent)

        {

            return this.Price * discountPercent;

        }

 

        public static long MarkUp(int times)

        {

            return 50 * times;

        }

 

        private long Add(int a, int b)

        {

            return a + b;

        }

 

        public long GetAddResult(int a, int b)

        {

            return Add(a, b);

        }

 

        public long LiveObjectAdd(int a, int b)

        {

            return GetAddLiveObject(a, b);

        }

 

        private long GetAddLiveObject(int a, int b)

        {

        throw new NotImplementedException("Not Implemented");

        }

    }

}

 

ShopCart类

    1 using System;

    2 using System.Collections.Generic;

    3 using System.Linq;

    4 using System.Text;

    5 

    6 namespace TestTypeMock

    7 {

    8    public   class ShopCart

    9     {

   10        public decimal SumPrice(List<Product> allProduct)

   11        {

   12            decimal totalPrice = 0;

   13            foreach (Product item in allProduct)

   14            {

   15                totalPrice += Product.MarkUp(2);  // in order to mock static method

   16            }

   17            return totalPrice;

   18        }

   19 

   20        public decimal NatureAdd(Product p)

   21        {

   22            return p.Discount(5);

   23        }

   24     }

   25 }

 

Icalc类

    1 using System;

    2 using System.Collections.Generic;

    3 using System.Linq;

    4 using System.Text;

    5 

    6 namespace TestTypeMock

    7 {

    8     public interface ICalc

    9     {

   10         long Add(int a, int b);

   11     }

   12 }

 

Duck类

    1 using System;

    2 using System.Collections.Generic;

    3 using System.Linq;

    4 using System.Text;

    5 

    6 namespace TestTypeMock

    7 {

    8   public    class Duck

    9     {

   10       public bool CanSwim()

   11       {

   12           return true;

   13       }

   14 

   15     }

   16 }

 

Chicken 类

    1 using System;

    2 using System.Collections.Generic;

    3 using System.Linq;

    4 using System.Text;

    5 

    6 namespace TestTypeMock

    7 {

    8   public    class Chicken

    9     {

   10       public bool CanSwim()

   11       {

   12           return false;

   13       }

   14     }

   15 }

 

测试

1. AAA

    1 using System;

    2 using System.Collections.Generic;

    3 using System.Linq;

    4 using System.Text;

    5 using Microsoft.VisualStudio.TestTools.UnitTesting;

    6 using TypeMock;

    7 using TypeMock.ArrangeActAssert;

    8 using TestTypeMock;

    9 namespace ProductTest

   10 {

   11     [TestClass]

   12     public class TestProduct

   13     {

   14 

   15         [TestInitialize]

   16         public void Setup()

   17         {

   18 

   19         }

   20 

   21         [TestMethod]

   22         public void ProductTest()

   23         {

   24             // Arrange

   25             Product fakeProduct = Isolate.Fake.Instance<Product>();

   26             Isolate.WhenCalled(() => fakeProduct.Discount(50)).WillReturn(60);

   27 

   28 

   29             // Act

   30             decimal discountPrice = fakeProduct.Discount(50);

   31 

   32             // Assert

   33             Assert.AreEqual(discountPrice, 60);

   34             Isolate.Verify.WasCalledWithAnyArguments(() => fakeProduct.Discount(70));

   35         }

   36 

   37         [TestMethod]

   38         public void TestCallOrginalMethod()

   39         {

   40             // Arrange

   41             Product fakeProduct = Isolate.Fake.Instance<Product>();

   42 

   43             // fakeProduct.Price = 200; // why can't use this way?

   44             Isolate.WhenCalled(() => fakeProduct.Price).WillReturn(200);

   45             Isolate.WhenCalled(() => fakeProduct.Discount((decimal)0.5)).CallOriginal();

   46 

   47             // Act

   48             decimal discountPrice = fakeProduct.Discount((decimal)0.5);

   49 

   50             // Assert

   51             Assert.AreEqual(discountPrice, 100);

   52             Isolate.Verify.WasCalledWithAnyArguments(() => fakeProduct.Discount(100));

   53             Isolate.Verify.WasCalledWithAnyArguments(() => fakeProduct.Price);

   54         }

   55 

   56         [TestMethod]

   57         [Description("Test Mock Static Method")]

   58         public void TestMockStaticMethod()

   59         {

   60             // Arrange

   61             Isolate.Fake.StaticMethods<Product>(Members.CallOriginal);

   62 

   63             Isolate.WhenCalled<long>(() => Product.MarkUp(5));

   64 

   65             // Act

   66             long newProductPrice = Product.MarkUp(5);

   67 

   68             // Assert

   69             Assert.AreEqual(newProductPrice, 250);

   70             Isolate.Verify.WasCalledWithAnyArguments(() => Product.MarkUp(5));

   71         }

   72 

   73         [TestMethod]

   74         public void TestMockStaticMethod2()

   75         {

   76             // Arrange

   77             Product fakeProduct = Isolate.Fake.Instance<Product>();

   78             Isolate.Fake.StaticMethods<Product>();

   79             Isolate.WhenCalled<long>(() => Product.MarkUp(2)).WillReturn(10);

   80 

   81             ShopCart s = new ShopCart();

   82             List<Product> list = new List<Product> { fakeProduct, fakeProduct, fakeProduct };

   83 

   84             // Act

   85             decimal b = s.SumPrice(list);  // will use  mock static method

   86 

   87             // Assert

   88             Assert.AreEqual(b, 30);

   89 

   90         }

   91 

   92         [TestMethod]

   93         [Isolated]

   94         [Description("Mock private method of class")]

   95         public void MockPrivate()

   96         {

   97             // Arrange

   98             Product mockProduct = Isolate.Fake.Instance<Product>();

   99             Isolate.NonPublic.WhenCalled(mockProduct, "Add").CallOriginal();

  100             Isolate.WhenCalled(() => mockProduct.GetAddResult(5, 5)).CallOriginal();

  101             // Act

  102             long result = mockProduct.GetAddResult(5, 5);

  103 

  104             //Assert

  105             Assert.AreEqual(10, result);

  106             Isolate.Verify.NonPublic.WasCalled(mockProduct, "Add").WithArguments(5, 5);

  107 

  108         }

  109 

  110         [TestMethod]

  111         public void TestLiveObject()

  112         {

  113             Product p = new Product();   // please notice this statement, not mocked object

  114             long result = p.GetAddResult(3, 5);

  115             Assert.AreEqual(8, result);

  116 

  117             // Arrange

  118             Isolate.NonPublic.WhenCalled (p, "GetAddLiveObject").WillReturn((long)10);

  119 

  120             // Act

  121             Assert.AreEqual(10,p.LiveObjectAdd(5, 5));

  122 

  123             // Assert

  124             Isolate.Verify.NonPublic.WasCalled(p, "GetAddLiveObject").WithArguments(5, 5);

  125 

  126         }

  127     }

  128 }

2. Nature Mock

    1 using System;

    2 using System.Collections.Generic;

    3 using System.Linq;

    4 using System.Text;

    5 using Microsoft.VisualStudio.TestTools.UnitTesting;

    6 using TypeMock;

    7 using TypeMock.ArrangeActAssert;

    8 using TestTypeMock;

    9 using System.Text.RegularExpressions;

   10 

   11 namespace ProductTest

   12 {

   13     [TestClass]

   14     public class TestNatureMock

   15     {

   16         [TestMethod]

   17         [VerifyMocks]

   18         public void TestByNatureMock()

   19         {

   20             Product p = new Product();

   21             p.Price = 20;

   22             using (RecordExpectations record = RecorderManager.StartRecording())

   23             {

   24                 p.Discount(6);

   25                 record.Return((decimal)20);

   26                 record.CheckArguments(Check.IsEqual((decimal)5));

   27                 record.Repeat(2);            //前两次调用使用Mock的方法,后面使用自己的

   28                 record.VerifyMode = VerifyMode.Normal;

   29                 //    record.DefaultBehavior.Strict = StrictFlags.InstanceMethods;

   30 

   31             }

   32 

   33             ShopCart s = new ShopCart();

   34             Assert.AreEqual(s.NatureAdd(p), 20);   // use mocked statement

   35             Assert.AreEqual(s.NatureAdd(p), 20);  // use mocked statement

   36             Assert.AreEqual(s.NatureAdd(p), 100);  // use original statement

   37 

   38             // MockManager.Verify();  //use this or put [verifymodes] on method

   39         }

   40 

   41 

   42         [TestMethod]

   43         public void TestByImpictUse()

   44         {

   45             MockManager.Init();

   46 

   47             // Product is now being mocked

   48             Mock p = MockManager.Mock(typeof(Product));

   49 

   50             // set up our expectations

   51             p.ExpectAndReturn("MarkUp", (long)25).When(Check.IsEqual(5));

   52 

   53             // Act

   54             Assert.AreEqual((long)25, Product.MarkUp(5));

   55 

   56             // Verify

   57             MockManager.Verify();

   58         }

   59 

   60         [TestMethod]

   61         public void NatureMockLiveObject()

   62         {

   63             Product p = new Product();

   64             p.Price = 200;

   65             using (RecordExpectations record = RecorderManager.StartRecording())

   66             {

   67                 p.Discount((decimal)10);

   68                 record.Return((decimal)20);

   69                 record.Repeat(2);

   70                 record.WhenArgumentsMatch(Check.IsEqual((decimal)10));

   71             }

   72 

   73             Assert.AreEqual(p.Discount((decimal)10), 20);

   74             Assert.AreEqual(p.Discount((decimal)10), 20);

   75             MockManager.Verify();

   76         }

   77 

   78         [TestMethod]

   79         public void NatureMockInterface()

   80         {

   81             ICalc mockICalc = (ICalc)RecorderManager.CreateMockedObject<ICalc>();

   82             using (RecordExpectations record = RecorderManager.StartRecording())

   83             {

   84                 mockICalc.Add(5, 5);

   85                 record.Return((long)10);

   86             }      

   87             Assert.AreEqual(mockICalc.Add(5, 5), (decimal)10);

   88             MockManager.Verify();

   89         }

   90     }

   91 

   92 

   93 }

 

Mock Swap

    1 using System;

    2 using System.Collections.Generic;

    3 using System.Linq;

    4 using System.Text;

    5 using Microsoft.VisualStudio.TestTools.UnitTesting;

    6 using TypeMock;

    7 using TypeMock.ArrangeActAssert;

    8 using TestTypeMock;

    9 

   10 namespace ProductTest

   11 {

   12     [TestClass]

   13   public    class TestMockSwap

   14     {

   15         [TestMethod]

   16         public void TestSwap()

   17         {

   18             Duck duck = new Duck();

   19             Chicken chicken = new Chicken();

   20             Assert.AreEqual(duck.CanSwim(), true);

   21             Assert.AreEqual(chicken.CanSwim(),false);

   22 

   23             Isolate.Swap.CallsOn(chicken).WithCallsTo(duck);

   24             Assert.AreEqual(chicken.CanSwim(), true);  // because swaped

   25 

   26             Assert.AreEqual(duck.CanSwim(), true);

   27 

   28             // how to back to call itself? below cause wrong, dead loop

   29           //  Isolate.Swap.CallsOn(chicken).WithCallsTo(chicken); //call itself

   30             Assert.AreEqual(chicken.CanSwim(), true);

   31 

   32 

   33         }

   34     }

   35 }

 

Test Base Class

 

    1 using System;

    2 using System.Collections.Generic;

    3 using System.Linq;

    4 using System.Text;

    5 using Microsoft.VisualStudio.TestTools.UnitTesting;

    6 using TypeMock;

    7 using TypeMock.ArrangeActAssert;

    8 using TestTypeMock;

    9 

   10 namespace ProductTest

   11 {

   12 

   13     [TestClass]

   14    public    class MockBaseClass

   15     {

   16         /// <summary>

   17         /// Mock base class method

   18         /// </summary>

   19         [TestMethod]

   20         public void TestBaseClass()

   21         {

   22             Mock mock = MockManager.Mock<Dog>();

   23             mock.CallBase.ExpectAndReturn("Do", "mock Animal Do");

   24 

   25             Dog dog = new Dog();

   26             Assert.AreEqual(dog.Do(), "mock Animal Do: I am Dog");

   27 

   28             MockManager.Verify();

   29 

   30         }

   31     }

   32 

   33    public class Animal

   34    {

   35        public virtual string Do()

   36        {

   37            return "Animal Do";

   38        }

   39    }

   40 

   41    public class Dog : Animal

   42    {

   43        public override string Do()

   44        {

   45            return base.Do() + ": I am Dog";

   46        }

   47    }

   48 }

 

Mock .net 3.5

    1 using System;

    2 using System.Collections.Generic;

    3 using System.Linq;

    4 using System.Text;

    5 using Microsoft.VisualStudio.TestTools.UnitTesting;

    6 using TypeMock;

    7 using TypeMock.ArrangeActAssert;

    8 using TestTypeMock;

    9 namespace ProductTest

   10 {

   11 

   12     [TestClass]

   13     public class TypeMockNet35

   14     {

   15 

   16         [TestMethod]

   17         public void TestAutoProperty()

   18         {

   19             AutoProperty p = Isolate.Fake.Instance<AutoProperty>();

   20             Isolate.WhenCalled(() => p.Name).WillReturn("Jack");

   21             Isolate.Swap.NextInstance<AutoProperty>().With(p);

   22 

   23             AutoProperty p1 = new AutoProperty();

   24             p1.Name = "wang";

   25 

   26             Assert.AreEqual("Jack", p1.Name);

   27         }

   28     }

   29 

   30     public class AutoProperty

   31     {

   32         public string Name { get; set; }

   33     }

   34 }

 

分享到:
评论

相关推荐

    尚硅谷springboot核心技术笔记

    最后,笔记可能会介绍Spring Boot的测试支持,包括单元测试、集成测试以及如何编写Mock测试用例。 总的来说,《尚硅谷springboot核心技术笔记》是一份全面的Spring Boot学习资源,无论你是初学者还是有一定经验的...

    CFA2019 Mock Exam A - Afternoon Session

    【CFA2019 Mock Exam A - 下午场】是一份专门为准备2019年CFA一级考试的考生设计的模拟试题集。这个下午场包含120个问题,模拟了实际考试中的时间分配,建议考生每个问题平均用时1.5分钟,总计3小时完成。试题涵盖多...

    CXF笔记

    4. **测试工具**:如CXF的模拟服务器(CXF-RT-FEATURES-MOCK)和测试框架,用于快速验证服务功能。 在【Conversion】这个文件名中,可能是指在CXF中处理数据转换的过程,例如XML到Java对象的转换,或者是不同数据...

    python基础笔记.zip

    - **unittest.mock**:用于模拟对象和函数,可以在测试中隔离依赖,提高测试的可控性和可读性。 3. 软件测试自动化实践: - **测试驱动开发(TDD)**:先写测试用例,再编写满足测试的代码,保证代码质量。 - **...

    mockjs数据模拟

    `学习笔记.md` 文件可能包含了更深入的使用示例和技巧,比如如何处理复杂的嵌套数据结构、自定义生成规则、以及如何在实际项目中集成 MockJS。此外,文档可能还会讲解如何通过 MockJS 的 `Mock.Random.extend` 方法...

    Felix笔记1-构建BookshelfProject

    2. `com.packtpub.felix.bookshelf-inventory-impl-mock`:这可能是库存管理服务的实现,可能是一个模拟(mock)版本,用于测试或演示目的。模拟实现通常用于快速验证设计,避免依赖真实的数据库或其他外部服务,...

    VSCode项目工程调试debug 教程 笔记

    断点是调试中的重要工具,用于暂停程序执行以便检查状态。除了基本的行内断点,VSCode还支持条件断点(只有满足特定条件时才会触发)和 log 点,后者会在达到该行时在控制台打印指定的表达式值。这对于理解代码执行...

    自动化测试笔记.zip

    在"自动化测试笔记.zip"这个压缩包中,我们可以预想它包含了关于自动化测试的详细资料,包括但不限于理论知识、常用工具介绍、实践案例以及可能的代码示例。 首先,自动化测试的基本概念是理解其核心的前提。自动化...

    gmock相关资料和笔记

    - **Nice Mock**与**Strict Mock**:Nice Mock允许未设定期望的调用,而Strict Mock会抛出异常。 - **匹配器(Matchers)**:用于检查方法参数是否符合预期,如`Eq`、`Ne`、`A`等。 - **流式API**:gmock提供了...

    模块测试笔记1

    2. 模拟库:如Mockito(Java)、unittest.mock(Python)、sinon.js(JavaScript),帮助模拟模块间的依赖关系,隔离测试。 3. 测试覆盖率工具:如JaCoCo(Java)、coverage.py(Python)、Istanbul(JavaScript),...

    Junit良葛格学习笔记

    - **模拟对象(Mock Objects)**:使用Mockito等库,模拟依赖对象的行为,使测试更加可控。 6. **扩展性**: - **Rule**:JUnit规则允许自定义测试行为,如临时文件管理、日志记录等。 - **扩展框架**:如TestNG...

    我的笔记 spring的测试

    同时,`@Autowired`和`@MockBean`等注解可以帮助我们管理测试中的bean,例如注入mock对象来模拟复杂的行为。此外,`@Before`和`@After`注解可以用来设置测试前后的环境。 接着,我们讨论Spring的集成测试。集成测试...

    HTTP协议学习笔记之c++

    - **ApiFox**:结合了Postman的功能,还支持Mock服务、Swagger等功能,便于API文档的生成和管理。 这些工具和技术可以帮助开发者更好地理解和使用HTTP协议,从而优化Web应用的性能和用户体验。

    android学习笔记

    11. **单元测试与Mocking**:学习JUnit、Espresso进行单元测试和UI测试,了解Mockito等工具进行mock对象测试。 12. **性能优化**:内存优化、渲染优化、电量优化,以及使用Android Profiler进行性能分析。 13. **...

    写笔记带后端 (2).zip

    7. **mock**: 模拟数据文件,用于开发阶段模拟后端接口。 8. **database**: 如果涉及到本地数据存储,可能有数据库配置和操作相关代码。 9. **components**: 自定义组件文件,可复用的UI元素。 10. **static**: 静态...

    easymock selenium junit

    在"学习总结"这个文件中,你可能找到了关于如何集成和运用这三个工具的笔记,包括安装步骤、基本用法、常见问题及解决策略等。深入理解并熟练运用Easymock、Selenium和JUnit,能够帮助开发者编写出高质量的代码,...

    spring培训学习笔记

    Spring支持单元测试和集成测试,提供了Mock对象和测试工具,方便开发者进行测试驱动开发(TDD)。 **与其他框架的整合**: Spring非常灵活,能够与众多其他框架无缝集成,如Struts、JSF、Hibernate等。Spring MVC...

    测试驱动开发 多币种实例2.笔记

    6. **持续集成/持续部署(CI/CD)**:结合自动化测试,使用Jenkins、GitLab CI/CD等工具,确保每次代码提交都会触发构建和测试流程,以尽早发现潜在问题。 7. **模拟与依赖注入**:在测试中可能需要使用模拟对象...

    spring个人学习笔记

    - 测试友好:Spring框架使单元测试和集成测试变得更加简单,可以通过Mock对象来隔离依赖,确保测试的准确性。 2. Spring快速入门 要开始一个Spring项目,通常遵循以下步骤: - 导入Maven坐标:引入Spring的核心库,...

Global site tag (gtag.js) - Google Analytics