private static void SeedDb(IHost host)
{
using var scope = host.Services.CreateScope();
var service = scope.ServiceProvider;
var productContext = service.GetRequiredService <ProductContext>();
ProductSeed.SeedAsync(productContext);
}
private Payload ToPayload(ProductSeed seed)
{
return new Payload {
{"name", seed.Name},
{"description", seed.Notes},
{"ref", seed.Reference}
};
}
public void Given_existing_tax_When_create_product_tax_from_tax_Then_add_product_tax_to_caller_product()
{
// Given
var product = new ProductSeed().GetSeedObject();
var tax = new Tax("FAKE 12%", 0.12m);
// When
product.AddTax(tax);
// Then
Assert.NotEmpty(product.ProductTaxes);
}
public ProductsController(ProductContext context, ILogger <ProductsController> logger)
{
_context = context;
_logger = logger;
if (_context.Products.Any())
{
return;
}
ProductSeed.InitData(context);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Store>().HasOne(x => x.Address).WithOne(x => x !.Store !).HasForeignKey <Address>(x => x.StoreId);
modelBuilder.Entity <Country>().HasData(CountrySeed.Get());
modelBuilder.Entity <Company>().HasData(CompanySeed.Get());
modelBuilder.Entity <Address>().HasData(AddressSeed.Get());
modelBuilder.Entity <Store>().HasData(StoreSeed.Get());
modelBuilder.Entity <Product>().HasData(ProductSeed.Get());
}
private POSOrder GetBasicPOSOrder()
{
var product = new ProductSeed().GetSeedObject();
product.Id = 1;
product.UpdateStock(10, product);
var repository = MockRepository((mock) => mock.Setup(m => m.GetBy(It.IsAny <int>()))
.Returns(product));
var posOrder = new POSOrder();
posOrder.AddItem(product.Id, 1, repository);
return(posOrder);
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var context = services.GetRequiredService <ProductManagementContext>();
ProductSeed.Initialize(services);
}
host.Run();
}
protected override void Seed(TestDbContext context)
{
base.Seed(context);
var companies = CompanySeed.Get();
context.Addresses.AddRange(AddressSeed.Get());
context.Countries.AddRange(CountrySeed.Get());
context.Companies.AddRange(CompanySeed.Get());
context.Products.AddRange(ProductSeed.Get());
context.Stores.AddRange(StoreSeed.Get());
context.SaveChanges();
}
public Product Create(ProductSeed seed, params Design[] designs)
{
Validate(seed);
Validate(designs);
var uri = Map("/products");
using (var response = MultipartPost(uri, ToPayload(seed, designs))) {
if (response.StatusCode == HttpStatusCode.OK)
return Deserialize(response);
throw Error("Failed to create product", response);
}
}
public Product Update(String productKey, ProductSeed seed)
{
Validate(seed);
var payload = ToPayload(seed);
var uri = Map("/products/{0}/update", productKey);
using (var response = Post(uri, payload)) {
if (response.StatusCode == HttpStatusCode.OK)
return Deserialize(response);
throw Error("Failed to update product", response);
}
}
public void If_Product_is_out_of_stock_don_t_create_item()
{
//Given
var posOrder = new POSOrder();
var product = new ProductSeed().GetSeedObject();
product.Id = 1;
product.UpdateStock(-product.QuantityInStock, product);
// When
var posOrderItemResult = POSOrderItem.Create(product.Id, 1, posOrder, MockRepository());
// Then
Assert.False(posOrderItemResult.Success);
Assert.Null(posOrderItemResult.Value);
}
public void Given_Update_Price_Object_When_Calling_UpdatePrice_Method_On_Instance_Of_Product_And_Pass_UpdatePrice_Object_Then_Add_Object_Collection_And_Update_Internal_Fields()
{
//Given
var product = new ProductSeed().GetSeedObject();
var productPrice = ProductPrice.CreateNewPrice(product, costPrice: 12.99m, endCustomerDrugPrice: 15.99m, DateTimeOffset.UtcNow);
//When
product.SetNewPrice(productPrice);
var newPrice = product.ProductPrices.Where(p => p == productPrice).FirstOrDefault();
//Then
Assert.Equal(12.99m, newPrice.CostPrice);
Assert.Equal(15.99m, newPrice.EndCustomerDrugPrice);
Assert.Equal(productPrice, newPrice);
}
public void Given_decimal_values_for_cost_price_and_customer_price_When_call_UpdatePrice_with_theses_decimal_values_as_argument_Then_add_new_ProductPrice_object_to_entity_with_given_values()
{
//Given
decimal costPrice = 12.99m;
decimal endCustomerPrice = 15.99m;
var product = new ProductSeed().GetSeedObject();
//When
product.UpdatePrice(endCustomerPrice, costPrice, DateTimeOffset.UtcNow);
//Then
var newPrice = product.ProductPrices.LastOrDefault();
Assert.Equal(12.99m, newPrice.CostPrice);
Assert.Equal(15.99m, newPrice.EndCustomerDrugPrice);
}
public override async Task POST_Create_ReceivesEntityObject_ExpectedToReturnCreatedEntity()
{
// Arrange
var stockEntrySeed = _seeder.GetSeedObject();
var drugSeed = new ProductSeed().GetSeedObject();
var url = GetRequestUrl("api/{0}/create?api-version=1.0", "POST");
stockEntrySeed.AddEntry(drugSeed, DateTime.UtcNow.AddDays(-365), 4, Guid.NewGuid().ToString());
// Act
var response = await _client.PostAsJsonAsync(url, stockEntrySeed);
var content = await response.Content.ReadAsStringAsync();
// Assert
Assert.True(response.IsSuccessStatusCode, content);
}
public virtual async Task AddProductStockEntryWithAfterCreation()
{
// Arrange
var stockEntry = _seeder.GetSeedObject();
var product = new ProductSeed().GetSeedObject();
_context.AddRange(stockEntry, product);
_context.SaveChanges();
// Act
stockEntry.AddEntry(product, null, 1, "LOT23CO4E");
_repository.Update(stockEntry);
var result = await _repository.SaveChangesAsync();
// Then
var stockEntryOnProduct = product.Stockentries.Where(p => p.ProductId == product.Id).FirstOrDefault();
Assert.Equal(stockEntryOnProduct.Id, stockEntry.Id);
}
private Payload ToPayload(ProductSeed seed, params Design[] designs)
{
var payload = new Payload {
{ "name", seed.Name},
{ "notes", seed.Notes},
{ "ref", seed.Reference}
};
foreach (var design in designs) {
payload.AddRange(ToFields(design));
payload.Add(
"designs[][uploaded_data]",
new DataItem(new FileInfo(design.Filename), "xxx")
);
}
return payload;
}
public void Given_category_and_product_When_add_product_to_category_Then_category_should_be_present_in_product_category_collection()
{
// Given
var product = new ProductSeed().GetSeedObject();
product.Id = 1;
var category = new Category()
{
Name = "Cosmetics"
};
category.Id = 1;
// When
product.AddToCategory(category);
// Then
Assert.NotEmpty(product.Categories);
}
public void Given_New_StockEntry_With_Drugs_With_DrugCostChanged_Between_Last_StockEntry_Of_Each_Product_When_Get_Diff_Between_Current_Products_And_StockEntry_Product_Then_Return_List_With_Previous_And_New_Product_Object()
{
//Given
var oldProduct = ProductSeed.BaseCreateProductEntity();
var newProduct = ProductSeed.BaseCreateProductEntity();
oldProduct.Ncm = "300024567";
newProduct.Ncm = oldProduct.Ncm;
newProduct.UpdatePrice(oldProduct.EndCustomerPrice + 1.0m, newProduct.CostPrice + 0.01m, DateTimeOffset.UtcNow);
var service = new StockService(new FakeRepository <StockEntry>(),
new ProductService(new FakeRepository <Product>(new Product[] { oldProduct })));
//When
var result = service.GetItemsWithPriceChanged(new List <Product> {
newProduct
});
//Then
Assert.Single(result);
}
public void When_add_new_item_of_already_present_product_sum_items()
{
// Given
var product = new ProductSeed().GetSeedObject();
product.Id = 1;
product.UpdateStock(14, product);
var posOrder = new POSOrder();
var repository = MockRepository((mock) => mock.Setup(m => m.GetBy(It.IsAny <int>()))
.Returns(product));
posOrder.AddItem(product.Id, 2, repository);
var expectedOrderTotal = product.EndCustomerPrice * 6;
// When
posOrder.AddItem(product.Id, 4, repository);
// Then
Assert.Equal(1, posOrder.Items.Count);
Assert.Equal(expectedOrderTotal, posOrder.OrderTotal);
}
public async Task GET_GetDrugsByName_StateUnderTest_ExpectedBehavior()
{
// Arrange
var baseUrl = "api/product/search/list?name={0}&api-version=1.0";
var drug = new ProductSeed().GetSeedObject();
var context = _fixture.GetContext();
context.Add(drug);
context.SaveChanges();
string requestUrl = string.Format(baseUrl, drug.Name);
// Act
var result = await _client.GetAsync(requestUrl);
result.EnsureSuccessStatusCode();
var response = await result.Content.ReadAsJsonAsync <BaseResourceResponse <IList <ProductDto> > >();
// Assert
Assert.True(response.Success);
Assert.True(response.ResultObject.Any());
}
public void Given_negative_stock_change_When_try_update_stock_quantity_with_change_bigger_than_existing_quantity_Then_exception_is_throwed()
{
// Given
var product = new ProductSeed().GetSeedObject();
product.Id = 1;
product.UpdateStock(StockChange.CreateChange(quantity: 0, product, new StockEntry {
Id = 1
}));
var posOrder = new POSOrder
{
Id = 1
};
int quantity = -2;
var stockChange = StockChange.CreateChange(quantity, product, posOrder);
// When..., then
Assert.Throws <ArgumentException>(() => product.UpdateStock(stockChange));
}
public virtual async Task AddProductStockEntryWithAfterCreation()
{
// Arrange
var stockEntry = _seeder.GetSeedObject();
var product = new ProductSeed().GetSeedObject();
_context.AddRange(stockEntry, product);
_context.SaveChanges();
// Act
var lotCode = String.Format("LOT23CO4E-{0}", Guid.NewGuid().ToString());
stockEntry.AddEntry(product, null, 1, lotCode);
_repository.Update(stockEntry);
var result = await _repository.SaveChangesAsync();
// Then
var stockEntryOnProduct = product.Stockentries.Where(p => p.StockEntryId == stockEntry.Id).FirstOrDefault();
Assert.Equal(stockEntryOnProduct.StockEntryId, stockEntry.Id);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
User[] users = UserSeed.CreateUsers();
Restaurant[] restaurants = RestaurantSeed.CreateRestaurants();
Product[] products = ProductSeed.CreateProducts(restaurants);
Booking[] bookings = BookingSeed.CreateBookings(users, restaurants, products);
modelBuilder.Entity <Restaurant>().HasMany(r => r.Products).WithOne(p => p.Restaurant);
modelBuilder.Entity <Product>().HasOne(p => p.Restaurant).WithMany(r => r.Products);
modelBuilder.Entity <User>().HasMany(u => u.Bookings).WithOne(b => b.User);
modelBuilder.Entity <Booking>().HasOne(b => b.User).WithMany(u => u.Bookings);
modelBuilder.Entity <Booking>().HasMany(b => b.Products);
modelBuilder.Entity <Product>().HasMany(b => b.Bookings);
modelBuilder.Entity <User>().HasData(users);
modelBuilder.Entity <Restaurant>().HasData(restaurants);
modelBuilder.Entity <Product>().HasData(products);
modelBuilder.Entity <Booking>().HasData(bookings);
}
public void If_quantity_is_bigger_than_product_stock_use_remaining_stock()
{
//Given
var posOrder = new POSOrder();
var product = new ProductSeed().GetSeedObject();
product.Id = 1;
product.UpdateStock(StockChange.CreateChange(5, product, product));
product.UpdateStock(StockChange.CreateChange(-2, product, product));
var quantity = 4;
var repository = MockRepository((mock) => {
mock.Setup(m => m.GetBy(It.IsAny <int>()))
.Returns(product);
});
//When
var posOrderItemResult = POSOrderItem.Create(product.Id, quantity, posOrder, repository);
//Then
Assert.NotEqual(posOrderItemResult.Value.Quantity, quantity);
Assert.Equal(posOrderItemResult.Value.Quantity, product.QuantityInStock);
}
public async Task GET_GetDrugByBarCode_StateUnderTest_ExpectedBehavior()
{
// Arrange
string baseUrl = "api/product/search/{0}?api-version=1.0";
var Product = new ProductSeed().GetSeedObject();
var context = _fixture.GetContext();
context.Add(Product);
context.SaveChanges();
string requestUrl = string.Format(baseUrl, Product.BarCode);
// Act
//var result = drugsController.GetDrugByBarCode(barCode);
var result = await _client.GetAsync(requestUrl);
result.EnsureSuccessStatusCode();
var valueResult = await result.Content.ReadAsJsonAsync <BaseResourceResponse <ProductDto> >();
// Assert
Assert.NotNull(valueResult);
Assert.Equal(Product.BarCode, valueResult.ResultObject.BarCode);
}
public void Given_negative_stock_change_When_try_update_stock_quantity_of_a_product_Then_current_stock_quantity_should_be_actual_stock_quantity_minus_stock_change()
{
// Given
var product = new ProductSeed().GetSeedObject();
product.Id = 1;
product.UpdateStock(StockChange.CreateChange(4, product, new StockEntry {
Id = 1
}));
var posOrder = new POSOrder
{
Id = 1
};
int quantity = -2;
int expectedQuantity = 2;
var stockChange = StockChange.CreateChange(quantity, product, posOrder);
// When
product.UpdateStock(stockChange);
// Then
Assert.Equal(expectedQuantity, product.QuantityInStock);
}
public void Create_Item_from_product_id_and_quantity()
{
//Given
var posOrder = new POSOrder();
var product = new ProductSeed().GetSeedObject();
product.Id = 1;
product.UpdateStock(4, product);
var quantity = 4;
var expectedOrderTotal = product.EndCustomerPrice * quantity;
var repository = MockRepository((mock) => {
mock.Setup(m => m.GetBy(It.IsAny <int>()))
.Returns(product);
});
//When
var item = POSOrderItem.Create(product.Id, quantity, posOrder, repository);
//Then
Assert.True(item.Success);
Assert.NotNull(item.Value);
Assert.Equal(expectedOrderTotal, item.Value.Total);
Assert.Equal(item.Value.POSOrderId, posOrder.Id);
}
public async Task Given_POST_legacy_creates_CreateLegacys_When_requests_prcodi_and_quantity_Then_expects_200_status_code()
{
// Given
var baseUrl = "api/POSOrder/create?api-version=1.0";
var drug = new ProductSeed().GetSeedObject();
var context = _fixture.GetContext();
context.Add(drug);
context.SaveChanges();
var transaction = new POSOrderDto
{
HasDealWithStore = false,
PaymentMethod = new Core.ApplicationModels.Dtos.Payments.PaymentMethodDto
{
Name = "InHands"
},
ConsumerCode = Guid.NewGuid().ToString(),
Items = new POSOrderItemDto[]
{
new POSOrderItemDto
{
ProductUniqueCode = drug.UniqueCode,
CostPrice = drug.CostPrice,
CustomerValue = drug.EndCustomerPrice,
Quantity = 1,
}
}
};
// When
//var result = _client.get
var result = await _client.PostAsJsonAsync(baseUrl, transaction);
var valueResult = await result.Content.ReadAsJsonAsync <BaseResourceResponse <POSOrderDto> >();
// Then
Assert.True(valueResult.Success);
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
var scope = host.Services.CreateScope();
using (scope)
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
var userManager = services.GetRequiredService <UserManager <User> >();
await context.Database.MigrateAsync();
await UserSeed.SeedUserAsync(userManager, context);
await CategorySeed.SeedCategoryAsync(context);
await SubCategorySeed.SeedSubCategory(context);
await ProductSeed.SeedProductAsync(context, userManager);
await ProductImagesSeed.SeedProductImages(context);
await ProductLinkSubCategory.SeedProductLinkSubCategoriesAsync(context);
await VIPAdsSeed.SeedVIPAds(context);
}
catch (Exception e)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(e, "error happen in migration");
}
}
host.Run();
}
public void When_try_add_item_to_cancelled_item_shouldnt_update_object()
{
//Given
var product = new ProductSeed().GetSeedObject();
product.Id = 1;
product.UpdateStock(3, product);
var posOrder = new POSOrder();
var repository = MockRepository((mock) => mock.Setup(m => m.GetBy(It.IsAny <int>()))
.Returns(product));
var expectedQuantity = 1;
posOrder.AddItem(product.Id, expectedQuantity, repository);
posOrder.Cancel();
//When
posOrder.AddItem(product.Id, 1, repository);
//Then
var item = posOrder.Items.FirstOrDefault();
Assert.Equal(expectedQuantity, item.Quantity);
}
public ProductController(IDataProtectionProvider provider)
{
_dataProtector = provider.CreateProtector("private_key_for_example_can_be_ProductController");
_dataProtector2 = provider.CreateProtector("even_can_define_more_than_one");
_productSeed = new ProductSeed();
}
private void Validate(ProductSeed seed)
{
_validator.Validate(seed);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity <Product>().HasData(ProductSeed.GetSeedData());
}
