C# MockRepository.Record方法代码示例

        public void Ayende_View_On_Mocking()
        {
            MockRepository mocks = new MockRepository();
            ISomeSystem mockSomeSystem = mocks.StrictMock<ISomeSystem>();

            using (mocks.Record())
            {
                Expect.Call(mockSomeSystem.GetFooFor<ExpectedBar>("foo"))
                    .Return(new List<ExpectedBar>());
            }

            ExpectationViolationException ex = Assert.Throws<ExpectationViolationException>(
                () =>
                {
                    using (mocks.Playback())
                    {
                        ExpectedBarPerformer cut = new ExpectedBarPerformer(mockSomeSystem);
                        cut.DoStuffWithExpectedBar("foo");
                    }
                }
                );

            Assert.Equal(@"ISomeSystem.GetFooFor<Rhino.Mocks.Tests.FieldsProblem.UnexpectedBar>(""foo""); Expected #1, Actual #1.
            ISomeSystem.GetFooFor<Rhino.Mocks.Tests.FieldsProblem.ExpectedBar>(""foo""); Expected #1, Actual #0.", ex.Message);
        }

        public void WillMerge_UnorderedRecorder_WhenRecorderHasSingleRecorderInside()
        {
            MockRepository mocks = new MockRepository();
            ICustomer customer = mocks.StrictMock<ICustomer>();

            CustomerMapper mapper = new CustomerMapper();

            using (mocks.Record())
            using (mocks.Ordered())
            {
                Expect.Call(customer.Id).Return(0);

                customer.IsPreferred = true;
            }

            ExpectationViolationException ex = Assert.Throws<ExpectationViolationException>(() =>
            {
                using (mocks.Playback())
                {
                    mapper.MarkCustomerAsPreferred(customer);
                }
            });

            Assert.Equal("Unordered method call! The expected call is: 'Ordered: { ICustomer.get_Id(); }' but was: 'ICustomer.set_IsPreferred(True);'", ex.Message);
        }

        public void MultiThreadedReplay()
        {
            var mocks = new MockRepository();
            var service = mocks.StrictMock<IService>();
            using (mocks.Record())
            {
                for (int i = 0; i < 100; i++)
                {
                    int i1 = i;

                    Expect.Call(() => service.Do("message" + i1));
                }
            }
            using (mocks.Playback())
            {
                int counter = 0;
                for (int i = 0; i < 100; i++)
                {
                    var i1 = i;
                    ThreadPool.QueueUserWorkItem(delegate
                    {
                        service.Do("message" + i1);
                        Interlocked.Increment(ref counter);
                    });
                }
                while (counter != 100)
                    Thread.Sleep(100);
            }
        }

        public void The_value_of_a_variable_used_as_an_out_parameter_should_not_be_used_as_a_constraint_on_an_expectation()
        {
            MockRepository mockRepository = new MockRepository();
            ServiceBeingCalled service = mockRepository.StrictMock<ServiceBeingCalled>();
            const int theNumberToReturnFromTheServiceOutParameter = 20;

            using(mockRepository.Record())
            {
                int uninitialized;

                // Uncommenting the following line will make the test pass, because the expectation constraints will match up with the actual call.
                // However, the value of an out parameter cannot be used within a method value before it is set within the method value,
                // so the value going in really is irrelevant, and should therefore be ignored when evaluating constraints.
                // Even ReSharper will tell you "Value assigned is not used in any execution path" for the following line.

                //uninitialized = 42;

                // I understand I can do an IgnoreArguments() or Contraints(Is.Equal("key"), Is.Anything()), but I think the framework should take care of that for me

                Expect.Call(service.PopulateOutParameter("key", out uninitialized)).Return(null).OutRef(theNumberToReturnFromTheServiceOutParameter);
            }
            ObjectBeingTested testObject = new ObjectBeingTested(service);
            int returnedValue = testObject.MethodUnderTest();
            Assert.Equal(theNumberToReturnFromTheServiceOutParameter, returnedValue);
        }

 public void CannotCallLastCallConstraintsMoreThanOnce()
 {
     MockRepository repository = new MockRepository();
     IGetResults resultGetter = repository.Stub<IGetResults>();
     using (repository.Record())
     {
         resultGetter.GetSomeNumber("a");
         LastCall.Constraints(Text.Contains("b"));
         LastCall.Constraints(Text.Contains("a"));
     }
 }

            public void OutByRefTest()
            {
                MockRepository mockery = new MockRepository();
                IFoo mockFoo = mockery.StrictMock<IFoo>();
                int three = 3;
                int six = 6;
                using (mockery.Record())
                {
                    SetupResult.For(mockFoo.foo(ref three)).OutRef(six).Return(true);
                }

                Assert.Throws<Rhino.Mocks.Exceptions.ExpectationViolationException>(() => mockFoo.foo(ref six));
            }

        public void CanGetSetupResultFromStub()
        {
            MockRepository repository = new MockRepository();
            IGetResults resultGetter = repository.Stub<IGetResults>();
            using (repository.Record())
            {
                resultGetter.GetSomeNumber("a");
                LastCall.Return(1);
            }

            int result = resultGetter.GetSomeNumber("a");
            Assert.Equal(1, result);
            repository.VerifyAll();
        }

 public void PlaybackThrowsOtherExceptionDoesntReport()
 {
     MockRepository mockRepository;
     mockRepository = new MockRepository();
     IFoo mockedFoo = mockRepository.StrictMock<IFoo>();
     using (mockRepository.Record())
     {
         Expect.Call(mockedFoo.Bar()).Return(42);
     }
     using (mockRepository.Playback())
     {
         throw new ArgumentException();
     }
 }

        public void StubNeverFailsTheTest()
        {
            MockRepository repository = new MockRepository();
            IGetResults resultGetter = repository.Stub<IGetResults>();
            using (repository.Record())
            {
                resultGetter.GetSomeNumber("a");
                LastCall.Return(1);
            }

            int result = resultGetter.GetSomeNumber("b");
            Assert.Equal(0, result);
            repository.VerifyAll(); //<- should not fail the test methinks
        }

        public void NaturalSyntaxForCallingMethods_WithArguments()
        {
            MockRepository mocks = new MockRepository();
            IDemo demo = mocks.StrictMock<IDemo>();
            using (mocks.Record())
            {
                Expect.Call( () => demo.VoidStringArg("blah") );
            }

            using (mocks.Playback())
            {
                demo.VoidStringArg("blah");
            }
        }

        public void NaturalSyntaxForCallingMethods()
        {
            MockRepository mocks = new MockRepository();
            IDemo demo = mocks.StrictMock<IDemo>();
            using (mocks.Record())
            {
                Expect.Call(demo.VoidNoArgs);
            }

            using (mocks.Playback())
            {
                demo.VoidNoArgs();
            }
        }

        public void NaturalSyntaxForCallingMethods_WithArguments_WhenNotCalled_WouldFailVerification()
        {
            MockRepository mocks = new MockRepository();
            IDemo demo = mocks.StrictMock<IDemo>();
            using (mocks.Record())
            {
                Expect.Call(() => demo.VoidStringArg("blah"));
            }

            Throws.Exception<ExpectationViolationException>("IDemo.VoidStringArg(\"blah\"); Expected #1, Actual #0.",delegate
            {
                mocks.VerifyAll();
            });
        }

        public void CanCallMethodWithParameters_WithoutSpecifyingParameters_WillAcceptAnyParameter()
        {
            MockRepository mocks = new MockRepository();
            IDemo demo = mocks.StrictMock<IDemo>();
            using (mocks.Record())
            {
                Expect.Call(() => demo.VoidStringArg("blah")).IgnoreArguments();
            }

            using (mocks.Playback())
            {
                demo.VoidStringArg("asd");
            }
        }

        public void CanSetExpectationOnReadWritePropertyUsingRecordPlaybackSyntax()
        {
            var mocks = new MockRepository();
            var demo = mocks.DynamicMock<IDemo>();

            using (mocks.Record())
            {
                demo.Expect(x => x.Prop).SetPropertyWithArgument("Eduardo");
            }

            using (mocks.Playback())
            {
                demo.Prop = "Eduardo";
            }
        }

 public void CannotCallLastCallConstraintsMoreThanOnce()
 {
     MockRepository repository = new MockRepository();
     IGetResults resultGetter = repository.Stub<IGetResults>();
     var ex = Assert.Throws<InvalidOperationException>(() =>
                                                       	{
                                                       		using (repository.Record())
                                                       		{
                                                       			resultGetter.GetSomeNumber("a");
                                                       			LastCall.Constraints(Text.Contains("b"));
                                                       			LastCall.Constraints(Text.Contains("a"));
                                                       		}
                                                       	});
     Assert.Equal("You have already specified constraints for this method. (IGetResults.GetSomeNumber(contains \"b\");)", ex.Message);
 }