public async Task When_Insert_Product()
{
//Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
Mock <IGenericRepository <Product> > repositoryMock = new MockProductRepository().InsertProductAsync();
var mockUnitOfWork = new MockUnitOfWork().ProductRepository(repositoryMock).SaveChangesAsync();
var productService = new ProductService(mockUnitOfWork.Object, loggerMock.Object);
var entity = new CreateProduct
{
Name = "Pepino",
Description = "Pepino",
Sku = "1234567890",
Price = 320.1M,
MinimunStock = 1,
MaximumStock = 210,
Stock = 0
};
//Act
var result = await productService.InsertProductAsync(entity);
//Assert
Assert.NotNull(result);
Assert.True(result.Id != Guid.Parse("00000000-0000-0000-0000-000000000000"));
}
public async Task When_Remove_Products_Of_Warehouse_Is_Correct_Remove_Product_Warehouse()
{
//Arrange
var loggerMock = new Mock <ILogger <MovementService> >();
Mock <IGenericRepository <Movement> > repositoryMovementMock = new MockMovementRepository().Queryable();
Mock <IGenericRepository <Product> > repositoryProductMock = new MockProductRepository()
.GetProductByIdAsync()
.UpdateProductAsync()
.Queryable();
var mockUnitOfWork = new MockUnitOfWork().MovementRepository(repositoryMovementMock)
.ProductRepository(repositoryProductMock)
.SaveChangesAsync();
var movementService = new MovementService(mockUnitOfWork.Object, loggerMock.Object);
RemoveProductWarehouse movement = new RemoveProductWarehouse
{
Quantity = 2,
ProductId = Guid.Parse("B99BC862-C515-4D61-97D8-4D2B188A19F3"),
WarehouseId = Guid.Parse("351BA5AA-C78D-4491-931A-76603D729392")
};
//Act
var result = await movementService.RemoveProductsOfWarehouse(movement);
//Assert
Assert.True(result.Equals(true));
}
public async Task When_No_Insert_Product_Is_Realy_Exist()
{
//Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
Mock <IGenericRepository <Product> > repositoryMock = new MockProductRepository()
.InsertProductAsync()
.Queryable();
var mockUnitOfWork = new MockUnitOfWork().ProductRepository(repositoryMock).SaveChangesAsync();
var productService = new ProductService(mockUnitOfWork.Object, loggerMock.Object);
var entity = new CreateProduct
{
Name = "Cebolla",
Description = "Cebolla",
Sku = "1234567890",
Price = 320.1M,
MinimunStock = 1,
MaximumStock = 210,
Stock = 0
};
Exception exception = null;
//Act
try
{
await productService.InsertProductAsync(entity);
}
catch (Exception ex)
{
exception = ex;
}
//Assert
Assert.True("There is already a product with this name." == exception.Message);
}
public async Task When_Error_Update_Product()
{
//Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
Mock <IGenericRepository <Product> > repositoryMock = new MockProductRepository().UpdateProductAsync().ExistProductAsync();
var mockUnitOfWork = new MockUnitOfWork().ProductRepository(repositoryMock).SaveChangesAsync();
var productService = new ProductService(mockUnitOfWork.Object, loggerMock.Object);
Exception exception = null;
var entity = new Product
{
Id = Guid.Parse("862F07EE-F92F-4EFB-9308-0F4C8B03A976"),
Name = "Pepino",
Description = "Pepino",
Sku = "1234567890",
Price = 320.1M,
MinimunStock = 1,
MaximumStock = 210,
Stock = 0
};
//Act
try
{
await productService.UpdateProductAsync(entity);
}
catch (Exception ex)
{
exception = ex;
}
//Assert
Assert.True("Product doesn't exist" == exception.Message);
Assert.True(typeof(BusinessException) == exception.GetType());
}
public async Task When_Update_Product()
{
//Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
Mock <IGenericRepository <Product> > repositoryMock = new MockProductRepository().UpdateProductAsync().ExistProductAsync();
var mockUnitOfWork = new MockUnitOfWork().ProductRepository(repositoryMock).SaveChangesAsync();
var productService = new ProductService(mockUnitOfWork.Object, loggerMock.Object);
var entity = new Product
{
Id = Guid.Parse("4d8830e2-465c-4a54-ad02-f875073c85dc"),
Name = "Pepino",
Description = "Pepino",
Sku = "1234567890",
Price = 320.1M,
MinimunStock = 1,
MaximumStock = 210,
Stock = 0
};
//Act
var result = await productService.UpdateProductAsync(entity);
//Assert
Assert.True(result);
}
public async Task When_Error_Update_Stock_Product(string id)
{
//Arrange
var stockValue = 23;
var loggerMock = new Mock <ILogger <ProductService> >();
Mock <IGenericRepository <Product> > repositoryMock = new MockProductRepository()
.GetProductByIdAsync()
.UpdateProductAsync()
.ExistProductAsync();
var mockUnitOfWork = new MockUnitOfWork().ProductRepository(repositoryMock).SaveChangesAsync();
var productService = new ProductService(mockUnitOfWork.Object, loggerMock.Object);
Exception exception = null;
//Act
try
{
await productService.UpdateStockProduct(Guid.Parse(id), stockValue);
}
catch (Exception ex)
{
exception = ex;
}
//Assert
Assert.True("Product doesn't exist" == exception.Message);
Assert.True(typeof(BusinessException) == exception.GetType());
}
public async Task When_Move_Product_Other_Warehouse()
{
//Arrange
var loggerMock = new Mock <ILogger <MovementService> >();
Mock <IGenericRepository <Movement> > repositoryMovementMock = new MockMovementRepository().Queryable();
Mock <IGenericRepository <Product> > repositoryProductMock = new MockProductRepository()
.GetProductByIdAsync()
.UpdateProductAsync()
.Queryable();
var mockUnitOfWork = new MockUnitOfWork().MovementRepository(repositoryMovementMock)
.ProductRepository(repositoryProductMock)
.SaveChangesAsync();
var movementService = new MovementService(mockUnitOfWork.Object, loggerMock.Object);
MoveProducts moveProducts = new MoveProducts
{
Quantity = 3,
ProductId = Guid.Parse("B99BC862-C515-4D61-97D8-4D2B188A19F3"),
CurrentWarehouseId = Guid.Parse("351BA5AA-C78D-4491-931A-76603D729392"),
NewWarehouseId = Guid.Parse("C347ED5D-1F33-49EE-A58D-B7F2310192A6")
};
//Act
var result = await movementService.MoveProductOtherWarehouse(moveProducts);
//Assert
Assert.NotNull(result);
Assert.True(result.ToList().Count > 0);
}
public async Task When_Error_Get_Total_Shopping_Of_Product(string id)
{
//Arrange
var loggerMock = new Mock <ILogger <MovementService> >();
Mock <IGenericRepository <Movement> > repositoryMovementMock = new MockMovementRepository().Queryable();
Mock <IGenericRepository <Product> > repositoryProductMock = new MockProductRepository()
.GetProductByIdAsync()
.UpdateProductAsync()
.Queryable();
var mockUnitOfWork = new MockUnitOfWork().MovementRepository(repositoryMovementMock)
.ProductRepository(repositoryProductMock)
.SaveChangesAsync();
var movementService = new MovementService(mockUnitOfWork.Object, loggerMock.Object);
Exception exception = null;
//Act
try
{
await movementService.GetTotalShoppingProduct(Guid.Parse(id));
}
catch (Exception ex)
{
exception = ex;
}
//Assert
Assert.True("The product is out of stock and purchases" == exception.Message);
Assert.True(typeof(BusinessException) == exception.GetType());
}
public void DebugListAllProducts()
{
MockProductRepository mockProductRepository = new MockProductRepository();
List <Product> products = mockProductRepository.GetAllProducts();
ProductBrowser productBrowser = new ProductBrowser();
productBrowser.BrowseListOfProducts(products);
}
public void AddNewProduct_InvokeAPI_ReturnNewProduct()
{
//Arrange
IProductRepository _productRepository = new MockProductRepository();
ProductController controller = new ProductController(_productRepository);
Product newProduct = new Product()
{
ProdType = "Desktop1",
ProcessorType = "P71",
Brand = "Dell1",
UsbPorts = 3,
RamSlots = 2,
FormFactor = "Tower1",
Quantity = 10
};
//ACT
JsonResult actualResult = controller.Post(newProduct);
//var result = JsonConvert.DeserializeObject<Newtonsoft.Json.Linq.JObject>(JsonConvert.SerializeObject(actualResult));
//var actProduct = JsonConvert.DeserializeObject<string>(result.SelectToken("Value").ToString());
//ASSERT
Assert.AreEqual(actualResult.Value.ToString(), "Product Added Successfully");
JsonResult actualResult1 = controller.Get();
var result1 = JsonConvert.DeserializeObject <Newtonsoft.Json.Linq.JObject>(JsonConvert.SerializeObject(actualResult1));
var actProduct1 = JsonConvert.DeserializeObject <List <Product> >(result1.SelectToken("Value").ToString());
//ASSERT
Product expProduct = new Product()
{
Id = 2,
ProdType = "Desktop1",
ProcessorType = "P71",
Brand = "Dell1",
UsbPorts = 3,
RamSlots = 2,
FormFactor = "Tower1",
Quantity = 10
};
Assert.AreEqual(actProduct1[1].Id, expProduct.Id);
Assert.AreEqual(actProduct1[1].ProdType, expProduct.ProdType);
Assert.AreEqual(actProduct1[1].Brand, expProduct.Brand);
Assert.AreEqual(actProduct1[1].ProcessorType, expProduct.ProcessorType);
Assert.AreEqual(actProduct1[1].Quantity, expProduct.Quantity);
Assert.AreEqual(actProduct1[1].UsbPorts, expProduct.UsbPorts);
Assert.AreEqual(actProduct1[1].RamSlots, expProduct.RamSlots);
Assert.AreEqual(actProduct1[1].FormFactor, expProduct.FormFactor);
}
public void GetProductByIdNullTest()
{
var db = new MockProductDBContext();
var repository = new MockProductRepository(db);
var controller = new ProductsController(repository);
var result = controller.Get("0") as NotFoundResult;
Assert.NotNull(result);
Assert.Equal(404, result.StatusCode);
}
public void A_Null_Object_Caching_Adapter_Will_Prevent_Any_Data_Caching()
{
MockProductRepository mockProductRepository = new MockProductRepository();
NullObjectCachingAdapter nullObjectCachingAdapter = new NullObjectCachingAdapter();
int categoryId = 1;
ProductService productService = new ProductService(mockProductRepository, nullObjectCachingAdapter);
productService.GetAllProductsIn(categoryId);
Assert.AreEqual(1, mockProductRepository.NumberOfTimesCalled());
productService.GetAllProductsIn(categoryId);
Assert.AreEqual(2, mockProductRepository.NumberOfTimesCalled());
}
public void TestRatingsOnBreadInDetailsView()
{
//Arrange
IBreadRepository breadRepository = new MockBreadRepository();
IProductRepository productRepository = new MockProductRepository();
IRatingRepository ratingRepository = new MockRatingRepository();
var controller = new BreadController(breadRepository, productRepository, ratingRepository);
// Act
var result = controller.BreadView(1);
// Assert
Assert.IsType <ViewResult>(result);
}
public async Task When_Delete_Product(string id)
{
//Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
Mock <IGenericRepository <Product> > repositoryMock = new MockProductRepository().DeleteProductAsync().ExistProductAsync();
var mockUnitOfWork = new MockUnitOfWork().ProductRepository(repositoryMock).SaveChangesAsync();
var productService = new ProductService(mockUnitOfWork.Object, loggerMock.Object);
//Act
var result = await productService.DeleteAsync(Guid.Parse(id));
//Assert
Assert.True(result.Equals(true));
}
public async Task When_Get_All_Product_Service()
{
//Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
Mock <IGenericRepository <Product> > repositoryMock = new MockProductRepository().GetAllProductAsync();
var mockUnitOfWork = new MockUnitOfWork().ProductRepository(repositoryMock);
var productService = new ProductService(mockUnitOfWork.Object, loggerMock.Object);
//Act
var result = await productService.GetProductsAsync();
//Assert
Assert.NotNull(result);
Assert.True(result.ToList().Count > 0);
}
public async Task When_Get_Product_By_Name_Service(string name)
{
//Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
Mock <IGenericRepository <Product> > repositoryMock = new MockProductRepository().Queryable();
var mockUnitOfWork = new MockUnitOfWork().ProductRepository(repositoryMock);
var productService = new ProductService(mockUnitOfWork.Object, loggerMock.Object);
//Act
var result = await productService.GetProductByNameAsync(name);
//Assert
Assert.NotNull(result);
Assert.True(result.Name.Equals(name));
}
public void TestsTheBreadView()
{
//Arrange
IBreadRepository breadRepository = new MockBreadRepository();
IProductRepository productRepository = new MockProductRepository();
IRatingRepository ratingRepository = new MockRatingRepository();
var controller = new BreadController(breadRepository, productRepository, ratingRepository);
// Act
var result = controller.BreadList();
// Assert
Assert.NotNull(result);
Assert.IsType <ViewResult>(result);
}
public async Task When_Get_Product_By_Id_Service(string id)
{
//Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
Mock <IGenericRepository <Product> > repositoryMock = new MockProductRepository().GetProductByIdAsync();
var mockUnitOfWork = new MockUnitOfWork().ProductRepository(repositoryMock);
var productService = new ProductService(mockUnitOfWork.Object, loggerMock.Object);
//Act
var result = await productService.GetProductByIdAsync(Guid.Parse(id));
//Assert
Assert.NotNull(result);
Assert.True(result.Id.Equals(Guid.Parse(id)));
}
public void ListAllProducts()
{
Clear();
var mockProductRepository = new MockProductRepository();
var products = mockProductRepository.GetAllProducts();
Echo("Liste des produits : \n");
foreach (Product product in products)
{
Console.WriteLine(product.Name + "\n");
}
AskKeyPress("Appuyez sur une touche pour revenir au menu.\n");
DisplayMainMenu();
}
public void GetProductByIdTest()
{
var db = new MockProductDBContext();
var repository = new MockProductRepository(db);
var controller = new ProductsController(repository);
var id = "0d62fd12-7ce3-4b7f-84cb-b12a417786a2";
var expectedProduct = new Product()
{
Id = id, Name = "product 1", Description = "", Price = 9.99m, ImgUri = "uri"
};
var result = controller.Get(id) as ObjectResult;
var product = result?.Value as Product;
Assert.NotNull(product);
Assert.Equal(expectedProduct, product);
}
public void EditProductTest()
{
var db = new MockProductDBContext();
var repository = new MockProductRepository(db);
var controller = new ProductsController(repository);
var id = "0d62fd12-7ce3-4b7f-84cb-b12a417786a2";
var productToPost = new Product()
{
Id = id, Name = "product 11", Description = "new description", Price = 11.00m, ImgUri = "new uri"
};
controller.Post(productToPost);
var result = controller.Get(id) as ObjectResult;
var product = result?.Value as Product;
Assert.NotNull(product);
Assert.Equal(productToPost, product);
}
public void AddProductTest()
{
var db = new MockProductDBContext();
var repository = new MockProductRepository(db);
var controller = new ProductsController(repository);
var id = Guid.NewGuid().ToString();
var productToPost = new Product()
{
Id = id, Name = "product 3", Description = "", Price = 1.00m, ImgUri = "uri"
};
controller.Post(productToPost);
var result = controller.Get(id) as ObjectResult;
var product = result?.Value as Product;
Assert.NotNull(product);
Assert.Equal(productToPost, product);
}
static void Main(string[] args)
{
var repository = new MockProductRepository();
var basket = new BasketService(repository);
Console.WriteLine("Scanning Products");
Console.WriteLine("Adding 3 apples to basket...");
basket.AddProduct(appleBarcode, 3);
Console.WriteLine("Adding 5 oranges to basket...");
basket.AddProduct(orangeBarcode, 5);
Console.WriteLine("Adding 2lbs of bananas to basket...");
basket.AddWeightedProduct(bananaBarcode, 2);
Console.WriteLine($"Basket Total: £{basket.GetTotal()}");
Console.WriteLine("Press any key to exit");
Console.Read();
}
public async Task When_Get_All_Warehouse_Not_Records()
{
//Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
Exception exception = null;
Mock <IGenericRepository <Product> > repositoryMock = new MockProductRepository().GetNotProductAsync();
var mockUnitOfWork = new MockUnitOfWork().ProductRepository(repositoryMock);
var productService = new ProductService(mockUnitOfWork.Object, loggerMock.Object);
//Act
try
{
await productService.GetProductsAsync();
}
catch (Exception ex)
{
exception = ex;
}
//Assert
Assert.True("No products records" == exception.Message);
}
public async Task When_Error_Move_Product_Other_Warehouse()
{
//Arrange
var loggerMock = new Mock <ILogger <MovementService> >();
Mock <IGenericRepository <Movement> > repositoryMovementMock = new MockMovementRepository().Queryable();
Mock <IGenericRepository <Product> > repositoryProductMock = new MockProductRepository()
.GetProductByIdAsync()
.UpdateProductAsync()
.Queryable();
var mockUnitOfWork = new MockUnitOfWork().MovementRepository(repositoryMovementMock)
.ProductRepository(repositoryProductMock)
.SaveChangesAsync();
var movementService = new MovementService(mockUnitOfWork.Object, loggerMock.Object);
MoveProducts moveProducts = new MoveProducts
{
Quantity = 23,
ProductId = Guid.Parse("A16C605C-0A1A-4E63-857F-68019CE2575C"),
CurrentWarehouseId = Guid.Parse("351BA5AA-C78D-4491-931A-76603D729392"),
NewWarehouseId = Guid.Parse("C347ED5D-1F33-49EE-A58D-B7F2310192A6")
};
Exception exception = null;
//Act
try
{
await movementService.MoveProductOtherWarehouse(moveProducts);
}
catch (Exception ex)
{
exception = ex;
}
//Assert
Assert.True("product not found in the selected warehouse" == exception.Message);
Assert.True(typeof(BusinessException) == exception.GetType());
}
public async Task When_Error_Threshold_Products_In_Warehouse()
{
//Arrange
var loggerMock = new Mock <ILogger <MovementService> >();
Mock <IGenericRepository <Movement> > repositoryMovementMock = new MockMovementRepository().Queryable();
Mock <IGenericRepository <Product> > repositoryProductMock = new MockProductRepository()
.GetProductByIdAsync()
.UpdateProductAsync()
.Queryable();
var mockUnitOfWork = new MockUnitOfWork().MovementRepository(repositoryMovementMock)
.ProductRepository(repositoryProductMock)
.SaveChangesAsync();
var movementService = new MovementService(mockUnitOfWork.Object, loggerMock.Object);
Movement movement = new Movement
{
Type = true,
Quantity = 11000,
ProductId = Guid.Parse("B99BC862-C515-4D61-97D8-4D2B188A19F3"),
WarehouseId = Guid.Parse("C347ED5D-1F33-49EE-A58D-B7F2310192A6")
};
Exception exception = null;
//Act
try
{
await movementService.InsertProductWareahouse(movement);
}
catch (Exception ex)
{
exception = ex;
}
//Assert
Assert.True("No more products can be loaded, as they exceed the established threshold. For logistical reasons there is no place to store them." == exception.Message);
Assert.True(typeof(BusinessException) == exception.GetType());
}
public async Task When_Error_Exceeds_Maximun_Limint_Products_In_Warehouse()
{
//Arrange
var loggerMock = new Mock <ILogger <MovementService> >();
Mock <IGenericRepository <Movement> > repositoryMovementMock = new MockMovementRepository().Queryable();
Mock <IGenericRepository <Product> > repositoryProductMock = new MockProductRepository()
.GetProductByIdAsync()
.UpdateProductAsync()
.Queryable();
var mockUnitOfWork = new MockUnitOfWork().MovementRepository(repositoryMovementMock)
.ProductRepository(repositoryProductMock)
.SaveChangesAsync();
var movementService = new MovementService(mockUnitOfWork.Object, loggerMock.Object);
Movement movement = new Movement
{
Type = true,
Quantity = 325,
ProductId = Guid.Parse("B99BC862-C515-4D61-97D8-4D2B188A19F3"),
WarehouseId = Guid.Parse("C347ED5D-1F33-49EE-A58D-B7F2310192A6")
};
Exception exception = null;
//Act
try
{
await movementService.InsertProductWareahouse(movement);
}
catch (Exception ex)
{
exception = ex;
}
//Assert
Assert.True("Only 320 units of the selected product can be loaded." == exception.Message);
Assert.True(typeof(BusinessException) == exception.GetType());
}
public void GetAllProductsTest()
{
var db = new MockProductDBContext();
var repository = new MockProductRepository(db);
var controller = new ProductsController(repository);
var expectedProducts = new List <Product>();
expectedProducts.Add(new Product()
{
Id = "0d62fd12-7ce3-4b7f-84cb-b12a417786a2", Name = "product 1", Description = "", Price = 9.99m, ImgUri = "uri"
});
expectedProducts.Add(new Product()
{
Id = "a7c7c58c-c9ae-4179-b278-d702f9c7533d", Name = "product 2", Description = "", Price = 99.99m, ImgUri = "uri"
});
var result = controller.Get() as ObjectResult;
var products = result?.Value as IEnumerable <Product>;
Assert.NotNull(products);
Assert.True(expectedProducts.SequenceEqual(products));
}
public async Task When_No_Return_Product_By_Id_Service(string id)
{
//Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
Exception exception = null;
Mock <IGenericRepository <Product> > repositoryMock = new MockProductRepository().GetProductByIdAsync();
var mockUnitOfWork = new MockUnitOfWork().ProductRepository(repositoryMock);
var productService = new ProductService(mockUnitOfWork.Object, loggerMock.Object);
//Act
try
{
await productService.GetProductByIdAsync(Guid.Parse(id));
}
catch (Exception ex)
{
exception = ex;
}
//Assert
Assert.True("Product doesn't exist" == exception.Message);
Assert.True(typeof(BusinessException) == exception.GetType());
}
public async Task When_Get_Total_Shopping_Of_Product(string id)
{
//Arrange
var loggerMock = new Mock <ILogger <MovementService> >();
Mock <IGenericRepository <Movement> > repositoryMovementMock = new MockMovementRepository().Queryable();
Mock <IGenericRepository <Product> > repositoryProductMock = new MockProductRepository()
.GetProductByIdAsync()
.UpdateProductAsync()
.Queryable();
var mockUnitOfWork = new MockUnitOfWork().MovementRepository(repositoryMovementMock)
.ProductRepository(repositoryProductMock)
.SaveChangesAsync();
var movementService = new MovementService(mockUnitOfWork.Object, loggerMock.Object);
//Act
var result = await movementService.GetTotalShoppingProduct(Guid.Parse(id));
//Assert
Assert.NotNull(result);
Assert.True(result.ShoppingQuantity.Equals(27));
Assert.True(result.TotalPriceShopping.Equals(7283.70M));
}
