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
}
