public async Task AddProduct_ValidData_ReturnsValidData()
{
//Arrange
var expextedResult = _fixture.Build <Product>().Create();
_mockproductRepository.Setup(x => x.AddProduct(expextedResult)).ReturnsAsync(expextedResult);
//Act
var actualResult = await _productService.AddProduct(expextedResult);
//Assert
actualResult.Should().BeEquivalentTo(expextedResult);
_mockproductRepository.VerifyAll();
}
static void Main(string[] args)
{
var service = new ProductsService();
System.Console.WriteLine("GET ALL PRODUCTS");
var allProducts = service.GetProducts();
foreach (var product in allProducts)
{
System.Console.WriteLine(string.Format("Id: {0}, Name: {1}, Price: ${2:0}", product.Id, product.Name, product.Price));
}
System.Console.WriteLine("Add product 100!!!");
service.AddProduct(100, "A real name", "Real description", 1000);
foreach (var product in allProducts)
{
System.Console.WriteLine(string.Format("Id: {0}, Name: {1}, Price: ${2:0}", product.Id, product.Name, product.Price));
}
System.Console.WriteLine("Remove product 100!!!");
service.RemoveProduct(100);
foreach (var product in allProducts)
{
System.Console.WriteLine(string.Format("Id: {0}, Name: {1}, Price: ${2:0}", product.Id, product.Name, product.Price));
}
System.Console.ReadKey();
}
public void Test_Persistence_Exception_Product_Not_Found_On_Update()
{
//create In Memory Database
var options = new DbContextOptionsBuilder <ERPContext>()
.UseInMemoryDatabase(databaseName: "ERP")
.Options;
using (var context = new ERPContext(options))
{
var repository = new EFRepository(context);
var productService = new ProductsService(repository);
//Insert an product
productService.AddProduct(new Product
{
Id = 1,
Name = "Ball",
Price = 1000,
Image = "base64Image"
});
Assert.Throws <PersistenceException>(() => productService.UpdateProduct(new Product
{
Id = 2,
Name = "Ball",
Price = 2000,
Image = "base64Image"
}));
}
}
public void AddProduct_ShouldReturn_Success()
{
// Arrange
ProductsModel product = new ProductsModel()
{
SupplierId = 1,
CategoryId = 1,
GroupId = 1,
NameWebStore = "product1",
NameSupplier = "Product1",
CodeWebStore = "111",
CodeSupplier = "112",
UnitId = 1,
PriceWebStore = 1.5m,
PriceSupplier = 1,
Available = "+",
LinkWebStore = "link1",
LinkSupplier = "link2",
Notes = "some notes"
};
fakeProductsRepository.Setup(a => a.Add(product));
productsService = new ProductsService(fakeProductsRepository.Object,
new Mock <ICommonRepository>().Object);
ProductsDtoModel productDto = new ProductsDtoModel()
{
SupplierId = product.SupplierId,
CategoryId = product.CategoryId,
GroupId = product.GroupId,
NameWebStore = product.NameWebStore,
NameSupplier = product.NameSupplier,
CodeWebStore = product.CodeWebStore,
CodeSupplier = product.CodeSupplier,
UnitId = product.UnitId,
PriceWebStore = product.PriceWebStore,
PriceSupplier = product.PriceSupplier,
Available = product.Available,
LinkWebStore = product.LinkWebStore,
LinkSupplier = product.LinkSupplier,
Notes = product.Notes
};
try
{
// Act
productsService.AddProduct(productDto);
operationSucceeded = true;
}
catch (Exception ex)
{
errorMessage = ex.Message + " | " + ex.StackTrace;
}
// Assert
Assert.IsTrue(operationSucceeded, errorMessage);
}
public void ShouldThrowArgumentNullException_WhenNullProductIsPassed()
{
// Arrange
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedGenericRepository = new Mock <IGenericRepository <Product> >();
var productsService = new ProductsService(mockedUnitOfWork.Object, mockedGenericRepository.Object);
// Act and Assert
Assert.Throws <ArgumentNullException>(() => productsService.AddProduct(null));
}
//Gelen Data Json a çevireceğin zaman [FromBody] Kullan
public IActionResult Post(Product product)
{
try
{
_productsService.AddProduct(product);
return(new StatusCodeResult(201));
}
catch
{
return(BadRequest());
}
}
public ActionResult <Product> AddProduct([FromBody] Product model)
{
var result = ProductsService.AddProduct(model);
if (result != null)
{
return(Ok(result));
}
else
{
return(BadRequest());
}
}
public void ShouldThrowArgumentNullExceptionWithCorrectMessage_WhenNullProductIsPassed()
{
// Arrange
var expectedExMessage = "Product cannot be null.";
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedGenericRepository = new Mock <IGenericRepository <Product> >();
var productsService = new ProductsService(mockedUnitOfWork.Object, mockedGenericRepository.Object);
// Act and Assert
var exception = Assert.Throws <ArgumentNullException>(() => productsService.AddProduct(null));
StringAssert.Contains(expectedExMessage, exception.Message);
}
public IActionResult Add(HttpSession session, HttpResponse response, AddProductBindingModel binding)
{
User user = AuthenticationManager.GetAuthenticatedUser(session.Id);
if (user == null)
{
this.Redirect(response, "/login/login");
return(null);
}
ProductsService service = new ProductsService(Data.Data.Context);
service.AddProduct(binding);
this.Redirect(response, "/admin/index");
return(null);
}
public void AddProductNullEntityShouldNotAddProduct()
{
var options = new DbContextOptionsBuilder <XeonDbContext>()
.UseInMemoryDatabase(databaseName: "AddNull_Product_Database")
.Options;
var dbContext = new XeonDbContext(options);
var productService = new ProductsService(dbContext);
Product product = null;
productService.AddProduct(product);
var products = dbContext.Products.ToList();
Assert.Empty(products);
}
public void ShouldCallCommitMethodOfUnitOfWorkOnce_WhenAProductIsPassed()
{
// Arrange
var product = new Mock <Product>();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedGenericRepository = new Mock <IGenericRepository <Product> >();
mockedUnitOfWork.Setup(uow => uow.Commit()).Verifiable();
var productsService = new ProductsService(mockedUnitOfWork.Object, mockedGenericRepository.Object);
// Act
productsService.AddProduct(product.Object);
// Assert
mockedUnitOfWork.Verify(uow => uow.Commit(), Times.Once);
}
public void ShouldCallAddMethodOfCategoryRepositoryOnce_WhenAProductIsPassed()
{
// Arrange
var product = new Mock <Product>();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedGenericRepository = new Mock <IGenericRepository <Product> >();
mockedGenericRepository.Setup(gr => gr.Add(product.Object)).Verifiable();
var productsService = new ProductsService(mockedUnitOfWork.Object, mockedGenericRepository.Object);
// Act
productsService.AddProduct(product.Object);
// Assert
mockedGenericRepository.Verify(gr => gr.Add(product.Object), Times.Once);
}
public void AddProduct_ValidProduct_Success()
{
//arrange
Mock <IProductsRepository> mockProductRepo = new Mock <IProductsRepository>();
Mock <ICategoriesRepository> mockCategoryRepo = new Mock <ICategoriesRepository>();
Mock <IMapper> mockMapper = new Mock <IMapper>();
Category category = new Category
{
Name = "TestCategory"
};
CategoryDTO categoryDTO = new CategoryDTO
{
Name = "TestCategory"
};
Product product = new Product
{
Name = "Testowy",
Description = "LoremipsumLoremipsumLoremipsumLoremipsumLoremipsum",
Category = category
};
ProductDTO productDTO = new ProductDTO
{
Name = "Testowy",
Description = "LoremipsumLoremipsumLoremipsumLoremipsumLoremipsum",
Category = categoryDTO
};
ProductsService service = new ProductsService(mockProductRepo.Object, mockCategoryRepo.Object,
mockMapper.Object);
mockMapper.Setup(m => m.Map <Product>(productDTO)).Returns(product);
mockCategoryRepo.Setup(m => m.GetCategoryByName(categoryDTO.Name)).Returns(category);
mockCategoryRepo.Setup(m => m.GetCategoryById(categoryDTO.Id)).Returns(category);
//act
service.AddProduct(productDTO);
//asserts
mockProductRepo.Verify(m => m.Add(product));
}
public void AddProductShouldAddProduct()
{
var options = new DbContextOptionsBuilder <XeonDbContext>()
.UseInMemoryDatabase(databaseName: "Add_Product_Database")
.Options;
var dbContext = new XeonDbContext(options);
var productService = new ProductsService(dbContext);
var product = new Product {
Name = "USB"
};
productService.AddProduct(product);
var products = dbContext.Products.ToList();
Assert.Single(products);
Assert.Equal(product.Name, products.First().Name);
}
public void Test_Business_Exception_High_Price()
{
//create In Memory Database
var options = new DbContextOptionsBuilder <ERPContext>()
.UseInMemoryDatabase(databaseName: "ERP")
.Options;
using (var context = new ERPContext(options))
{
var repository = new EFRepository(context);
var productService = new ProductsService(repository);
Assert.Throws <BusinessException>(() => productService.AddProduct(new Product
{
Id = 1,
Name = "Ball",
Price = 10000000,
Image = "base64Image"
}));
}
}
public void AddProduct_ProductWithNotExistingCategory_Unsuccess()
{
//arrange
Mock <IProductsRepository> mockProductRepo = new Mock <IProductsRepository>();
Mock <ICategoriesRepository> mockCategoryRepo = new Mock <ICategoriesRepository>();
Mock <IMapper> mockMapper = new Mock <IMapper>();
Category category = new Category
{
Name = "TestCategory"
};
CategoryDTO categoryDTO = new CategoryDTO
{
Name = "TestCategory"
};
Product product = new Product
{
Name = "Testowy",
Description = "LoremipsumLoremipsumLoremipsumLoremipsumLoremipsum",
Category = category
};
ProductDTO productDTO = new ProductDTO
{
Name = "Testowy",
Description = "LoremipsumLoremipsumLoremipsumLoremipsumLoremipsum",
Category = categoryDTO
};
ProductsService service = new ProductsService(mockProductRepo.Object, mockCategoryRepo.Object,
mockMapper.Object);
mockMapper.Setup(m => m.Map <Product>(productDTO)).Returns(product);
mockCategoryRepo.Setup(m => m.GetCategoryByName(categoryDTO.Name)).Returns((Category)null);
//act and assert
Assert.Throws <ValidationException>(() => { service.AddProduct(productDTO); });
}
public void Test_Business_Exception_Too_Large_Image_File()
{
// Create a fake base64file
string fakeBase64File = new string('*', 1048577); //1MB
//create In Memory Database
var options = new DbContextOptionsBuilder <ERPContext>()
.UseInMemoryDatabase(databaseName: "ERP")
.Options;
using (var context = new ERPContext(options))
{
var repository = new EFRepository(context);
var productService = new ProductsService(repository);
Assert.Throws <BusinessException>(() => productService.AddProduct(new Product
{
Id = 1,
Name = "Ball",
Price = 100,
Image = fakeBase64File
}));
}
}
public void AddProduct([FromBody] Product product)
{
productsService.AddProduct(product);
}
