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