public void Call_Querable_FirstOrDefault_WithSameName()
{
// Arange
var randomNumberOfProducts = 10;
var randomNumberInsideCollection = 4;
var collection = ProductGenerator.GetProducts(randomNumberOfProducts);
var randomItem = collection.ToList()[randomNumberInsideCollection];
var randomName = randomItem.Name;
var randomDto = ProductGenerator.GetProductDtos(1).First();
var mockedQuerable = QuerableMock.GetQuetableMock(collection);
var mockedUnitOfWork = new Mock <IEfUnitOfWork>();
var mockedMapperService = new Mock <IMapperService>();
mockedMapperService.Setup(x => x.Map(randomItem)).Returns(randomDto);
var obj = new ProductService(mockedQuerable.Object, mockedUnitOfWork.Object, mockedMapperService.Object);
// Act
var result = obj.GetByName(randomName);
// Assert
Assert.AreSame(randomDto, result);
}
public void Call_Querable_FirstOrDefault_WithSameName_ButNameWontBeFoundInCollection()
{
// Arange
var randomNumberOfProducts = 10;
var randomNumberInsideCollection = 4;
var collection = ProductGenerator.GetProducts(randomNumberOfProducts);
var randomItem = collection.ToList()[randomNumberInsideCollection];
var randomName = randomItem.Name + "the string that will fail finding the name in the collection";
var mockedQuerable = QuerableMock.GetQuetableMock(collection);
var mockedUnitOfWork = new Mock <IEfUnitOfWork>();
var mockedMapperService = new Mock <IMapperService>();
mockedMapperService.Setup(x => x.Map((Product)null)).Verifiable();
var obj = new ProductService(mockedQuerable.Object, mockedUnitOfWork.Object, mockedMapperService.Object);
// Act
var result = obj.GetByName(randomName);
// Assert
mockedMapperService.Verify();
}
public void Call_UnitOfWork_SaveChangesMethod_AfterAddInQuerable()
{
// Arange
var expected = new List <int>()
{
1, 2
};
var actual = new List <int>();
var productDto = ProductGenerator.GetProductDtos(1).First();
var product = ProductGenerator.GetProducts(1).First();
var mockedQuerable = new Mock <IEfQuerable <Product> >();
mockedQuerable.Setup(x => x.Add(product)).Callback(() => actual.Add(1));
var mockedUnitOfWork = new Mock <IEfUnitOfWork>();
mockedUnitOfWork.Setup(x => x.SaveChanges()).Callback(() => actual.Add(2));
var mockedMapperService = new Mock <IMapperService>();
mockedMapperService.Setup(x => x.Map(productDto)).Returns(product);
var obj = new ProductService(mockedQuerable.Object, mockedUnitOfWork.Object, mockedMapperService.Object);
// Act
obj.Add(productDto);
// Assert
CollectionAssert.AreEqual(expected, actual);
}
public void Call_UnitOfWork_SaveChangesMethod_WhenProductIsValid()
{
// Arange
var productDto = ProductGenerator.GetProductDtos(1).First();
var product = ProductGenerator.GetProducts(1).First();
var mockedQuerable = new Mock <IEfQuerable <Product> >();
mockedQuerable.Setup(x => x.Add(product));
var mockedUnitOfWork = new Mock <IEfUnitOfWork>();
mockedUnitOfWork.Setup(x => x.SaveChanges()).Verifiable();
var mockedMapperService = new Mock <IMapperService>();
mockedMapperService.Setup(x => x.Map(productDto)).Returns(product);
var obj = new ProductService(mockedQuerable.Object, mockedUnitOfWork.Object, mockedMapperService.Object);
// Act
obj.Add(productDto);
// Assert
mockedUnitOfWork.Verify(x => x.SaveChanges(), Times.Once);
}
private static void WriteAndReadProducts(EF6Context context, int nofProducts, int nofProperties, int batchSize = 100)
{
Console.WriteLine("Writing products...");
var sw = Stopwatch.StartNew();
{
foreach (var batch in ProductGenerator.GenerateProducts(nofProducts, nofProperties).Batch(batchSize))
{
// Add new ones.
context.Products.AddRange(batch);
context.SaveChanges();
}
}
sw.Stop();
Console.WriteLine($"Written {nofProducts} products with {nofProperties} properties in: {sw.Elapsed}");
var rps = (nofProducts + nofProducts * nofProperties) / sw.Elapsed.TotalSeconds;
Console.WriteLine($"That is {rps:0.##} records/s");
Console.WriteLine("Reading products...");
context.Products.FirstOrDefault();
var counter = 0;
sw.Restart();
{
IList <Product> batch = null;
do
{
batch = context.Products.AsNoTracking().Include(x => x.Properties).OrderBy(x => x.Id).Skip(counter).Take(100).ToList();
counter += batch.Count;
} while (batch.Count == 100);
}
sw.Stop();
Console.WriteLine($"Read {counter} products with {nofProperties} properties in: {sw.Elapsed}");
}
public async Task PostAsyncOkTest()
{
//Arrange
var saveProductResource = ProductGenerator.GetTestSaveProductResource();
var product = ProductGenerator.GetTestProduct();
product.Name = saveProductResource.Name;
product.Cost = saveProductResource.Cost;
var productResponse = new ProductResponse(product);
var service = new Mock <IProductService>();
service.Setup(e => e.SaveAsync(It.IsAny <Product>())).ReturnsAsync(productResponse);
var controller = new ProductsController(service.Object, _mapper);
//Act
var result = await controller.PostAsync(saveProductResource);
//Assert
var actionResult = Assert.IsType <OkObjectResult>(result);
var productResource = Assert.IsAssignableFrom <ProductResource>(actionResult.Value);
ProductAssertHelper.AssertEquals(saveProductResource, productResource);
}
public async Task Browse_Async_method_Should_Work_Correctly()
{
const int ProductQuantity = 100;
IProductRepository repository = new ProductRepository(DbContextHelper.GetInMemory());
List <Product> generatedProducts = new ProductGenerator().Generate(ProductQuantity).ToList();
foreach (var product in generatedProducts)
{
await repository.AddAsync(product);
}
Product firstProduct = generatedProducts.First();
var @params = new PageProductQuery()
{
Subcategory = firstProduct.Subcategory.Slug,
Category = firstProduct.Subcategory.Category.Slug,
PageNumber = 2,
PageSize = 30
};
//ACT
PagedList <Product> productsFromRepo = await repository.BrowseAsync(@params.PageNumber,
@params.PageSize, @params.Category, @params.Subcategory);
//ASSERT
productsFromRepo.Should().HaveCount(@params.PageSize);
productsFromRepo.PageSize.Should().Be(@params.PageSize);
productsFromRepo.PageNumber.Should().Be(@params.PageNumber);
productsFromRepo.TotalCount.Should().Be(ProductQuantity);
}
static void Main(string[] args)
{
var answer = ProductGenerator.GenerateProducts(999)
.Where(p => p.ToString().IsPalindrome())
.Max();
Console.WriteLine(answer);
Console.ReadKey();
}
public static void Run()
{
Console.WriteLine("<Composite Pattern Example>");
Console.WriteLine();
ProductGenerator.GenerateProducts().ListCategories();
Console.WriteLine();
Console.WriteLine("</Composite Pattern Example>");
Console.WriteLine();
}
// context.EnsureUpsertSproc();
// UpsertProductsBatched(context, nofProducts: 5000, nofProperties: 25);
private static void UpsertProductsBatched(EFCoreContext context, int nofProducts, int nofProperties, int batchSize = 1000)
{
Console.WriteLine("Writing products...");
var sw = Stopwatch.StartNew();
{
foreach (var batch in ProductGenerator.GenerateProducts(nofProducts, nofProperties).Batch(batchSize))
{
var productsTable = new DataTable();
productsTable.Columns.Add("Id", typeof(string));
productsTable.Columns.Add("Code", typeof(string));
productsTable.Columns.Add("Name", typeof(string));
productsTable.Columns.Add("StartDate", typeof(DateTime));
productsTable.Columns.Add("EndDate", typeof(DateTime));
productsTable.Columns.Add("IsActive", typeof(bool));
productsTable.Columns.Add("IsBuyable", typeof(bool));
productsTable.Columns.Add("MinOrderQuantity", typeof(int));
productsTable.Columns.Add("MaxOrderQuantity", typeof(int));
var propertiesTable = new DataTable();
propertiesTable.Columns.Add("ProductId", typeof(string));
propertiesTable.Columns.Add("Name", typeof(string));
propertiesTable.Columns.Add("Locale", typeof(string));
propertiesTable.Columns.Add("Value", typeof(string));
foreach (var p in batch)
{
productsTable.Rows.Add(p.Id, p.Code, p.Name, p.StartDate, p.EndDate,
p.IsActive, p.IsBuyable, p.MinOrderQuantity, p.MaxOrderQuantity);
foreach (var prop in p.Properties)
{
propertiesTable.Rows.Add(prop.ProductId, prop.Name, prop.Locale, prop.Value);
}
}
context.Database.ExecuteSqlCommand("EXEC [dbo].[UpsertProducts] @products, @properties",
new SqlParameter("@products", SqlDbType.Structured)
{
Value = productsTable,
TypeName = "dbo.ProductsUDT"
},
new SqlParameter("@properties", SqlDbType.Structured)
{
Value = propertiesTable,
TypeName = "dbo.ProductPropertiesUDT"
});
}
}
sw.Stop();
Console.WriteLine($"Written {nofProducts} products with {nofProperties} properties in: {sw.Elapsed}");
var rps = (nofProducts + nofProducts * nofProperties) / sw.Elapsed.TotalSeconds;
Console.WriteLine($"That is {rps:0.##} records/s");
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
ProductGenerator.Initialize(services);
}
host.Run();
}
public async Task PutAsyncBadRequestTest()
{
// Arrange
var controller = new ProductsController(Mock.Of <IProductService>(), _mapper);
controller.ModelState.AddModelError("error", "some error");
// Act
var result = await controller.PutAsync(1, ProductGenerator.GetTestSaveProductResource());
// Assert
Assert.IsType <BadRequestObjectResult>(result);
}
private static void WriteAndReadProducts(EFCoreContext context, int nofProducts, int nofProperties, int batchSize = 100)
{
Console.WriteLine("Writing products...");
var sw = Stopwatch.StartNew();
{
foreach (var batch in ProductGenerator.GenerateProducts(nofProducts, nofProperties).Batch(batchSize))
{
// Read existing from database.
var ids = batch.Select(x => x.Id).ToArray();
var existingSetFromDb = context.Products
.Include(x => x.Properties)
.Where(x => ids.Contains(x.Id)).ToList();
// Update existing ones.
var existingSetInBatch = new List <Product>();
foreach (var existing in existingSetFromDb)
{
var update = batch.First(x => x.Id.Equals(existing.Id, StringComparison.OrdinalIgnoreCase));
existing.UpdateFrom(update);
existingSetInBatch.Add(update);
}
// Add new ones.
context.Products.AddRange(batch.Except(existingSetInBatch));
context.SaveChanges();
}
}
sw.Stop();
Console.WriteLine($"Written {nofProducts} products with {nofProperties} properties in: {sw.Elapsed}");
var rps = (nofProducts + nofProducts * nofProperties) / sw.Elapsed.TotalSeconds;
Console.WriteLine($"That is {rps:0.##} records/s");
Console.WriteLine("Reading products...");
context.Products.FirstOrDefault();
var counter = 0;
sw.Restart();
{
IList <Product> batch = null;
do
{
batch = context.Products.AsNoTracking().Include(x => x.Properties).OrderBy(x => x.Id).Skip(counter).Take(100).ToList();
counter += batch.Count;
} while (batch.Count == 100);
}
sw.Stop();
Console.WriteLine($"Read {counter} products with {nofProperties} properties in: {sw.Elapsed}");
}
public SectionProductList GetProductList()
{
var productGenerator = new ProductGenerator();
var productList = new SectionProductList();
productList.SystemId = Guid.NewGuid();
productList.Title = "Products";
productList.Text = "Here are some products you may be interested in.";
foreach (var i in Enumerable.Range(1, 4))
{
productList.Products.Add(productGenerator.GenerateProduct());
}
return(productList);
}
protected override TestServer CreateServer(IWebHostBuilder builder)
{
//Real TCP port
this.host = builder.Build();
this.host.Start();
RootUri = this.host.ServerFeatures.Get <IServerAddressesFeature>().Addresses.LastOrDefault();
using (var scope = this.host.Services.CreateScope())
{
var services = scope.ServiceProvider;
ProductGenerator.Initialize(services);
}
//Fake Server we won't use...this is lame. Should be cleaner, or a utility class
return(new TestServer(new WebHostBuilder().UseStartup <Startup>()));
}
public async Task Must_Update()
{
var product = ProductGenerator.GenerateAndSave(ProductRepository, Command.CategoryId);
Command.Id = product.Id;
var response = await HttpClient.PutAsJsonAsync($"{BasePath}Products", Command);
Output.WriteLine(await response.Content.ReadAsStringAsync());
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
product = ProductRepository.Reload(product);
Assert.Equal(Command.Id, product.Id);
Assert.Equal(Command.Title, product.Title);
}
public void Return_ResultProperly_WhenArgumentIsValid()
{
// Arange
var product = ProductGenerator.GetProducts(1).First();
var obj = new MapperService();
// Act
var result = obj.MapToSimple(product);
// Assert
Assert.AreEqual(product.ProductId, result.Id);
Assert.AreEqual(product.Name, result.Name);
Assert.AreEqual(product.Price, result.Price);
Assert.AreEqual(product.Photo1, result.ImageUrl);
Assert.AreEqual(@"/" + product.Name, result.Link);
}
private static async Task WriteProducts(IBulkExecutor bulkExecutor, int nofProducts, int nofProperties)
{
Console.WriteLine("Writing products...");
var sw = Stopwatch.StartNew();
{
await bulkExecutor.BulkImportAsync(
ProductGenerator.GenerateProducts(nofProducts, nofProperties)
.Select(x => JObject.FromObject(x, Serializer)),
enableUpsert : true);
}
sw.Stop();
Console.WriteLine($"Written {nofProducts} products with {nofProperties} properties in: {sw.Elapsed}");
var rps = (nofProducts + nofProducts * nofProperties) / sw.Elapsed.TotalSeconds;
Console.WriteLine($"That is {rps:0.##} records/s");
}
public async Task GetByIdOkTest()
{
//Arrange
var service = new Mock <IProductService>();
var productResponse = ProductGenerator.GetTestProductResponse();
service.Setup(e => e.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(productResponse);
var controller = new ProductsController(service.Object, _mapper);
//Act
var result = await controller.GetById(productResponse.Product.Id);
//Assert
var actionResult = Assert.IsType <OkObjectResult>(result);
var productResource = Assert.IsAssignableFrom <ProductResource>(actionResult.Value);
ProductAssertHelper.AssertEquals(productResponse.Product, productResource);
}
public void Return_ProductProperly_WhenDtoIsValid()
{
// Arange
var product = ProductGenerator.GetProductDtos(1).First();
var obj = new MapperService();
// Act
var result = obj.Map(product);
// Assert
Assert.AreEqual(product.ProductId, result.ProductId);
Assert.AreEqual(product.Name, result.Name);
Assert.AreEqual(product.Count, result.Count);
Assert.AreEqual(product.Price, result.Price);
Assert.AreEqual(product.Photo1, result.Photo1);
Assert.AreEqual(product.Photo2, result.Photo2);
Assert.AreEqual(product.Photo3, result.Photo3);
Assert.AreEqual(product.Photo4, result.Photo4);
}
public async Task GetAllAsyncTest()
{
//Arrange
var service = new Mock <IProductService>();
var products = ProductGenerator.GetTestProducts();
service.Setup(e => e.ListAsync()).ReturnsAsync(products);
var controller = new ProductsController(service.Object, _mapper);
//Act
var result = await controller.GetAllAsync();
//Assert
var actionResult = Assert.IsType <List <ProductResource> >(result);
var productResources = Assert.IsAssignableFrom <List <ProductResource> >(actionResult);
AssertHelperBase.AssertEqualLists(products, actionResult, ProductAssertHelper.AssertEquals);
Assert.Equal(3, productResources.Count());
}
private static void SeedProducts(SalesContext db, int count)
{
ProductGenerator.InitialProductsSeed(db, count);
}
public async Task Create_Order_Then_Update_Product_Then_Get_Order_Products_Test()
{
var product0 = await _productRepository.CreateProductAsync(
ProductGenerator.GenerateProduct(), CancellationToken.None);
var product1 = await _productRepository.CreateProductAsync(
ProductGenerator.GenerateProduct(), CancellationToken.None);
var product2 = await _productRepository.CreateProductAsync(
ProductGenerator.GenerateProduct(), CancellationToken.None);
var order = new OrderEntity
{
CreatedOn = DateTime.UtcNow,
ProductIdCollection = new[]
{
Guid.NewGuid(),
Guid.NewGuid(),
product0.Id,
Guid.NewGuid(),
product1.Id,
product2.Id,
Guid.NewGuid(),
}
};
order = await _orderRepository.CreateOrderAsync(order, CancellationToken.None);
Assert.IsNotNull(order);
Assert.IsNotNull(order.Products);
Assert.IsNotNull(order.ProductIdCollection);
var products = order.Products.ToArray();
Assert.AreEqual(3, products.Length);
Assert.IsTrue(products.Any(product => product.Id == product0.Id));
Assert.IsTrue(products.Any(product => product.Id == product1.Id));
Assert.IsTrue(products.Any(product => product.Id == product2.Id));
var productIdCollection = order.ProductIdCollection.ToArray();
Assert.AreEqual(3, productIdCollection.Length);
Assert.IsTrue(productIdCollection.Any(id => id == product0.Id));
Assert.IsTrue(productIdCollection.Any(id => id == product1.Id));
Assert.IsTrue(productIdCollection.Any(id => id == product2.Id));
product0.Sku = ProductGenerator.GenerateToken();
await _productRepository.UpdateProducAsync(product0, CancellationToken.None);
var productsForOrder = await _productRepository.GetProductsForOrderAsync(
order.Id, OrderProductSortProperty.Sku, SortDirection.Descending, CancellationToken.None);
Assert.IsNotNull(productsForOrder);
var controlProductsForOrder = new[] { product0, product1, product2, }
.OrderByDescending(product => product.Sku)
.ToArray();
var testProductsForOrder = productsForOrder.ToArray();
Assert.AreEqual(controlProductsForOrder.Length, testProductsForOrder.Length);
for (var i = 0; i < controlProductsForOrder.Length; ++i)
{
Assert.AreEqual(controlProductsForOrder[i].Id, testProductsForOrder[i].Id);
Assert.AreEqual(controlProductsForOrder[i].Sku, testProductsForOrder[i].Sku);
Assert.AreEqual(controlProductsForOrder[i].Name, testProductsForOrder[i].Name);
Assert.AreEqual(controlProductsForOrder[i].Price, testProductsForOrder[i].Price);
}
var changeNotes = await _productChangeNoteRepository.GetProductChangeNotesAsync(
product0.Id, CancellationToken.None);
Assert.IsNotNull(changeNotes);
Assert.AreEqual(2, changeNotes.Count());
Assert.IsTrue(changeNotes.Any(changeNote => changeNote is OrderCreatedProductChangeNoteEntity));
Assert.IsTrue(changeNotes.Any(changeNote => changeNote is ProductFieldChangedProductChangeNoteEntity));
}
