public void Test()
{
// Arrange
using var container = new MockingContainer <MyClassAuto>();
container.Arrange <INameProvider>(x => x.GetName()).Returns("A Name").MustBeCalled();
// or
//var nameProviderMock = Mock.Create<INameProvider>();
//nameProviderMock.Arrange(x => x.GetName()).Returns("A Name").MustBeCalled();
//container.Bind<INameProvider>().ToConstant(nameProviderMock);
// Act
var sut = container.Instance;
sut.DoGreeting();
// Assert
container.Assert();
var greetingServiceMock = container.Get <IGreetingService>();
greetingServiceMock.Assert(x => x.Greet("A Name"));
//Assert.Equal(1, Mock.GetTimesCalled(() => greetingServiceMock.Greet("A Name")));
// This throws an exception
//Assert.Equal(1, Mock.GetTimesCalled(() => container.Get<IGreetingService>().Greet("A Name")));
}
public void ShouldAssertOccurrenceFromContainerWithoutPriorArrangement()
{
var c = new MockingContainer <Unit>();
c.Instance.DoWork();
c.Assert <IUnitOfWork>(x => x.DoWork());
}
public void ShouldInjectAbstractType()
{
var c = new MockingContainer <DependencyBase>();
var obj = c.Instance;
Assert.NotNull(obj.Dep);
}
public void Handle_SimpleMessage_ReturnsTrue()
{
MockingContainer container = new MockingContainer(new MockRepository());
MessageHandler mw = container.ResolveRealObject<MessageHandler>();
bool handle = mw.Handle("a");
Assert.IsTrue(handle);
}
public void ShouldCheckPropertyMixinOnNonabstractPropertyOnInjectedAbstractType()
{
var c = new MockingContainer <DependencyBase>();
var obj = c.Instance;
obj.BaseValue = 10;
Assert.Equal(10, obj.baseValue);
}
public void ShouldArrangeMethodsOnInjectedAbstractType()
{
var c = new MockingContainer <DependencyBase>();
var obj = c.Instance;
Mock.Arrange(() => obj.Value).Returns(5);
Assert.Equal(5, obj.Value);
}
public void ShouldSpecifyDependencyBehavior()
{
var container = new MockingContainer <FileLog>(new AutoMockSettings {
MockBehavior = Behavior.Strict
});
Assert.Throws <StrictMockException>(() => container.Instance.LogExists());
}
public void ShouldAssertPropertySetNegativeWithMatcher()
{
// Arrange
var container = new MockingContainer <Module>();
// Assert
container.AssertSet <IService>(x => x.Value = Arg.AnyInt, Occurs.Never());
}
public void ShouldMakeSingletonExplicitlyRequestedServices()
{
var container = new MockingContainer <Module>();
var s1 = container.Get <IService>();
var s2 = container.Instance.service;
Assert.Same(s1, s2);
}
public void ShouldCreateMocksOfDependencies()
{
var container = new MockingContainer <FileLog>();
container.Arrange <IFileSystem>(x => x.Exists("123")).Returns(true);
container.Arrange <ICalendar>(x => x.Now).Returns(new DateTime(123));
Assert.True(container.Instance.LogExists());
}
public void Setup()
{
tempDir = TempDirectoriesFactory.CreateEmpty();
container = new MockingContainer <ChangelogManager>();
container.Arrange <IBinDirectory>(directory => directory.FullPath).Returns(tempDir.FullName);
WriteSampleChangelog();
}
public void ShouldCreateMocksOfDependencies()
{
var container = new MockingContainer<FileLog>();
container.Arrange<IFileSystem>(x => x.Exists("123")).Returns(true);
container.Arrange<ICalendar>(x => x.Now).Returns(new DateTime(123));
Assert.True(container.Instance.LogExists());
}
public LoginUtilTests()
{
autoMockSettings = new AutoMockSettings
{
ConstructorArgTypes = new Type[] { typeof(IConnectionMonitor), typeof(ILoginDomainService) }
};
LoginUtil.Instance.ValidateUserLogin(TestHelper.TestUsers[0].UserName, TestHelper.TestUsers[0].Password, TestHelper.TestUsers[0].CountryCode).Wait();
container = new MockingContainer <LoginUtil>(autoMockSettings);
}
public void ShouldAssertPropertySetNegative()
{
DebugView.IsTraceEnabled = true;
// Arrange
var container = new MockingContainer <Module>();
// Assert
container.AssertSet <IService>(x => x.Value = 99, Occurs.Never());
}
public void ShouldArrangeMultipleInstancesSeparatelyByPropertyName()
{
var container = new MockingContainer <TransactionService>();
container.Bind <IAccount>().ToMock().InjectedIntoProperty("BillingAccount").AndArrange(x => Mock.Arrange(() => x.Id).Returns(30));
var inst = container.Instance;
Assert.Equal(30, inst.BillingAccount.Id);
}
public void ShouldInjectAbstractTypeWithSpecifiedCtor()
{
var c = new MockingContainer <DependencyBase>(
new AutoMockSettings {
ConstructorArgTypes = new[] { typeof(IDisposable) }
});
var obj = c.Instance;
Assert.NotNull(obj.Dep);
}
public void ShouldResolveTargetTypeWithInterfaceAndConcreteDependencies()
{
var container = new MockingContainer <Unit>();
container.Arrange <IUnitOfWork>(uow => uow.DoWork()).MustBeCalled();
// this is where it resolves.
container.Instance.DoWork();
container.Assert();
}
public void ShouldAssertThatReportsAreReceived()
{
var container = new MockingContainer<Reporter>();
container.Arrange<IReportBuilder>(rb => rb.GetReports()).Returns(new[] { new Report(), new Report() }).MustBeCalled();
container.Arrange<IReportSender>(rs => rs.SendReport(Arg.IsAny<Report>()));
container.Instance.SendReports();
container.Assert<IReportBuilder>();
}
public void ShouldAssertThatReportIsSent()
{
var container = new MockingContainer<Reporter>();
container.Arrange<IReportBuilder>(rb => rb.GetReports()).Returns(new[] { new Report(), new Report() });
container.Arrange<IReportSender>(rs => rs.SendReport(Arg.IsAny<Report>())).Occurs(2);
container.Instance.SendReports();
container.AssertAll();
}
public void ShouldAssertSpecificallyThatSendReportMethodIsCalledTwice()
{
var container = new MockingContainer<Reporter>();
container.Arrange<IReportBuilder>(rb => rb.GetReports()).Returns(new[] { new Report(), new Report() });
container.Arrange<IReportSender>(rs => rs.SendReport(Arg.IsAny<Report>())).Occurs(2);
container.Instance.SendReports();
container.Assert<IReportSender>(rs => rs.SendReport(Arg.IsAny<Report>()));
}
public void ShouldAssertPropertySetWithMatcher()
{
// Arrange
var container = new MockingContainer <Module>();
// Act
container.Get <IService>().Value = 99;
// Assert
container.AssertSet <IService>(x => x.Value = Arg.AnyInt);
}
public void ShouldInjectContainers()
{
var c = new MockingContainer <DisposableContainer>();
var disposables = new List <IDisposable> {
Mock.Create <IDisposable>(), Mock.Create <IDisposable>()
};
var i = c.Get <DisposableContainer>(new ConstructorArgument("disposables", disposables));
i.Dispose();
Assert.Equal(0, disposables.Count);
}
public void ShouldArrangeSingletonInstances()
{
var container = new MockingContainer <TransactionService>();
container.Arrange <IAccount>(x => x.Id).Returns(10);
var inst = container.Instance;
Assert.NotNull(inst.From);
Assert.Same(inst.From, inst.To);
Assert.Same(inst.From, inst.BillingAccount);
}
public void Handle_SimpleMessage_SendEmail()
{
MockRepository mocks = new MockRepository();
MockingContainer container = new MockingContainer(mocks);
MessageHandler mw = container.ResolveRealObject<MessageHandler>();
using(mocks.Record())
{
container.Resolve<IEmailer>()
.Send("message","a","*****@*****.**");
}
bool handle = mw.Handle("a");
mocks.VerifyAll();
}
public void ShouldIncludeAssertionMessageWhenAssertingContainer()
{
var c = new MockingContainer <FileLog>();
c.Arrange <ICalendar>(x => x.Now).MustBeCalled("Calendar must be used!");
c.Arrange <IFileSystem>(x => x.Refresh()).MustBeCalled("Should use latest data!");
var ex = Assert.Throws <AssertionException>(() => c.Assert("Container must be alright!"));
Assert.True(ex.Message.Contains("Calendar must be used!"));
Assert.True(ex.Message.Contains("Should use latest data!"));
Assert.True(ex.Message.Contains("Container must be alright!"));
}
public void ShouldAssertRaisesAgainstMethod()
{
var container = new MockingContainer <Executor>();
bool raised = false;
container.Arrange <IExecutor>(x => x.Submit()).Raises(() => container.Get <IExecutor>().Done += null, EventArgs.Empty);
container.Get <IExecutor>().Done += delegate { raised = true; };
container.Instance.Submit();
Assert.True(raised);
}
public void ShouldAssertMockingNestedDependency()
{
var container = new MockingContainer <Foo>();
container.Bind <Bar>().ToSelf();
container.Arrange <IUnitOfWork>(uow => uow.DoWork()).MustBeCalled();
Assert.Throws <AssertionException>(() => container.Assert());
container.Instance.DoWork();
container.Assert();
}
public void ShouldAssertArrangedExpectations()
{
var container = new MockingContainer <FileLog>();
container.Arrange <IFileSystem>(x => x.Refresh()).MustBeCalled();
container.Arrange <IFileSystem>(x => x.Exists("123")).Returns(true).MustBeCalled();
container.Arrange <ICalendar>(x => x.Now).Returns(new DateTime(123)).MustBeCalled();
Assert.Throws <AssertionException>(() => container.Assert());
container.Instance.LogExists();
container.Assert();
}
public void ShouldAssertArrangedExpectations()
{
var container = new MockingContainer<FileLog>();
container.Arrange<IFileSystem>(x => x.Refresh()).MustBeCalled();
container.Arrange<IFileSystem>(x => x.Exists("123")).Returns(true).MustBeCalled();
container.Arrange<ICalendar>(x => x.Now).Returns(new DateTime(123)).MustBeCalled();
Assert.Throws<AssertFailedException>(() => container.Assert());
container.Instance.LogExists();
container.Assert();
}
public void ShouldArrangePropertySetWithMatcher()
{
// Arrange
var container = new MockingContainer <Module>();
container.ArrangeSet <IService>(x => x.Value = Arg.AnyInt).MustBeCalled();
var service = container.Get <IService>();
// Act
service.Value = 99;
// Assert
container.Assert <IService>();
}
/// <summary>
/// Return mocking container for <see cref="ExecuteScript"/>.
/// </summary>
/// <returns>ExecuteScript.</returns>
private MockingContainer <BookingBusiness> GetMockingContainer()
{
var container = new MockingContainer <BookingBusiness>(new AutoMockSettings()
{
ConstructorArgTypes = typeof(BookingBusiness).GetConstructors()
.OrderByDescending(c => c.GetParameters().Count())
.First()
.GetParameters()
.Select(p => p.ParameterType)
.ToArray(),
MockBehavior = Behavior.Strict,
});
return(container);
}
public void WithAutomocking()
{
//Arrange
var container = new MockingContainer<ClassUnderTest>();
var expectedResult = "Hello";
container
.Arrange<ISecondDependency>(x => x.GetString())
.Returns(expectedResult);
//Act
var result = container.Instance.StringMethod();
//Assert
Assert.AreEqual(expectedResult, result);
}
public void ShouldAssertDependenciesDirectly()
{
var container = new MockingContainer <FileLog>();
container.Arrange <ICalendar>(x => x.Now).Returns(new DateTime(123));
Assert.Throws <AssertionException>(() => container.Assert <IFileSystem>(x => x.Refresh(), Occurs.Once()));
Assert.Throws <AssertionException>(() => container.Assert <IFileSystem>(x => x.Exists("123"), Occurs.Once()));
Assert.Throws <AssertionException>(() => container.Assert <ICalendar>(x => x.Now, Occurs.Once()));
container.Instance.LogExists();
container.Assert <IFileSystem>(x => x.Refresh(), Occurs.Once());
container.Assert <IFileSystem>(x => x.Exists("123"), Occurs.Once());
container.Assert <ICalendar>(x => x.Now, Occurs.Once());
}
public void WithAutomocking()
{
//Arrange
var container = new MockingContainer <ClassUnderTest>();
var expectedResult = "Hello";
container
.Arrange <ISecondDependency>(x => x.GetString())
.Returns(expectedResult);
//Act
var result = container.Instance.StringMethod();
//Assert
Assert.AreEqual(expectedResult, result);
}
public void ShouldAutoMockConcretedDependecies()
{
// ARRANGE
// Creating a MockingContainer of PersonRepository.
// To instantiate the system under test (the container) you should use the Instance property
// For example: container.Instance.
var container = new MockingContainer <PersonRepository>();
// Arranging: That the Walk() method from the Person instance
// must be called from the container during the test method.
container.Arrange <Person>(anml => anml.Walk()).MustBeCalled();
// ACT - Calling Walk() from the mocked instance of PersonRepository
container.Instance.Walk();
// ASSERT - Asserting all expectations against this method.
container.Assert <Person>(anml => anml.Walk());
}
public void ShouldAssertAllContainerArrangments()
{
// ARRANGE
// Creating a MockingContainer of ClassUnderTest.
// To instantiate the system uder test (the container) you should use the Instance property
// For example: container.Instance.
var container = new MockingContainer<ClassUnderTest>();
// Arranging: That the GetString() method from the ISecondDependecy interface
// must be called from the container instance durring the test method.
container.Arrange<ISecondDependency>(
secondDep => secondDep.GetString()).MustBeCalled();
// ACT - Calling SringMethod() from the mocked instance of ClassUnderTest
var actualString = container.Instance.StringMethod();
// ASSERT - Asserting all expectations for the container.
container.AssertAll();
}
public void ShouldAssertAllContainerArrangments()
{
// ARRANGE
// Creating a MockingContainer of ClassUnderTest.
// To instantiate the system uder test (the container) you should use the Instance property
// For example: container.Instance.
var container = new MockingContainer <ClassUnderTest>();
// Arranging: That the GetString() method from the ISecondDependecy interface
// must be called from the container instance durring the test method.
container.Arrange <ISecondDependency>(
secondDep => secondDep.GetString()).MustBeCalled();
// ACT - Calling SringMethod() from the mocked instance of ClassUnderTest
var actualString = container.Instance.StringMethod();
// ASSERT - Asserting all expectations for the container.
container.AssertAll();
}
public void ShouldAssertMultipleInstancesByName()
{
var container = new MockingContainer <TransactionService>();
container.Bind <IAccount>().ToMock().InjectedIntoParameter("fromAccount").Named("from")
.AndArrange(x => Mock.Arrange(() => x.Id).Returns(10));
container.Bind <IAccount>().ToMock().InjectedIntoParameter("toAccount").Named("to")
.AndArrange(x => Mock.Arrange(() => x.Id).Returns(20));
container.Bind <IAccount>().ToMock().InjectedIntoProperty((TransactionService s) => s.BillingAccount).Named("bill")
.AndArrange(x => Mock.Arrange(() => x.Id).Returns(30));
var inst = container.Instance;
inst.TransferFunds(10);
container.Assert <IAccount>("from", x => x.Withdraw(11), Occurs.Once());
container.Assert <IAccount>("to", x => x.Deposit(10), Occurs.Once());
container.Assert <IAccount>("bill", x => x.Deposit(1), Occurs.Once());
}
public void ShouldSelectConstructorBasedOnSettings()
{
// assert the default NInject behavior that injects into the constructor with most parameters
var container = new MockingContainer <VariousCtors>();
Assert.Throws <InvalidOperationException>(() => { var inst = container.Instance; });
// assert the overriden constructor lookup behavior
var container2 = new MockingContainer <VariousCtors>(new AutoMockSettings {
ConstructorArgTypes = new[] { typeof(IFileSystem) }
});
Assert.NotNull(container2.Instance);
// assert that specifying an invalid constructor throws
Assert.Throws <MockException>(() => new MockingContainer <VariousCtors>(new AutoMockSettings {
ConstructorArgTypes = new[] { typeof(ICalendar) }
}));
}
public void ShouldMockDependenciesWithContainer()
{
// ARRANGE
// Creating a MockingContainer of ClassUnderTest.
// To instantiate the system uder test (the container) you should use the Instance property
// For example: container.Instance.
var container = new MockingContainer<ClassUnderTest>();
string expectedString = "Test";
// Arranging: When the GetString() method from the ISecondDependecy interface
// is called from the container, it should return expectedString.
container.Arrange<ISecondDependency>(
secondDep => secondDep.GetString()).Returns(expectedString);
// ACT - Calling SringMethod() from the mocked instance of ClassUnderTest
var actualString = container.Instance.StringMethod();
// ASSERT
Assert.AreEqual(expectedString, actualString);
}
public void ShouldAssertOccurrenceFromContainerWithoutPriorArrangement()
{
var c = new MockingContainer<Unit>();
c.Instance.DoWork();
c.Assert<IUnitOfWork>(x => x.DoWork());
}
public void ShouldInjectContainers()
{
var c = new MockingContainer<DisposableContainer>();
var disposables = new List<IDisposable> { Mock.Create<IDisposable>(), Mock.Create<IDisposable>() };
var i = c.Get<DisposableContainer>(new ConstructorArgument("disposables", disposables));
i.Dispose();
Assert.Equal(0, disposables.Count);
}
public void ShouldInjectAbstractType()
{
var c = new MockingContainer<DependencyBase>();
var obj = c.Instance;
Assert.NotNull(obj.Dep);
}
public void ShouldSelectConstructorBasedOnSettings()
{
// assert the default NInject behavior that injects into the constructor with most parameters
var container = new MockingContainer<VariousCtors>();
Assert.Throws<InvalidOperationException>(() => { var inst = container.Instance; });
// assert the overriden constructor lookup behavior
var container2 = new MockingContainer<VariousCtors>(new AutoMockSettings { ConstructorArgTypes = new[] { typeof(IFileSystem) } });
Assert.NotNull(container2.Instance);
// assert that specifying an invalid constructor throws
Assert.Throws<MockException>(() => new MockingContainer<VariousCtors>(new AutoMockSettings { ConstructorArgTypes = new[] { typeof(ICalendar) } }));
}
public void ShouldIncludeAssertionMessageWhenAssertingContainer()
{
var c = new MockingContainer<FileLog>();
c.Arrange<ICalendar>(x => x.Now).MustBeCalled("Calendar must be used!");
c.Arrange<IFileSystem>(x => x.Refresh()).MustBeCalled("Should use latest data!");
var ex = Assert.Throws<AssertFailedException>(() => c.Assert("Container must be alright!"));
Assert.True(ex.Message.Contains("Calendar must be used!"));
Assert.True(ex.Message.Contains("Should use latest data!"));
Assert.True(ex.Message.Contains("Container must be alright!"));
}
public void CreatehandlerUsingMockingContainer()
{
MockingContainer container = new MockingContainer(new MockRepository());
MessageHandler mw = container.ResolveRealObject<MessageHandler>();
Assert.IsNotNull(mw);
}
public void ShouldAssertRaisesAgainstMethod()
{
var container = new MockingContainer<Executor>();
bool raised = false;
container.Arrange<IExecutor>(x => x.Submit()).Raises(() => container.Get<IExecutor>().Done += null, EventArgs.Empty);
container.Get<IExecutor>().Done += delegate { raised = true; };
container.Instance.Submit();
Assert.True(raised);
}
public void ShouldSpecifyDependencyBehavior()
{
var container = new MockingContainer<FileLog>(new AutoMockSettings { MockBehavior = Behavior.Strict });
Assert.Throws<StrictMockException>(() => container.Instance.LogExists());
}
public void ShouldArrangeSingletonInstances()
{
var container = new MockingContainer<TransactionService>();
container.Arrange<IAccount>(x => x.Id).Returns(10);
var inst = container.Instance;
Assert.NotNull(inst.From);
Assert.Same(inst.From, inst.To);
Assert.Same(inst.From, inst.BillingAccount);
}
public void ShouldArrangeMultipleInstancesSeparatelyByPropertyName()
{
var container = new MockingContainer<TransactionService>();
container.Bind<IAccount>().ToMock().InjectedIntoProperty("BillingAccount").AndArrange(x => Mock.Arrange(() => x.Id).Returns(30));
var inst = container.Instance;
Assert.Equal(30, inst.BillingAccount.Id);
}
public void ShouldAssertMultipleInstancesByName()
{
var container = new MockingContainer<TransactionService>();
container.Bind<IAccount>().ToMock().InjectedIntoParameter("fromAccount").Named("from")
.AndArrange(x => Mock.Arrange(() => x.Id).Returns(10));
container.Bind<IAccount>().ToMock().InjectedIntoParameter("toAccount").Named("to")
.AndArrange(x => Mock.Arrange(() => x.Id).Returns(20));
container.Bind<IAccount>().ToMock().InjectedIntoProperty((TransactionService s) => s.BillingAccount).Named("bill")
.AndArrange(x => Mock.Arrange(() => x.Id).Returns(30));
var inst = container.Instance;
inst.TransferFunds(10);
container.Assert<IAccount>("from", x => x.Withdraw(11), Occurs.Once());
container.Assert<IAccount>("to", x => x.Deposit(10), Occurs.Once());
container.Assert<IAccount>("bill", x => x.Deposit(1), Occurs.Once());
}
public void ShouldResolveTargetTypeWithInterfaceAndConcreteDependencies()
{
var container = new MockingContainer<Unit>();
container.Arrange<IUnitOfWork>(uow => uow.DoWork()).MustBeCalled();
// this is where it resolves.
container.Instance.DoWork();
container.Assert();
}
public void ShouldAssertMockingNestedDependency()
{
var container = new MockingContainer<Foo>();
container.Bind<Bar>().ToSelf();
container.Arrange<IUnitOfWork>(uow => uow.DoWork()).MustBeCalled();
Assert.Throws<AssertFailedException>(() => container.Assert());
container.Instance.DoWork();
container.Assert();
}
public void ShouldInjectAbstractTypeWithSpecifiedCtor()
{
var c = new MockingContainer<DependencyBase>(
new AutoMockSettings { ConstructorArgTypes = new[] { typeof(IDisposable) } });
var obj = c.Instance;
Assert.NotNull(obj.Dep);
}
public void ShouldMakeSingletonExplicitlyRequestedServices()
{
var container = new MockingContainer<Module>();
var s1 = container.Get<IService>();
var s2 = container.Instance.service;
Assert.Same(s1, s2);
}
public void ShouldCheckPropertyMixinOnNonabstractPropertyOnInjectedAbstractType()
{
var c = new MockingContainer<DependencyBase>();
var obj = c.Instance;
obj.BaseValue = 10;
Assert.Equal(10, obj.baseValue);
}
public void Initialize()
{
_container = new MockingContainer<GestureProvider>();
}
public void ShouldArrangeMethodsOnInjectedAbstractType()
{
var c = new MockingContainer<DependencyBase>();
var obj = c.Instance;
Mock.Arrange(() => obj.Value).Returns(5);
Assert.Equal(5, obj.Value);
}
public void ShouldImplicitlyArrangeSeparateInstances()
{
var container = new MockingContainer<TransactionService>();
var inst = container.Instance;
Assert.NotNull(inst.From);
Assert.NotNull(inst.To);
Assert.NotNull(inst.BillingAccount);
Assert.NotSame(inst.From, inst.To);
Assert.NotSame(inst.From, inst.BillingAccount);
}
public void ShouldAssertDependenciesDirectly()
{
var container = new MockingContainer<FileLog>();
container.Arrange<ICalendar>(x => x.Now).Returns(new DateTime(123));
Assert.Throws<AssertFailedException>(() => container.Assert<IFileSystem>(x => x.Refresh(), Occurs.Once()));
Assert.Throws<AssertFailedException>(() => container.Assert<IFileSystem>(x => x.Exists("123"), Occurs.Once()));
Assert.Throws<AssertFailedException>(() => container.Assert<ICalendar>(x => x.Now, Occurs.Once()));
container.Instance.LogExists();
container.Assert<IFileSystem>(x => x.Refresh(), Occurs.Once());
container.Assert<IFileSystem>(x => x.Exists("123"), Occurs.Once());
container.Assert<ICalendar>(x => x.Now, Occurs.Once());
}
