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()); }