public void CallbackAndConstraintsOnSameMethod() { demo.StringArgString(""); Assert.Throws <InvalidOperationException>("This method has already been set to CallbackExpectation.", () => LastCall.On(demo).Callback <string>(StringMethod) .Constraints(Is.Anything())); }
/// <summary> /// Handles the method /// </summary> /// <param name="method"></param> /// <param name="arguments"></param> public override void HandleMethodCall(MethodInfo method, object[] arguments) { Method = method; if (ArgumentManager.HasBeenUsed) { ArgumentManager.ValidateMethodSignature(method); Arguments = ArgumentManager.GetConstraints(); ReturnArguments = ArgumentManager.GetReturnValues(); SetExpectedCount(new Range(1, null)); ArgumentManager.Clear(); return; } var parameters = method.GetParameters(); var constraints = new AbstractConstraint[parameters.Length]; for (int index = 0; index < parameters.Length; index++) { var parameter = parameters[index]; constraints[index] = (parameter.IsOut) ? Is.Anything() : Is.Equal(arguments[index]); } Arguments = constraints; }
public void CreateLogViewWhichIsActive() { StumpMother mother = new StumpMother(); ILogView view = MockRepository.GenerateMock <ILogView>(); ILogMonitor monitor = mother.LogMonitors[0]; mother.LogUpdaterQueue.Expect(lr => lr.FetchLogContents("d:/log1.txt", null)) .Constraints(Is.Equal("d:/log1.txt"), Is.Anything()) .Do((Action <string, LogContentsFetchedCallback>) delegate { view.ShowLogContents("logContents1"); }); view.Expect(v => v.IsLogDisplayActive).Return(true); view.Expect(v => v.ShowLogContents("logContents1")); monitor.Expect(m => m.StartMonitoring("d:/log1.txt", null, null, null, null)) .IgnoreArguments().Repeat.Once(); monitor.Expect(m => m.StopMonitoring()).Repeat.Once(); using (LogPresenter presenter = new LogPresenter( view, monitor, mother.LogUpdaterQueue, mother.Workspace.LogFiles[0])) { } view.VerifyAllExpectations(); monitor.VerifyAllExpectations(); }
public void RenderMailMessage_MessageFormatIsHtmlEvenIfHtmlTagHasAttributes() { const string templateName = "welcome"; var parameters = new Hashtable(); using (mockRepository.Record()) { Expect.Call(viewEngineManagerMock.HasTemplate("mail\\" + templateName)).Return(true); Expect.Call(() => viewEngineManagerMock.Process(templateName, "layout", null, null)) .Constraints( Is.Equal("mail\\" + templateName), Is.Equal("layout"), Is.Anything(), Is.Anything()) .Do(new Render(RendersHtmlEmail)); } using (mockRepository.Playback()) { var message = service.RenderMailMessage(templateName, "layout", parameters); Assert.IsTrue(message.IsBodyHtml); } }
public void Analyze_WebServiceThrows_SendsEmail() { MockRepository mocks = new MockRepository(); IWebService stubService = mocks.Stub <IWebService>(); IEmailService mockEmail = mocks.StrictMock <IEmailService>(); using (mocks.Record()) { stubService.LogError("aaa"); LastCall.Constraints(Is.Anything()); LastCall.Throw(new Exception("가짜 예외")); mockEmail.SendEmail("a", "subject", "가짜 예외"); } LogAnalyzer2 log = new LogAnalyzer2(); log.Service = stubService; log.Email = mockEmail; string tooShortFileName = "abc.ext"; log.Analyze(tooShortFileName); mocks.VerifyAll(); }
public void Default_description() { var matcher = Is.Anything(); var description = new StringDescription(); matcher.DescribeTo(description); Assert.That(description.ToString(), Is.EqualTo("ANYTHING")); }
public ConstraintExpectationTests() { method = typeof(IDemo).GetMethod("VoidThreeArgs"); expectation = new ConstraintsExpectation(new FakeInvocation(this.method), new AbstractConstraint[] { Is.Anything(), Text.Like(@"[\w\d]+"), Is.Equal(3.14f), }, new Range(1, 1)); }
public void Appends_description() { const string test = "test"; var matcher = Is.Anything(test); var description = new StringDescription(); matcher.DescribeTo(description); Assert.That(description.ToString(), Is.EqualTo(test)); }
public void TooFewConstraints() { Assert.Throws <InvalidOperationException>( "The number of constraints is not the same as the number of the method's parameters!", () => new ConstraintsExpectation(new FakeInvocation(this.method), new AbstractConstraint[] { Is.Anything(), Is.Null() }, new Range(1, 1))); }
public void generate_should_pass_assemblies_to_parser_when_set_directly() { var parser = MockRepository.GenerateMock <IAssemblyXmlParser>(); var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, parser, StubWriter, StubResourceManager, StubEventAggregator); generator.SetXmlContent(new[] { "content" }); generator.Generate(); parser.AssertWasCalled(x => x.CreateDocumentModel(null, null), x => x.Constraints(Is.Anything(), List.ContainsAll(new[] { "content" }))); }
public void should_pass_default_template_path_to_writer_if_not_set() { var writer = MockRepository.GenerateMock <IBulkPageWriter>(); var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, StubParser, writer, StubResourceManager, StubEventAggregator); generator.SetAssemblies(new[] { "unimportant_file_path" }); generator.Generate(); writer.AssertWasCalled(x => x.CreatePagesFromDirectory(null, null, null), x => x.Constraints(Text.EndsWith("templates"), Is.Anything(), Is.Anything())); }
public BaseFixture() { // Make this remote act like it's mapped to $/Project Remote.Stub(r => r.GetPathInGitRepo(null)) .Constraints(Is.Anything()) .Do(new Function <string, string>(path => path.StartsWith("$/Project/") ? path.Replace("$/Project/", "") : null)); // Make this remote ignore any path that includes "ignored". Remote.Stub(r => r.ShouldSkip(null)) .Constraints(Is.Anything()) .Do(new Function <string, bool>(s => s.Contains("ignored"))); }
public void PassingNullConstraintsThrows() { Assert.Throws <InvalidOperationException>( "The constraint at index 1 is null! Use Is.Null() to represent null parameters.", () => expectation = new ConstraintsExpectation(new FakeInvocation(this.method), new AbstractConstraint[] { Is.Anything(), null, Is.Equal(3.14f), }, new Range(1, 1))); }
/// <summary> /// Ignores all arguments removing any existing argument constraints /// </summary> /// <returns>Fluid Interface</returns> IPropertyOptions <T> IPropertyOptions <T> .IgnoreArguments() { var constraints = new AbstractConstraint[Arguments.Length]; for (int index = 0; index < Arguments.Length; index++) { constraints[index] = Is.Anything(); } Arguments = constraints; return(this); }
public void CreateErrorMessageForConstraints() { ConstraintsExpectation expectation = new ConstraintsExpectation(new FakeInvocation(this.method), new AbstractConstraint[] { Is.Anything(), Is.Null(), Text.Like(@"[\w\d]+1234") }, new Range(1, 1)); string message = "IDemo.VoidThreeArgs(anything, equal to null, like \"[\\w\\d]+1234\");"; Assert.Equal(message, expectation.ErrorMessage); }
public void StubThatThrowsException_RhinoMocks() { IWebService simulatedService = MockRepository.GenerateStub <IWebService>(); simulatedService .Expect(t => t.LogError("")) .Throw(new Exception("fake exception")) .Constraints(Is.Anything()); LogAnalyzer log = new LogAnalyzer(simulatedService); log.Analyze("abc.ext"); }
public void generate_should_pass_xmls_to_parser_when_set_by_name() { var parser = MockRepository.GenerateMock <IAssemblyXmlParser>(); var generator = new DocumentationGenerator(StubAssemblyLoader, StubXmlLoader, parser, StubWriter, StubResourceManager, StubEventAggregator); StubXmlLoader.Stub(x => x.LoadFrom(null)) .IgnoreArguments() .Return("content"); generator.SetXmlFiles(new[] { "assembly.xml" }); generator.Generate(); parser.AssertWasCalled(x => x.CreateDocumentModel(null, null), x => x.Constraints(Is.Anything(), List.ContainsAll(new[] { "content" }))); }
private IExpectation BuildDefaultExpectation(IInvocation invocation, MethodInfo method, object[] args) { ParameterInfo[] parameters = method.GetParameters(); if (!Array.Exists(parameters, delegate(ParameterInfo p) { return(p.IsOut); })) { return(new ArgsEqualExpectation(invocation, args, GetDefaultCallCountRangeExpectation())); } //The value of an incoming out parameter variable is ignored AbstractConstraint[] constraints = new AbstractConstraint[parameters.Length]; for (int i = 0; i < parameters.Length; i++) { constraints[i] = parameters[i].IsOut ? Is.Anything() : Is.Equal(args[i]); } return(new ConstraintsExpectation(invocation, constraints, GetDefaultCallCountRangeExpectation())); }
/// <summary> /// Builds the default expectation. /// </summary> /// <param name="invocation">The invocation.</param> /// <param name="method">The method.</param> /// <param name="args">The args.</param> /// <param name="callCallRangeExpectation">The call call range expectation.</param> /// <returns></returns> public IExpectation BuildDefaultExpectation(IInvocation invocation, MethodInfo method, object[] args, Func <Range> callCallRangeExpectation) { var parameters = method.GetParameters(); if (!Array.Exists(parameters, p => p.IsOut)) { return(new ArgsEqualExpectation(invocation, args, callCallRangeExpectation())); } //The value of an incoming out parameter variable is ignored var constraints = new AbstractConstraint[parameters.Length]; for (var i = 0; i < parameters.Length; i++) { constraints[i] = parameters[i].IsOut ? Is.Anything() : Is.Equal(args[i]); } return(new ConstraintsExpectation(invocation, constraints, callCallRangeExpectation())); }
public void ThisDoesnt() { MockRepository mockery = new MockRepository(); IFoo mockFoo = mockery.StrictMock <IFoo>(); int junk = 3; using (mockery.Record()) { Expect.Call(mockFoo.foo(ref junk)). IgnoreArguments(). OutRef(3). Constraints(Is.Anything()). Repeat.Once(). Return(true); } using (mockery.Playback()) { ClassUnderTest cut = new ClassUnderTest(); Assert.Equal(3, cut.doit(mockFoo)); } }
public void RenderMailMessage_MessageIsConstructedCorrectly() { const string templateName = "welcome"; var parameters = new Hashtable(); using (mockRepository.Record()) { Expect.Call(viewEngineManagerMock.HasTemplate("mail\\" + templateName)).Return(true); Expect.Call(() => viewEngineManagerMock.Process(templateName, "layout", null, null)) .Constraints( Is.Equal("mail\\" + templateName), Is.Equal("layout"), Is.Anything(), Is.Anything()) .Do(new Render(RendersEmail)); } using (mockRepository.Playback()) { var message = service.RenderMailMessage(templateName, "layout", parameters); Assert.AreEqual("*****@*****.**", message.To[0].Address); Assert.AreEqual("*****@*****.**", message.CC[0].Address); Assert.AreEqual("*****@*****.**", message.Bcc[0].Address); Assert.AreEqual("*****@*****.**", message.From.Address); Assert.AreEqual("Hello!", message.Subject); Assert.AreEqual("This is the\r\nbody\r\n", message.Body); Assert.AreEqual(1, message.Headers.Count); #if !DOTNET40 Assert.AreEqual("Test Reply", message.ReplyTo.DisplayName); Assert.AreEqual("*****@*****.**", message.ReplyTo.Address); #else Assert.AreEqual(1, message.ReplyToList.Count()); Assert.AreEqual("Test Reply", message.ReplyToList.First().DisplayName); Assert.AreEqual("*****@*****.**", message.ReplyToList.First().Address); #endif } }
public void RenderMailMessage_BackwardCompatibility_UsesTemplateNameAsItIsIfStartsWithSlash() { const string templateName = "/emailtemplates/welcome"; using (mockRepository.Record()) { Expect.Call(viewEngineManagerMock.HasTemplate(templateName)).Return(true); viewEngineManagerMock.Process(templateName, null, engineContext, controller, controllerContext); LastCall.Constraints( Is.Equal(templateName), Is.Anything(), Is.Same(engineContext), Is.Same(controller), Is.Same(controllerContext)); } using (mockRepository.Playback()) { service.RenderMailMessage(templateName, engineContext, controller, controllerContext, false); } }
public void RenderMailMessage_InvokesViewEngineManager() { const string templateName = "welcome"; var parameters = new Hashtable(); using (mockRepository.Record()) { Expect.Call(viewEngineManagerMock.HasTemplate("mail\\" + templateName)).Return(true); viewEngineManagerMock.Process(templateName, "layout", null, null); LastCall.Constraints( Is.Equal("mail\\" + templateName), Is.Equal("layout"), Is.Anything(), Is.Anything()); } using (mockRepository.Playback()) { service.RenderMailMessage(templateName, "layout", parameters); } }
public void GeneratedStubFooCall() { FooRequest fooRequest = FooRequest.CreateBuilder().Build(); MockRepository mocks = new MockRepository(); IRpcChannel mockChannel = mocks.StrictMock <IRpcChannel>(); IRpcController mockController = mocks.StrictMock <IRpcController>(); TestService service = TestService.CreateStub(mockChannel); Action <FooResponse> doneHandler = mocks.StrictMock <Action <FooResponse> >(); using (mocks.Record()) { // Nasty way of mocking out "the channel calls the done handler". Expect.Call(() => mockChannel.CallMethod(null, null, null, null, null)) .IgnoreArguments() .Constraints(Is.Same(FooDescriptor), Is.Same(mockController), Is.Same(fooRequest), Is.Same(FooResponse.DefaultInstance), Is.Anything()) .Do((CallFooDelegate)((p1, p2, p3, response, done) => done(response))); doneHandler.Invoke(FooResponse.DefaultInstance); } service.Foo(mockController, fooRequest, doneHandler); mocks.VerifyAll(); }
public void DeleteFunctionTest() { #region arrange string id = "1"; SqlConnection conn = new SqlConnection(); SqlTransaction tran = null; int reNumber = 1; _dataAccess.Stub(o => o.ExcuteSQL(Arg <string> .Is.Anything, ref Arg <SqlConnection> .Ref(Is.Anything(), null).Dummy, ref Arg <SqlTransaction> .Ref(Is.Anything(), null).Dummy, Arg <object[]> .Is.Anything)).Return(reNumber); #endregion #region act var result = _target.DeleteFunction(id, ref conn, ref tran); #endregion #region assert Assert.AreEqual(result, reNumber); #endregion }
public void ShouldTellRemoteToShelveTreeish() { mocks.Get <Globals>().Repository = mocks.Get <IGitRepository>(); var remote = mocks.Get <IGitTfsRemote>(); //mocks.Get<IGitRepository>().Stub(x => x.ReadTfsRemote(null)).IgnoreArguments().Return(remote); mocks.Get <IGitRepository>().Stub(x => x.GetLastParentTfsCommits(null)).IgnoreArguments() .Return(new[] { new TfsChangesetInfo { Remote = remote } }); mocks.ClassUnderTest.Run("shelveset name", "treeish"); remote.AssertWasCalled(x => x.Shelve(null, null, null, false), y => y.Constraints(Is.Equal("shelveset name"), Is.Equal("treeish"), Is.Anything(), Is.Anything())); }
public void TestEditWorkgroupVendorPostRedirectsWhenValid() { #region Arrange new FakeVendors(3, VendorRepository); var workgroup = CreateValidEntities.Workgroup(15); workgroup.SetIdTo(15); var workgroupVendors = new List <WorkgroupVendor>(); workgroupVendors.Add(CreateValidEntities.WorkgroupVendor(5)); workgroupVendors[0].VendorId = null; workgroupVendors[0].VendorAddressTypeCode = null; workgroupVendors[0].Workgroup = workgroup; new FakeWorkgroupVendors(0, WorkgroupVendorRepository, workgroupVendors); var workgroupVendor = CreateValidEntities.WorkgroupVendor(9); workgroupVendor.Workgroup.SetIdTo(15); workgroupVendor.VendorId = null; workgroupVendor.VendorAddressTypeCode = null; workgroupVendor.Name = "Changed"; WorkgroupService.Expect(a => a.TransferValues(Arg <WorkgroupVendor> .Is.Anything, ref Arg <WorkgroupVendor> .Ref(Is.Anything(), workgroupVendor).Dummy)); #endregion Arrange #region Act var result = Controller.EditWorkgroupVendor(15, 1, workgroupVendor) .AssertActionRedirect() .ToAction <WorkgroupController>(a => a.VendorList(15)); #endregion Act #region Assert Assert.IsNotNull(result); Assert.AreEqual(15, result.RouteValues["id"]); Assert.AreEqual("WorkgroupVendor Edited Successfully", Controller.Message); WorkgroupVendorRepository.AssertWasCalled(a => a.EnsurePersistent(Arg <WorkgroupVendor> .Is.Anything), x => x.Repeat.Times(2)); var oldArgs = (WorkgroupVendor)WorkgroupVendorRepository.GetArgumentsForCallsMadeOn(a => a.EnsurePersistent(Arg <WorkgroupVendor> .Is.Anything))[0][0]; var newArgs = (WorkgroupVendor)WorkgroupVendorRepository.GetArgumentsForCallsMadeOn(a => a.EnsurePersistent(Arg <WorkgroupVendor> .Is.Anything))[1][0]; Assert.IsNotNull(oldArgs); Assert.AreEqual("Name5", oldArgs.Name); Assert.IsFalse(oldArgs.IsActive); Assert.IsNotNull(newArgs); Assert.AreEqual("Changed", newArgs.Name); Assert.IsTrue(newArgs.IsActive); #endregion Assert }
public void TestEditWorkgroupVendorPostReturnsViewWhenNotValid() { #region Arrange new FakeVendors(3, VendorRepository); var workgroupVendors = new List <WorkgroupVendor>(); workgroupVendors.Add(CreateValidEntities.WorkgroupVendor(5)); workgroupVendors[0].VendorId = null; workgroupVendors[0].VendorAddressTypeCode = null; new FakeWorkgroupVendors(0, WorkgroupVendorRepository, workgroupVendors); var workgroupVendor = CreateValidEntities.WorkgroupVendor(9); workgroupVendor.VendorId = null; workgroupVendor.VendorAddressTypeCode = null; workgroupVendor.Name = null; WorkgroupService.Expect(a => a.TransferValues(Arg <WorkgroupVendor> .Is.Anything, ref Arg <WorkgroupVendor> .Ref(Is.Anything(), workgroupVendor).Dummy)); #endregion Arrange #region Act var result = Controller.EditWorkgroupVendor(0, 1, workgroupVendor) .AssertViewRendered() .WithViewData <WorkgroupVendorViewModel>(); #endregion Act #region Assert Controller.ModelState.AssertErrorsAre("The Name field is required."); Assert.IsNotNull(result); Assert.AreEqual("Line19", result.WorkgroupVendor.Line1); #endregion Assert }
/// <summary> /// Handles the call /// </summary> /// <param name="method"></param> /// <param name="arguments"></param> public override void HandleMethodCall(MethodInfo method, object[] arguments) { if (!method.IsSpecialName) { throw new InvalidOperationException("Property expectations can only be set for properties."); } var methodName = method.Name; if (!methodName.StartsWith("get_") && !methodName.StartsWith("set_")) { throw new InvalidOperationException("Property expectations can only be set for properties."); } var propertyName = method.Name.Substring(4); PropertyInfo property; if (methodName.StartsWith("get_")) { var types = new Type[arguments.Length]; if (arguments.Length > 0) { for (int argumentIndex = 0; argumentIndex < arguments.Length; argumentIndex++) { types[argumentIndex] = arguments[argumentIndex].GetType(); } } property = method.DeclaringType.GetProperty(propertyName, types); } else { var argumentLength = (arguments.Length - 1); var types = new Type[argumentLength]; if (argumentLength > 0) { for (int argumentIndex = 0; argumentIndex < argumentLength; argumentIndex++) { types[argumentIndex] = arguments[argumentIndex].GetType(); } } property = method.DeclaringType.GetProperty(propertyName, types); } MethodGet = property.GetGetMethod(true); MethodSet = property.GetSetMethod(true); if (MethodGet == null || MethodSet == null) { throw new InvalidOperationException("Property must be read/write."); } if (ArgumentManager.HasBeenUsed) { ArgumentManager.ValidateMethodSignature(method); Arguments = ArgumentManager.GetConstraints(); ReturnArguments = ArgumentManager.GetReturnValues(); SetExpectedCount(new Range(1, null)); ArgumentManager.Clear(); return; } var parameters = method.GetParameters(); var constraints = new AbstractConstraint[parameters.Length]; for (int index = 0; index < parameters.Length; index++) { var parameter = parameters[index]; constraints[index] = (parameter.IsOut) ? Is.Anything() : Is.Equal(arguments[index]); } Arguments = constraints; }
public void TestCreateVendorPostWithInvalidValueReturnsView4() { #region Arrange SetupDataForVendors3(); var vendorToCreate = CreateValidEntities.WorkgroupVendor(9); vendorToCreate.VendorId = null; vendorToCreate.City = null; WorkgroupService.Expect(a => a.TransferValues(Arg <WorkgroupVendor> .Is.Anything, ref Arg <WorkgroupVendor> .Ref(Is.Anything(), vendorToCreate).Dummy)); #endregion Arrange #region Act var result = Controller.CreateVendor(3, vendorToCreate, true) .AssertViewRendered() .WithViewData <WorkgroupVendorViewModel>(); #endregion Act #region Assert WorkgroupVendorRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <WorkgroupVendor> .Is.Anything)); Controller.ModelState.AssertErrorsAre("The City field is required."); Assert.IsNotNull(result); Assert.AreEqual(true, result.NewVendor); Assert.AreEqual(null, result.VendorAddress); Assert.AreEqual(null, result.WorkgroupVendor.City); Assert.AreEqual("Line19", result.WorkgroupVendor.Line1); Assert.AreEqual(null, result.Vendor); #endregion Assert }