public void Test_WithIncompatibleVariables() { var object1 = new object(); var object2 = new object(); var invalidOperationException = new InvalidOperationException("Oh nos!"); TransactionMock.BackToRecord(); TransactionFactoryMock.BackToRecord(); TransactionMock.Stub(mock => mock.Release()); TransactionFactoryMock.Stub(mock => mock.Create()).Return(_newTransactionMock); ExecutionContextMock.Stub(mock => mock.GetVariables()).Return(new[] { object1, object2 }); _newTransactionMock .Stub(mock => mock.EnsureCompatibility(Arg <IEnumerable> .List.ContainsAll(new[] { object1, object2 }))) .Throw(invalidOperationException); MockRepository.ReplayAll(); Assert.That( () => _strategy.Reset(), Throws .TypeOf <WxeException>() .With.Message.EqualTo( "One or more of the variables of the WxeFunction are incompatible with the new transaction after the Reset. Oh nos! " + "(To avoid this exception, clear the Variables collection from incompatible objects before calling Reset and repopulate it " + "afterwards.)") .And.InnerException.SameAs(invalidOperationException)); Assert.That(_strategy.Scope, Is.Null); Assert.That(_strategy.Transaction, Is.SameAs(_newTransactionMock)); }
public void Test_WithScope() { var object1 = new object(); var object2 = new object(); InvokeOnExecutionPlay(_strategy); TransactionMock.BackToRecord(); TransactionFactoryMock.BackToRecord(); var newScopeMock = MockRepository.StrictMock <ITransactionScope>(); using (MockRepository.Ordered()) { ScopeMock.Expect(mock => mock.Leave()); TransactionMock.Expect(mock => mock.Release()); TransactionFactoryMock.Expect(mock => mock.Create()).Return(_newTransactionMock); _newTransactionMock.Expect(mock => mock.EnterScope()).Return(newScopeMock); ExecutionContextMock.Expect(mock => mock.GetVariables()).Return(new[] { object1, object2 }); _newTransactionMock.Expect(mock => mock.EnsureCompatibility(Arg <IEnumerable> .List.ContainsAll(new[] { object1, object2 }))); } Assert.That(_strategy.Scope, Is.SameAs(ScopeMock)); MockRepository.ReplayAll(); _strategy.Reset(); MockRepository.VerifyAll(); Assert.That(_strategy.Scope, Is.SameAs(newScopeMock)); }
public void Test_WithScope_And_ResetThrows() { InvokeOnExecutionPlay(_strategy); var exception = new ApplicationException("Reset Exception"); TransactionFactoryMock.BackToRecord(); TransactionMock.BackToRecord(); using (MockRepository.Ordered()) { ScopeMock.Expect(mock => mock.Leave()); TransactionMock.Expect(mock => mock.Release()); TransactionFactoryMock.Expect(mock => mock.Create()).Throw(exception); } Assert.That(_strategy.Scope, Is.SameAs(ScopeMock)); MockRepository.ReplayAll(); try { _strategy.Reset(); Assert.Fail("Expected Exception"); } catch (ApplicationException actualException) { Assert.That(actualException, Is.SameAs(exception)); } MockRepository.VerifyAll(); Assert.That(_strategy.Scope, Is.SameAs(ScopeMock)); Assert.That(_strategy.Transaction, Is.SameAs(TransactionMock), "Transaction just released is retained."); }
public void CreateChildTransactionStrategy_AfterPlay_Throws() { InvokeOnExecutionPlay(_strategy); var childTransaction = MockRepository.GenerateStub <ITransaction> (); TransactionMock.Expect(mock => mock.CreateChild()).Return(childTransaction); ApplicationException innerException = new ApplicationException("EnterScope Exception"); childTransaction.Expect(mock => mock.EnterScope()).Throw(innerException); var childExecutionContextStub = MockRepository.GenerateStub <IWxeFunctionExecutionContext> (); childExecutionContextStub.Stub(stub => stub.GetInParameters()).Return(new object[0]); MockRepository.ReplayAll(); try { _strategy.CreateChildTransactionStrategy(true, childExecutionContextStub, Context); Assert.Fail("Expected Exception"); } catch (WxeFatalExecutionException e) { MockRepository.VerifyAll(); Assert.That(e.InnerException, Is.SameAs(innerException)); Assert.That(_strategy.Child, Is.InstanceOf(typeof(ChildTransactionStrategy))); } }
public void CreateChildTransactionStrategy_AfterPlay() { InvokeOnExecutionPlay(_strategy); var childTransaction = MockRepository.GenerateStub <ITransaction> (); TransactionMock.Expect(mock => mock.CreateChild()).Return(childTransaction); ITransactionScope childScope = MockRepository.GenerateStub <ITransactionScope>(); childTransaction.Expect(mock => mock.EnterScope()).Return(childScope); var childExecutionContextStub = MockRepository.GenerateStub <IWxeFunctionExecutionContext> (); childExecutionContextStub.Stub(stub => stub.GetInParameters()).Return(new object[0]); MockRepository.ReplayAll(); TransactionStrategyBase childTransactionStrategy = _strategy.CreateChildTransactionStrategy(true, childExecutionContextStub, Context); MockRepository.VerifyAll(); Assert.That(childTransactionStrategy, Is.InstanceOf(typeof(ChildTransactionStrategy))); Assert.That(((ChildTransactionStrategy)childTransactionStrategy).AutoCommit, Is.True); Assert.That(((ChildTransactionStrategy)childTransactionStrategy).Transaction, Is.SameAs(childTransaction)); Assert.That(childTransactionStrategy.OuterTransactionStrategy, Is.SameAs(_strategy)); Assert.That(((ChildTransactionStrategy)childTransactionStrategy).ExecutionContext, Is.SameAs(childExecutionContextStub)); Assert.That(((ChildTransactionStrategy)childTransactionStrategy).Scope, Is.SameAs(childScope)); Assert.That(_strategy.Child, Is.SameAs(childTransactionStrategy)); }
public void Test_ReleaseThrows() { var strategy = CreateScopedTransactionStrategy(false, NullTransactionStrategy.Null); var innerException = new Exception("Release Exception"); InvokeOnExecutionPlay(strategy); ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionStop(Context, ExecutionListenerStub)); ExecutionContextMock.Expect(mock => mock.GetOutParameters()).Return(new object[0]); ScopeMock.Expect(mock => mock.Leave()); TransactionMock.Expect(mock => mock.Release()).Throw(innerException); MockRepository.ReplayAll(); try { strategy.OnExecutionStop(Context, ExecutionListenerStub); Assert.Fail("Expected Exception"); } catch (WxeFatalExecutionException actualException) { Assert.That(actualException.InnerException, Is.SameAs(innerException)); } MockRepository.VerifyAll(); Assert.That(strategy.Scope, Is.Null); }
public void Test_ChildStrategyThrows() { var innerException = new ApplicationException("InnerListener Exception"); using (MockRepository.Ordered()) { TransactionMock.Expect(mock => mock.EnterScope()).Return(ScopeMock); ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionPlay(Context, ExecutionListenerStub)).Throw(innerException); } MockRepository.ReplayAll(); try { _strategy.OnExecutionPlay(Context, ExecutionListenerStub); Assert.Fail("Expected Exception"); } catch (ApplicationException actualException) { Assert.That(actualException, Is.SameAs(innerException)); } MockRepository.VerifyAll(); Assert.That(_strategy.Scope, Is.Not.Null); }
public void Test_WithParentTransactionStrategy() { var strategy = CreateScopedTransactionStrategy(true, OuterTransactionStrategyMock); var expectedObjects = new[] { new object() }; InvokeOnExecutionPlay(strategy); using (MockRepository.Ordered()) { ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionStop(Context, ExecutionListenerStub)); TransactionMock.Expect(mock => mock.Commit()); ExecutionContextMock.Expect(mock => mock.GetOutParameters()).Return(expectedObjects); OuterTransactionStrategyMock.Expect(mock => mock.EnsureCompatibility(expectedObjects)); ScopeMock.Expect(mock => mock.Leave()); TransactionMock.Expect(mock => mock.Release()); } MockRepository.ReplayAll(); strategy.OnExecutionStop(Context, ExecutionListenerStub); MockRepository.VerifyAll(); Assert.That(strategy.Scope, Is.Null); }
public void Test_ChildStrategyThrows_And_ReleaseThrows() { var innerException = new Exception("InnerListener Exception"); var outerException = new Exception("Release Exception"); InvokeOnExecutionPlay(_strategy); using (MockRepository.Ordered()) { ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionFail(Context, ExecutionListenerStub, _failException)).Throw(innerException); ScopeMock.Expect(mock => mock.Leave()); TransactionMock.Expect(mock => mock.Release()).Throw(outerException); } MockRepository.ReplayAll(); try { _strategy.OnExecutionFail(Context, ExecutionListenerStub, _failException); Assert.Fail("Expected Exception"); } catch (WxeFatalExecutionException actualException) { Assert.That(actualException.InnerException, Is.SameAs(innerException)); Assert.That(actualException.OuterException, Is.SameAs(outerException)); } MockRepository.VerifyAll(); Assert.That(_strategy.Scope, Is.Null); }
public void Test_WithoutScope_And_CreateThrows() { var exception = new ApplicationException("Reset Exception"); TransactionMock.BackToRecord(); TransactionMock.Expect(mock => mock.Release()); TransactionFactoryMock.BackToRecord(); TransactionFactoryMock.Expect(mock => mock.Create()).Throw(exception); Assert.That(_strategy.Scope, Is.Null); MockRepository.ReplayAll(); try { _strategy.Reset(); Assert.Fail("Expected Exception"); } catch (ApplicationException actualException) { Assert.That(actualException, Is.SameAs(exception)); } MockRepository.VerifyAll(); Assert.That(_strategy.Scope, Is.Null); Assert.That(_strategy.Transaction, Is.SameAs(TransactionMock), "Transaction just released is retained."); }
public async Task VerifyGetDebitTransaction_ReturnAccountViewModelTestAsync() { var account = AccountMock.AccountModelFaker.Generate(); var transactionDebitInputViewModel = TransactionMock.TransactionDebitInputViewModelModelFaker.Generate(); _mapperMock.Setup(x => x.Map <Transaction>(It.IsAny <TransactionInputViewModel>())) .Returns(TransactionMock.TransactionModelFakerTyped(transactionDebitInputViewModel).Generate()); _mapperMock.Setup(x => x.Map <TransactionViewModel>(It.IsAny <Transaction>())) .Returns(TransactionMock.TransactionViewModelModelFaker.Generate()); _accountRepositoryMock.Setup(x => x.GetAccountById(account.Id)) .ReturnsAsync(AccountMock.AccountModelFaker.Generate()); _transactionServiceMock.Setup(x => x.DebitAccount(It.IsAny <Transaction>())) .Returns(Task.CompletedTask); var accountAppService = new AccountAppService(_accountRepositoryMock.Object, _mapperMock.Object, _transactionServiceMock.Object, _domainNotificationMock.Object); var accountMethod = await accountAppService.Transaction(transactionDebitInputViewModel); var accountResult = Assert.IsAssignableFrom <TransactionViewModel>(accountMethod); _transactionServiceMock.Verify(x => x.DebitAccount(It.IsAny <Transaction>()), Times.Once()); Assert.NotNull(accountResult); }
public async Task HandleAsync_WithSomeItemsOfItemCategoryOnActiveShoppingLists_ShouldStoreItemsAndShoppingListsAndDeleteItemCategory() { // Arrange var fixture = commonFixture.GetNewFixture(); ItemCategoryRepositoryMock itemCategoryRepositoryMock = new ItemCategoryRepositoryMock(fixture); ItemRepositoryMock itemRepositoryMock = new ItemRepositoryMock(fixture); ShoppingListRepositoryMock shoppingListRepositoryMock = new ShoppingListRepositoryMock(fixture); TransactionGeneratorMock transactionGeneratorMock = new TransactionGeneratorMock(fixture); ItemCategoryMock itemCategoryMock = itemCategoryMockFixtur.Create(); var storeItemMocks = storeItemMockFixture.CreateMany(2).ToList(); var shoppingLists = new Dictionary <StoreItemMock, List <ShoppingListMock> >(); foreach (var storeItemMock in storeItemMocks) { int amount = commonFixture.NextInt(1, 5); var listMocks = shoppingListMockFixture.CreateMany(amount).ToList(); shoppingLists.Add(storeItemMock, listMocks); shoppingListRepositoryMock.SetupFindActiveByAsync(storeItemMock.Object.Id, listMocks.Select(m => m.Object)); } TransactionMock transactionMock = new TransactionMock(); var command = fixture.Create <DeleteItemCategoryCommand>(); var handler = fixture.Create <DeleteItemCategoryCommandHandler>(); itemCategoryRepositoryMock.SetupFindByAsync(command.ItemCategoryId, itemCategoryMock.Object); itemRepositoryMock.SetupFindActiveByAsync(command.ItemCategoryId, storeItemMocks.Select(m => m.Object)); transactionGeneratorMock.SetupGenerateAsync(transactionMock.Object); // Act var result = await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { result.Should().BeTrue(); itemCategoryMock.VerifyDeleteOnce(); foreach (var storeItemMock in storeItemMocks) { storeItemMock.VerifyDeleteOnce(); itemRepositoryMock.VerifyStoreAsyncOnce(storeItemMock.Object); IEnumerable <ShoppingListMock> affiliatedShoppingListMocks = shoppingLists[storeItemMock]; foreach (var listMock in affiliatedShoppingListMocks) { listMock.VerifyRemoveItemOnce(storeItemMock.Object.Id); shoppingListRepositoryMock.VerifyStoreAsyncOnce(listMock.Object); } } itemCategoryRepositoryMock.VerifyStoreAsyncOnce(itemCategoryMock.Object); transactionMock.VerifyCommitAsyncOnce(); } }
public static void SeedingsData(this AssignmentDbContext assignmentDbContext) { if (!assignmentDbContext.Customers.Any() || !assignmentDbContext.Transactions.Any()) { CustomerMock.MockCustomer(assignmentDbContext); TransactionMock.MockTransaction(assignmentDbContext); } }
public void Commit() { TransactionMock.Expect(mock => mock.Commit()); MockRepository.ReplayAll(); _strategy.Commit(); MockRepository.VerifyAll(); }
public void Rollback() { TransactionMock.Expect(mock => mock.Rollback()); MockRepository.ReplayAll(); _strategy.Rollback(); MockRepository.VerifyAll(); }
public async Task HandleAsync_WithValidActualId_ShouldRemoveItemFromBasket(bool isActualItemId, bool isTemporaryItem) { // Arrange var local = new LocalFixture(); var handler = local.CreateCommandHandler(); var command = isActualItemId ? local.CreateCommandWithActualId() : local.CreateCommandWithOfflineId(); ShoppingListMock listMock = local.ShoppingListMockFixture.Create(); var storeItem = local.StoreItemFixture.Create(StoreItemDefinition.FromTemporary(isTemporaryItem)); StoreItemMock itemMock = new StoreItemMock(storeItem); local.ShoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, listMock.Object); if (isActualItemId) { local.ItemRepositoryMock.SetupFindByAsync(new ItemId(command.OfflineTolerantItemId.ActualId.Value), itemMock.Object); } else { local.ItemRepositoryMock.SetupFindByAsync(new TemporaryItemId(command.OfflineTolerantItemId.OfflineId.Value), itemMock.Object); } TransactionMock transactionMock = new TransactionMock(); local.TransactionGeneratorMock.SetupGenerateAsync(transactionMock.Object); // Act bool result = await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { result.Should().BeTrue(); listMock.VerifyRemoveItemOnce(itemMock.Object.Id); local.TransactionGeneratorMock.VerifyGenerateAsyncOnce(); if (isTemporaryItem) { itemMock.VerifyDeleteOnce(); local.ItemRepositoryMock.VerifyStoreAsyncOnce(itemMock.Object); } else { itemMock.VerifyDeleteNever(); local.ItemRepositoryMock.VerifyStoreAsyncNever(); } local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(listMock.Object); transactionMock.VerifyCommitAsyncOnce(); } }
public void Test() { using (MockRepository.Ordered()) { TransactionMock.Expect(mock => mock.EnterScope()).Return(ScopeMock); ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionPlay(Context, ExecutionListenerStub)); } MockRepository.ReplayAll(); _strategy.OnExecutionPlay(Context, ExecutionListenerStub); MockRepository.VerifyAll(); Assert.That(_strategy.Scope, Is.SameAs(ScopeMock)); }
public void CreateChildTransactionStrategy_TwiceWithoutUnregister() { var childTransaction = MockRepository.GenerateStub <ITransaction>(); TransactionMock.Expect(mock => mock.CreateChild()).Return(childTransaction); var childExecutionContextStub = MockRepository.GenerateStub <IWxeFunctionExecutionContext>(); childExecutionContextStub.Stub(stub => stub.GetInParameters()).Return(new object[0]); MockRepository.ReplayAll(); _strategy.CreateChildTransactionStrategy(true, childExecutionContextStub, Context); _strategy.CreateChildTransactionStrategy(true, childExecutionContextStub, Context); }
public void Test_WithNullValue() { var object1 = new object(); var object2 = new object(); using (MockRepository.Ordered()) { ExecutionContextMock.Expect(mock => mock.GetInParameters()).Return(new[] { object1, null, object2 }); TransactionMock.Expect(mock => mock.EnsureCompatibility(Arg <IEnumerable> .List.ContainsAll(new[] { object1, object2 }))); } MockRepository.ReplayAll(); new RootTransactionStrategy(false, () => TransactionMock, NullTransactionStrategy.Null, ExecutionContextMock); MockRepository.VerifyAll(); }
public void Test() { InvokeOnExecutionPlay(_strategy); using (MockRepository.Ordered()) { ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionFail(Context, ExecutionListenerStub, _failException)); ScopeMock.Expect(mock => mock.Leave()); TransactionMock.Expect(mock => mock.Release()); } MockRepository.ReplayAll(); _strategy.OnExecutionFail(Context, ExecutionListenerStub, _failException); MockRepository.VerifyAll(); Assert.That(_strategy.Scope, Is.Null); }
public override void SetUp() { base.SetUp(); ExecutionContextMock.BackToRecord(); ExecutionContextMock.Stub(stub => stub.GetInParameters()).Return(new object[0]).Repeat.Any(); ExecutionContextMock.Replay(); TransactionMock.BackToRecord(); TransactionMock.Stub(stub => stub.EnsureCompatibility(Arg <IEnumerable> .Is.NotNull)); TransactionMock.Replay(); _strategy = MockRepository.PartialMock <ScopedTransactionStrategyBase> ( true, (Func <ITransaction>)(() => TransactionMock), OuterTransactionStrategyMock, ExecutionContextMock); _strategy.Replay(); ExecutionContextMock.BackToRecord(); TransactionMock.BackToRecord(); }
public async Task HandleAsync_WithSomeItemsOfItemCategoryOnNoActiveShoppingLists_ShouldStoreItemsButNoShoppingListsAndDeleteItemCategory() { // Arrange var fixture = commonFixture.GetNewFixture(); ItemCategoryRepositoryMock itemCategoryRepositoryMock = new ItemCategoryRepositoryMock(fixture); ItemRepositoryMock itemRepositoryMock = new ItemRepositoryMock(fixture); ShoppingListRepositoryMock shoppingListRepositoryMock = new ShoppingListRepositoryMock(fixture); TransactionGeneratorMock transactionGeneratorMock = new TransactionGeneratorMock(fixture); ItemCategoryMock itemCategoryMock = itemCategoryMockFixtur.Create(); List <StoreItemMock> storeItemMocks = storeItemMockFixture.CreateMany(3).ToList(); TransactionMock transactionMock = new TransactionMock(); var command = fixture.Create <DeleteItemCategoryCommand>(); var handler = fixture.Create <DeleteItemCategoryCommandHandler>(); itemCategoryRepositoryMock.SetupFindByAsync(command.ItemCategoryId, itemCategoryMock.Object); itemRepositoryMock.SetupFindActiveByAsync(command.ItemCategoryId, storeItemMocks.Select(m => m.Object)); shoppingListRepositoryMock.SetupFindActiveByAsync(Enumerable.Empty <IShoppingList>()); transactionGeneratorMock.SetupGenerateAsync(transactionMock.Object); // Act var result = await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { result.Should().BeTrue(); itemCategoryMock.VerifyDeleteOnce(); shoppingListRepositoryMock.VerifyStoreAsyncNever(); foreach (var storeItemMock in storeItemMocks) { storeItemMock.VerifyDeleteOnce(); itemRepositoryMock.VerifyStoreAsyncOnce(storeItemMock.Object); } itemCategoryRepositoryMock.VerifyStoreAsyncOnce(itemCategoryMock.Object); transactionMock.VerifyCommitAsyncOnce(); } }
public void Test_EnterScopeThrows() { var innerException = new Exception("Enter Scope Exception"); TransactionMock.Expect(mock => mock.EnterScope()).Throw(innerException); MockRepository.ReplayAll(); try { _strategy.OnExecutionPlay(Context, ExecutionListenerStub); Assert.Fail("Expected Exception"); } catch (WxeFatalExecutionException actualException) { Assert.That(actualException.InnerException, Is.SameAs(innerException)); } Assert.That(_strategy.Scope, Is.Null); }
public void Test_WithIncompatibleInParameters() { var object1 = new object(); var invalidOperationException = new InvalidOperationException("Objects no good!"); ExecutionContextMock.Stub(mock => mock.GetInParameters()).Return(new[] { object1 }); TransactionMock .Stub(mock => mock.EnsureCompatibility(Arg <IEnumerable> .List.ContainsAll(new[] { object1 }))) .Throw(invalidOperationException); MockRepository.ReplayAll(); Assert.That( () => new RootTransactionStrategy(false, () => TransactionMock, NullTransactionStrategy.Null, ExecutionContextMock), Throws .TypeOf <WxeException>() .With.Message.EqualTo( "One or more of the input parameters passed to the WxeFunction are incompatible with the function's transaction. Objects no good!") .And.InnerException.SameAs(invalidOperationException)); }
public async Task HandleAsync_WithItemOnShoppingLists_ShouldDeleteItemAndRemoveItFromActiveShoppingLists( List <ShoppingListMock> shoppingListMocks) { // Arrange var local = new LocalFixture(); var handler = local.CreateCommandHandler(); var command = local.CreateCommand(); TransactionMock transactionMock = new TransactionMock(); StoreItemMock storeItemMock = local.StoreItemMockFixture.Create(); local.ItemRepositoryMock.SetupFindByAsync(command.ItemId, storeItemMock.Object); local.ShoppingListRepositoryMock.SetupFindActiveByAsync(storeItemMock.Object.Id, shoppingListMocks.Select(m => m.Object)); local.TransactionGeneratorMock.SetupGenerateAsync(transactionMock.Object); // Act var result = await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { result.Should().BeTrue(); storeItemMock.VerifyDeleteOnce(); local.ItemRepositoryMock.VerifyStoreAsyncOnce(storeItemMock.Object); if (!shoppingListMocks.Any()) { local.ShoppingListRepositoryMock.VerifyStoreAsyncNever(); } else { foreach (var shoppingListMock in shoppingListMocks) { shoppingListMock.VerifyRemoveItemOnce(storeItemMock.Object.Id); local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(shoppingListMock.Object); } } transactionMock.VerifyCommitAsyncOnce(); } }
public void Test_WithoutAutoCommit() { var strategy = CreateScopedTransactionStrategy(false, NullTransactionStrategy.Null); InvokeOnExecutionPlay(strategy); using (MockRepository.Ordered()) { ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionStop(Context, ExecutionListenerStub)); ExecutionContextMock.Expect(mock => mock.GetOutParameters()).Return(new object[0]); ScopeMock.Expect(mock => mock.Leave()); TransactionMock.Expect(mock => mock.Release()); } MockRepository.ReplayAll(); strategy.OnExecutionStop(Context, ExecutionListenerStub); MockRepository.VerifyAll(); Assert.That(strategy.Scope, Is.Null); }
public async Task HandleAsync_WithNoItemsOfItemCategory_ShouldNotStoreAnyItemsAndDeleteItemCategory() { // Arrange var fixture = commonFixture.GetNewFixture(); ItemCategoryRepositoryMock itemCategoryRepositoryMock = new ItemCategoryRepositoryMock(fixture); ItemRepositoryMock itemRepositoryMock = new ItemRepositoryMock(fixture); ShoppingListRepositoryMock shoppingListRepositoryMock = new ShoppingListRepositoryMock(fixture); TransactionGeneratorMock transactionGeneratorMock = new TransactionGeneratorMock(fixture); ItemCategoryMock itemCategoryMock = itemCategoryMockFixtur.Create(); TransactionMock transactionMock = new TransactionMock(); var command = fixture.Create <DeleteItemCategoryCommand>(); var handler = fixture.Create <DeleteItemCategoryCommandHandler>(); itemCategoryRepositoryMock.SetupFindByAsync(command.ItemCategoryId, itemCategoryMock.Object); itemRepositoryMock.SetupFindActiveByAsync(command.ItemCategoryId, Enumerable.Empty <IStoreItem>()); transactionGeneratorMock.SetupGenerateAsync(transactionMock.Object); // Act var result = await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { result.Should().BeTrue(); itemCategoryMock.VerifyDeleteOnce(); shoppingListRepositoryMock.VerifyStoreAsyncNever(); itemRepositoryMock.VerifyStoreAsyncNever(); itemCategoryRepositoryMock.VerifyStoreAsyncOnce(itemCategoryMock.Object); transactionMock.VerifyCommitAsyncOnce(); } }
public void Test_CommitThrows() { var strategy = CreateScopedTransactionStrategy(true, NullTransactionStrategy.Null); var innerException = new ApplicationException("Commit Exception"); InvokeOnExecutionPlay(strategy); ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionStop(Context, ExecutionListenerStub)); TransactionMock.Expect(mock => mock.Commit()).Throw(innerException); MockRepository.ReplayAll(); try { strategy.OnExecutionStop(Context, ExecutionListenerStub); Assert.Fail("Expected Exception"); } catch (ApplicationException actualException) { Assert.That(actualException, Is.SameAs(innerException)); } MockRepository.VerifyAll(); Assert.That(strategy.Scope, Is.SameAs(ScopeMock)); }
public void GetTransaction() { TransactionMock.Expect(mock => mock.To <ITransaction>()).Return(TransactionMock); TransactionMock.Replay(); Assert.That(_strategy.GetNativeTransaction <ITransaction>(), Is.SameAs(TransactionMock)); }