public async Task HandleAsync_WithValidDataAndManufacturerId_ShouldMakeTemporaryItemPermanent() { // Arrange var local = new LocalFixture(); var handler = local.CreateCommandHandler(); StoreItemMock storeItemMock = local.StoreItemMockFixture.Create(StoreItemDefinition.FromTemporary(true)); List <IStoreItemAvailability> availabilities = storeItemMock.Object.Availabilities.ToList(); var command = local.CreateCommand(availabilities); local.ItemRepositoryMock.SetupFindByAsync(command.PermanentItem.Id, storeItemMock.Object); // Act var result = await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { result.Should().BeTrue(); local.ItemCategoryValidationServiceMock.VerifyValidateAsyncOnce(command.PermanentItem.ItemCategoryId); local.ManufacturerValidationServiceMock.VerifyValidateAsyncOnce(command.PermanentItem.ManufacturerId); local.AvailabilityValidationServiceMock.VerifyValidateOnce(availabilities); storeItemMock.VerifyMakePermanentOnce(command.PermanentItem, availabilities); local.ItemRepositoryMock.VerifyStoreAsyncOnce(storeItemMock.Object); } }
public async Task HandleAsync_WithActualId_ShouldAddItemToList() { // Arrange var local = new LocalFixture(); var handler = local.CreateCommandHandler(); var command = local.CreateCommandWithActualId(); ShoppingListMock listMock = local.ShoppingListMockFixture.Create(); local.ShoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, listMock.Object); // Act bool result = await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { result.Should().BeTrue(); local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(listMock.Object); local.AddItemToShoppingListServiceMock.VerifyAddItemToShoppingListOnce( listMock.Object, new ItemId(command.ItemId.ActualId.Value), command.SectionId, command.Quantity); } }
public async Task ConvertAsync_WithItemCategoryAndManufacturer_ShouldConvertToReadModel() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var item = local.CreateItem(); var availability = item.Availabilities.First(); var itemCategory = local.CreateItemCategory(item.ItemCategoryId); var manufacturer = local.CreateManufacturer(item.ManufacturerId); var store = local.CreateStore(availability.StoreId, availability.DefaultSectionId); local.ItemCategoryRepositoryMock.SetupFindByAsync(item.ItemCategoryId, itemCategory); local.ManufacturerRepositoryMock.SetupFindByAsync(item.ManufacturerId, manufacturer); local.StoreRepositoryMock.SetupFindByAsync(availability.StoreId.ToMonoList(), store.ToMonoList()); // Act var result = await service.ConvertAsync(item, default); // Assert var expected = local.ToSimpleReadModel(item, itemCategory, manufacturer, store); using (new AssertionScope()) { result.Should().BeEquivalentTo(expected); } }
public async Task HandleAsync_WithValidData_ShouldStoreItem() { // Arrange var local = new LocalFixture(); var handler = local.CreateCommandHandler(); IStoreItem storeItem = local.StoreItemFixture.CreateValid(); IStoreItemAvailability availability = local.CommonFixture.ChooseRandom(storeItem.Availabilities); var command = local.CreateCommand(availability); local.StoreItemFactoryMock.SetupCreate(command.TemporaryItemCreation, storeItem); // Act var result = await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { result.Should().BeTrue(); local.AvailabilityValidationServiceMock.VerifyValidateOnce( command.TemporaryItemCreation.Availability.ToMonoList()); local.ItemRepositoryMock.VerifyStoreAsyncOnce(storeItem); } }
public async Task ConvertAsync_WithItemCategoryAndNoManufacturer_ShouldConvertToReadModel() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var store = local.CreateStore(); var items = local.CreateItemsWithoutManufacturer(store).ToList(); var itemCategoryIds = items .Where(i => i.ItemCategoryId != null) .Select(i => i.ItemCategoryId); var manufacturerIds = items .Where(i => i.ManufacturerId != null) .Select(i => i.ManufacturerId); var itemCategoryDict = local.CreateItemCategories(itemCategoryIds); var manufacturerDict = local.CreateManufacturers(manufacturerIds); local.ItemCategoryRepositoryMock.SetupFindByAsync(itemCategoryIds, itemCategoryDict.Values); local.ManufacturerRepositoryMock.SetupFindByAsync(manufacturerIds, manufacturerDict.Values); // Act var result = await service.ConvertAsync(items, store, default); // Assert var expected = local.ToSimpleReadModels(items, store, itemCategoryDict, manufacturerDict); using (new AssertionScope()) { result.Should().BeEquivalentTo(expected); } }
public async Task ExchangeItemAsync_WithNewItemAvailableForShoppingListAndNotInBasket_ShouldRemoveOldItemAndAddNewItem() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); ShoppingListMock shoppingListMock = local.CreateShoppingListMockNotInBasket(); var shopppingListStoreId = shoppingListMock.Object.StoreId; IShoppingListItem oldShoppingListItem = shoppingListMock.GetRandomItem(local.CommonFixture, i => !i.IsInBasket); ItemId oldItemId = oldShoppingListItem.Id; IStoreItem newItem = local.CreateNewItemForStore(shopppingListStoreId); local.ShoppingListRepositoryMock.SetupFindActiveByAsync(oldItemId, shoppingListMock.Object.ToMonoList()); // Act await service.ExchangeItemAsync(oldItemId, newItem, default); // Assert var sectionId = newItem.Availabilities.First(av => av.StoreId == shopppingListStoreId).DefaultSectionId; using (new AssertionScope()) { shoppingListMock.VerifyRemoveItemOnce(oldItemId); local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(shoppingListMock.Object); local.AddItemToShoppingListServiceMock.VerifyAddItemToShoppingListOnce(shoppingListMock.Object, newItem.Id, sectionId, oldShoppingListItem.Quantity); shoppingListMock.VerifyPutItemInBasketNever(); } }
public async Task ConvertAsync_WithInvalidManufacturer_ShouldConvertToReadModel() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var item = local.CreateItem(); var availability = item.Availabilities.First(); var itemCategory = local.CreateItemCategory(item.ItemCategoryId); var store = local.CreateStore(availability.StoreId, availability.DefaultSectionId); local.ItemCategoryRepositoryMock.SetupFindByAsync(item.ItemCategoryId, itemCategory); local.ManufacturerRepositoryMock.SetupFindByAsync(item.ManufacturerId, null); local.StoreRepositoryMock.SetupFindByAsync(availability.StoreId.ToMonoList(), store.ToMonoList()); // Act Func <Task <StoreItemReadModel> > function = async() => await service.ConvertAsync(item, default); // Assert using (new AssertionScope()) { (await function.Should().ThrowAsync <DomainException>()) .Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.ManufacturerNotFound); } }
public async Task HandleAsync_WithValidDataAndManufacturerIdNull_ShouldCreateItem() { // Arrange var local = new LocalFixture(); IStoreItem storeItem = local.StoreItemFixture.CreateValid(); List <IStoreItemAvailability> availabilities = storeItem.Availabilities.ToList(); var handler = local.CreateCommandHandler(); var command = local.CreateCommandWithoutManufacturerId(availabilities); local.StoreItemFactoryMock.SetupCreate(command.ItemCreation, storeItem); // Act var result = await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { result.Should().BeTrue(); local.ItemRepositoryMock.VerifyStoreAsyncOnce(storeItem); local.ItemCategoryValidationServiceMock.VerifyValidateAsyncOnce(command.ItemCreation.ItemCategoryId); local.ManufacturerValidationServiceMock.VerifyValidateAsyncNever(); local.AvailabilityValidationServiceMock.VerifyValidateOnce(availabilities); } }
public async Task HandleAsync_WithValidOfflineId_ShouldPutItemInBasket() { // Arrange var local = new LocalFixture(); var handler = local.CreateCommandHandler(); var command = local.CreateCommandWithOfflineId(); IStoreItem storeItem = local.StoreItemFixture.CreateValid(); var temporaryItemId = new TemporaryItemId(command.OfflineTolerantItemId.OfflineId.Value); ShoppingListMock listMock = local.ShoppingListMockFixture.Create(); local.ShoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, listMock.Object); local.ItemRepositoryMock.SetupFindByAsync(temporaryItemId, storeItem); // Act bool result = await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { result.Should().BeTrue(); local.ItemRepositoryMock.VerifyFindByAsync(temporaryItemId); listMock.VerifyPutItemInBasketOnce(storeItem.Id); local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(listMock.Object); } }
private static void AddFixture(string fixtureFullName, string fixtureName) { LocalFixture lf = new LocalFixture(LocalCollection.CurrentLocalAssembly, fixtureName, fixtureFullName); if (!LocalCollection.CurrentLocalAssembly.LocalFixtures.Contains(lf)) { LocalCollection.CurrentLocalAssembly.LocalFixtures.Add(lf); } LocalCollection.CurrentLocalAssembly.CurrentLocalFixture = (from x in LocalCollection.CurrentLocalAssembly.LocalFixtures where x.Equals(lf) select x).First(); }
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 async Task AddItemToShoppingList_WithItemIdIsNull_ShouldThrowArgumentNullException() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var shoppingList = local.ShoppingListFixture.AsModelFixture().CreateValid(); var sectionId = new SectionId(local.CommonFixture.NextInt()); var quantity = local.CommonFixture.NextFloat(); // Act Func <Task> function = async() => await service.AddItemToShoppingList(shoppingList, (ItemId)null, sectionId, quantity, default);
public async Task ValidateAsync_WithAvailabilitiesIsNull_ShouldThrowArgumentNullException() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); // Act Func <Task> function = async() => await service.ValidateAsync(null, default); // Assert using (new AssertionScope()) { await function.Should().ThrowAsync <ArgumentNullException>(); } }
public async Task HandleAsync_WithCommandIsNull_ShouldThrowArgumentNullException() { // Arrange var local = new LocalFixture(); var handler = local.CreateCommandHandler(); // Act Func <Task> function = async() => await handler.HandleAsync(null, default); // Assert using (new AssertionScope()) { await function.Should().ThrowAsync <ArgumentNullException>(); } }
public async Task ConvertAsync_WithItemIsNull_ShouldThrowArgumentNullException() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); // Act Func <Task <StoreItemReadModel> > function = async() => await service.ConvertAsync(null, default); // Assert using (new AssertionScope()) { await function.Should().ThrowAsync <ArgumentNullException>(); } }
public async Task ExchangeItemAsync_WithOldItemIdIsNull_ShouldThrowArgumentNullException() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var oldItemId = local.CreateOldItemId(); // Act Func <Task> function = async() => await service.ExchangeItemAsync(oldItemId, null, default); // Assert using (new AssertionScope()) { await function.Should().ThrowAsync <ArgumentNullException>(); } }
public async Task ValidateAsync_WithDuplicatedStoreIds_ShouldThrowDomainException() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var availabilities = local.CreateAvailabilitiesWithDuplicatedStoreIds(); // Act Func <Task> function = async() => await service.ValidateAsync(availabilities, default); // Assert using (new AssertionScope()) { (await function.Should().ThrowAsync <DomainException>()) .Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.MultipleAvailabilitiesForStore); } }
public async Task HandleAsync_WithInvalidItemId_ShouldThrowDomainException() { // Arrange var local = new LocalFixture(); var handler = local.CreateCommandHandler(); var command = local.CreateCommand(); local.ItemRepositoryMock.SetupFindByAsync(command.PermanentItem.Id, null); // Act Func <Task <bool> > action = async() => await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { (await action.Should().ThrowAsync <DomainException>()) .Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.ItemNotFound); } }
public async Task Change_Customer_Maximum_Length_Name_Should_Be_Ok() { // Setup LocalFixture.Seed(this.GetContext); // Arrange using var context = this.GetContext(); var handler = new ChangeCustomerNameCommandHandler(context); var command = new ChangeCustomerNameCommand( new Guid("8e61088d-776d-4c0f-a458-50dccf4e6580"), "Mauricio A" ); // Act var actual = await handler.Handle(command, CancellationToken.None); // Assert Assert.True(actual.IsSuccess); }
public async Task ValidateAsync_WithValidItemCategoryId_ShouldNotThrow() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var itemCategory = local.CreateItemCategory(); local.ItemCategoryRepositoryMock.SetupFindByAsync(itemCategory.Id, itemCategory); // Act Func <Task> function = async() => await service.ValidateAsync(itemCategory.Id, default); // Assert using (new AssertionScope()) { await function.Should().NotThrowAsync(); } }
public async Task ValidateAsync_WithValidManufacturerId_ShouldNotThrow() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var manufacturer = local.CreateManufacturer(); local.ManufacturerRepositoryMock.SetupFindByAsync(manufacturer.Id, manufacturer); // Act Func <Task> function = async() => await service.ValidateAsync(manufacturer.Id, default); // Assert using (new AssertionScope()) { await function.Should().NotThrowAsync(); } }
public async Task AddItemToShoppingList_WithItemIdAndShoppingListIsNull_ShouldThrowArgumentNullException() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var itemId = new ItemId(local.CommonFixture.NextInt()); var sectionId = new SectionId(local.CommonFixture.NextInt()); var quantity = local.CommonFixture.NextFloat(); // Act Func <Task> function = async() => await service.AddItemToShoppingList(null, itemId, sectionId, quantity, default); // Assert using (new AssertionScope()) { await function.Should().ThrowAsync <ArgumentNullException>(); } }
public async Task HandleAsync_WithInvalidShoppingListId_ShouldThrowDomainException() { // Arrange var local = new LocalFixture(); var handler = local.CreateCommandHandler(); var command = local.CreateCommandWithOfflineId(); local.ShoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, null); // Act Func <Task> function = async() => await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { (await function.Should().ThrowAsync <DomainException>()) .Where(e => e.Reason.ErrorCode == ErrorReasonCode.ShoppingListNotFound); } }
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 async Task ValidateAsync_WithInvalidItemCategoryId_ShouldThrowDomainException() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var itemCategoryId = new ItemCategoryId(local.CommonFixture.NextInt()); local.ItemCategoryRepositoryMock.SetupFindByAsync(itemCategoryId, null); // Act Func <Task> function = async() => await service.ValidateAsync(itemCategoryId, default); // Assert using (new AssertionScope()) { (await function.Should().ThrowAsync <DomainException>()) .Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.ItemCategoryNotFound); } }
public async Task ExchangeItemAsync_WithOldItemOnNoShoppingLists_ShouldDoNothing() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); ItemId oldItemId = local.CreateOldItemId(); IStoreItem newItem = local.CreateNewItem(); local.ShoppingListRepositoryMock.SetupFindActiveByAsync(oldItemId, Enumerable.Empty <IShoppingList>()); // Act await service.ExchangeItemAsync(oldItemId, newItem, default); // Assert using (new AssertionScope()) { local.ShoppingListRepositoryMock.VerifyStoreAsyncNever(); } }
public async Task ValidateAsync_WithInvalidStoreId_ShouldThrowDomainException() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var availabilities = local.CreateValidAvailabilities(); var storeIds = availabilities.Select(av => av.StoreId); local.StoreRepositoryMock.SetupFindByAsync(storeIds, Enumerable.Empty <IStore>()); // Act Func <Task> function = async() => await service.ValidateAsync(availabilities, default); // Assert using (new AssertionScope()) { (await function.Should().ThrowAsync <DomainException>()) .Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.StoreNotFound); } }
public async Task ValidateAsync_WithValidData_ShouldNotThrow() { // Arrange var local = new LocalFixture(); var service = local.CreateService(); var availabilities = local.CreateValidAvailabilities().ToList(); var storeIds = availabilities.Select(av => av.StoreId); var stores = local.CreateValidStores(availabilities); local.StoreRepositoryMock.SetupFindByAsync(storeIds, stores); // Act Func <Task> function = async() => await service.ValidateAsync(availabilities, default); // Assert using (new AssertionScope()) { await function.Should().NotThrowAsync(); } }
public async Task HandleAsync_WithNonTemporaryItem_ShouldThrowDomainException() { // Arrange var local = new LocalFixture(); var handler = local.CreateCommandHandler(); var command = local.CreateCommand(); var baseDefinition = StoreItemDefinition.FromTemporary(false); IStoreItem storeItem = local.StoreItemFixture.CreateValid(baseDefinition); local.ItemRepositoryMock.SetupFindByAsync(command.PermanentItem.Id, storeItem); // Act Func <Task <bool> > action = async() => await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { (await action.Should().ThrowAsync <DomainException>()) .Where(ex => ex.Reason.ErrorCode == ErrorReasonCode.ItemNotTemporary); } }
public async Task HandleAsync_WithActualId_ShouldRemoveItemFromBasket() { // Arrange var local = new LocalFixture(); var handler = local.CreateCommandHandler(); var command = local.CreateCommandWithActualId(); ShoppingListMock shoppingListMock = local.ShoppingListMockFixture.Create(); local.ShoppingListRepositoryMock.SetupFindByAsync(command.ShoppingListId, shoppingListMock.Object); // Act bool result = await handler.HandleAsync(command, default); // Assert using (new AssertionScope()) { result.Should().BeTrue(); shoppingListMock.VerifyRemoveItemFromBasketOnce(new ItemId(command.OfflineTolerantItemId.ActualId.Value)); local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(shoppingListMock.Object); } }