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