C# MockContext.Arrange方法代码示例

        public void Arrange_CallBackFourArguments_InvokesCallback()
        {
            var mockContext = new MockContext<IFoo>();
            var fooMock = new FooMock(mockContext);
            int firstResult = 0;
            int secondResult = 0;
            int thirdResult = 0;
            int fourthResult = 0;
            mockContext.Arrange(
                f => f.Execute(The<int>.IsAnyValue, The<int>.IsAnyValue, The<int>.IsAnyValue, The<int>.IsAnyValue))
                .Callback<int, int, int, int>(
                    (i1, i2, i3, i4) =>
                    {
                        firstResult = i1;
                        secondResult = i2;
                        thirdResult = i3;
                        fourthResult = i4;
                    });

            fooMock.Execute(1, 2, 3, 4);

            Assert.AreEqual(1, firstResult);
            Assert.AreEqual(2, secondResult);
            Assert.AreEqual(3, thirdResult);
            Assert.AreEqual(4, fourthResult);
        }

 public void Arrange_CallBackOneArgument_InvokesCallback()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     int callBackResult = 0;
     mockContext.Arrange(f => f.Execute(The<int>.IsAnyValue)).Callback<int>(s => callBackResult = s);
     fooMock.Execute(1);
     Assert.AreEqual(1, callBackResult);
 }

 public void Arrange_CallBackNoArguments_InvokesCallback()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     bool isCalled = false;
     mockContext.Arrange(f => f.Execute()).Callback(() => isCalled = true);
     fooMock.Execute();
     Assert.IsTrue(isCalled);
 }

        public void Cloud_auth_object_returns_project_id()
        {
            var mockContext = new MockContext<CloudAuthenticator>();
            mockContext.Arrange(f => f.GetProjectId()).Returns("ProjectId");

            var cloudAuthMock = new CloudAuthenticatorMock(mockContext);
            var result = cloudAuthMock.GetProjectId();

            mockContext.Assert(f => f.GetProjectId(), Invoked.Once);
            Assert.Equal("ProjectId", result);
        }

        public void Cloud_auth_object_returns_initializer()
        {
            var initializer = new BaseClientService.Initializer();
            var mockContext = new MockContext<CloudAuthenticator>();
            mockContext.Arrange(f => f.GetInitializer()).Returns(initializer);

            var cloudAuthMock = new CloudAuthenticatorMock(mockContext);
            var result = cloudAuthMock.GetInitializer();

            mockContext.Assert(f => f.GetInitializer(), Invoked.Once);
            Assert.Equal(initializer, result);
        }

 public MessageControllerTest(ITestOutputHelper output)
 {
     this.output = output;
     lookupRepo = new FakeLookupRepository();
     logger = new DivineLogger<FakeDataStore>(new FakeDataStore());
     cache = new MemoryCache(new MemoryCacheOptions());
     msgService = new FakeCommunicationService();
     var mockContext = new MockContext<IRepository<Member>>();
     membersRepo = new FakeMemberRepository(mockContext);
     var repositories = new DivineRepositories(attendanceRepo, lookupRepo, membersRepo, msgRepo);
     //divineBot = new TextDivineBot(repositories, msgService);
     mockContext.Arrange(x => (x.GetAllAsync())).Returns(Task.FromResult(membersList.AsQueryable()));
     messageCtrl = new MessageController(repositories, msgService, cache, logger, null);
 }

 public void Arrange_CallBackTwoArguments_InvokesCallback()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     int firstResult = 0;
     int secondResult = 0;
     mockContext.Arrange(f => f.Execute(The<int>.IsAnyValue, The<int>.IsAnyValue)).Callback<int, int>(
         (i, i1) =>
         {
             firstResult = i;
             secondResult = i1;
         });
     fooMock.Execute(1, 2);
     Assert.AreEqual(1, firstResult);
     Assert.AreEqual(2, secondResult);
 }

        public async Task Get_ReturnsBadRequest()
        {
            //Arrange
            var mockContext = new MockContext<IRepository<Member>>();
            membersRepo = new FakeMemberRepository(mockContext);
            var controller = new MembersController(new DivineRepositories(null, lookupRepo, membersRepo, null), logger, null, null);
            mockContext.Arrange(x => (x.GetAllAsync())).Throws(() => new NullReferenceException("null Data"));

            //Act
            var result = await controller.Get();

            //Assert
            Assert.NotNull(result);
            Assert.Equal(result.StatusCode , (int) HttpStatusCode.BadRequest);
            Assert.IsType<string>(result.Value);
            Assert.Contains("error",result.Value.ToString(),  StringComparison.OrdinalIgnoreCase);
        }

        public async Task Get_ReturnsNoException()
        {
            //Arrange
            var mockContext = new MockContext<IRepository<Member>>();
            membersRepo = new FakeMemberRepository(mockContext);
            var controller = new MembersController(new DivineRepositories(null, lookupRepo, membersRepo, null),logger, null, null);
            var data = new List<Member> { new Member { Id = 1 } }.AsQueryable();
            mockContext.Arrange(x => (x.GetAllAsync())).Returns(Task.FromResult(data));

            //ACT
            var result = await controller.Get();

            //Assert
            Assert.NotNull(result);
            Assert.IsType<List<Member>>(result.Value);
            Assert.Equal(data.Count(), ((List<Member>)result.Value).Count());


        }

        public void Execute_ArrangedReturnValue_ReturnsValueUsingLambda()
        {
            var mockContext = new MockContext<IFoo>();
            var fooMock = new FooMock(mockContext);
            var outerVariable = " works";
            mockContext.Arrange(f => f.Execute(The<string>.IsAnyValue)).Returns<string>(
                a =>
                {
                    var r = a + outerVariable + "!";
                    return r;
                });

            var result = fooMock.Execute("It");

            Assert.AreEqual("It works!", result);
        }

        public void Arrange_ReturnsWithFourArguments_InvokesGetResult()
        {
            var mockContext = new MockContext<IFoo>();
            var fooMock = new FooMock(mockContext);
            mockContext.Arrange(
                f =>
                    f.Execute(
                        The<string>.IsAnyValue,
                        The<string>.IsAnyValue,
                        The<string>.IsAnyValue,
                        The<string>.IsAnyValue))
                .Returns<string, string, string, string>((a, b, c, d) => "This" + a + b + c + d);
            fooMock.Execute(1, 2, 3, 4);

            var result = fooMock.Execute(" is", " really", " cool", "!");
            Assert.AreEqual("This is really cool!", result);
        }

        public void Arrange_ReturnsWithNoArguments_InvokesGetResult()
        {
            var mockContext = new MockContext<IFoo>();
            var fooMock = new FooMock(mockContext);

            mockContext.Arrange(f => f.Execute()).Returns(() => "This");
            var result = fooMock.Execute();
            Assert.AreEqual("This", result);
        }

 public void Arrange_ReturnsWithOneArgument_InvokesGetResult()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     mockContext.Arrange(f => f.Execute(The<string>.IsAnyValue)).Returns<string>(a => "This" + a);
     var result = fooMock.Execute(" is");
     Assert.AreEqual("This is", result);
 }

 public void Execute_ArrangedRuturnValue_ArrayElementContraintSupport()
 {
     var mockContext = new MockContext<IFoo>();
     var fooMock = new FooMock(mockContext);
     var inputData = new byte[] {1, 2, 3, 4, 5 };
     mockContext.Arrange(
         f => f.Execute(The<byte[]>.Is(a => a[4] == 5)))
         .Returns<byte[]>(a => a);
     var result = fooMock.Execute(inputData);
     Assert.AreEqual(inputData, result);
 }

        public void PropertySupport_ArrangeGetterReturnValue_IsVerified()
        {
            var mockContext = new MockContext<IProp>();
            var propMock = new PropMock(mockContext);
            mockContext.Arrange(x => x.ReadOnlyProperty).Returns(() => "result");

            var propertyValue = propMock.ReadOnlyProperty;
            Assert.AreEqual("result", propertyValue);
        }