public void ProductController_AddsProductToIndexModelData_Collection()
{
// Arrange
SetUpTheMockDb();
ProductsController controller = new ProductsController(mock.Object);
Product testProduct = new Product();
testProduct.Description = "test product";
// Act
controller.Create(testProduct);
ViewResult indexView = new ProductsController().Index() as ViewResult;
var collection = indexView.ViewData.Model as List <Product>;
// Assert
CollectionAssert.Contains(collection, testProduct);
}
public void DB_CreatesNewEntries_Collection()
{
// Arrange
ProductsController controller = new ProductsController(db);
Product testProduct = new Product();
testProduct.Name = "Test Product";
testProduct.Cost = 10;
testProduct.Description = "Test Desc";
// Act
controller.Create(testProduct);
var collection = (controller.Index() as ViewResult).ViewData.Model as List <Product>;
// Assert
CollectionAssert.Contains(collection, testProduct);
}
public async Task Create_ProductReturns_RedirectToActionResult()
{
mock = new Mock <IProducts>();
controller = new ProductsController(mock.Object);
Product newProduct = new Product
{
Name = "Bread",
Price = 15
};
var result = await controller.Create(newProduct);
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Null(redirectToActionResult.ControllerName);
Assert.Equal("Index", redirectToActionResult.ActionName);
mock.Verify(p => p.AddAsync(newProduct));
}
public void Mock_PostViewResultCreate_ViewResult()
{
// Arrange
Product testProduct = new Product
{
ProductId = 1,
Description = "Wash the dog"
};
DbSetup();
ProductsController controller = new ProductsController(mock.Object);
// Act
var resultView = controller.Create(testProduct) as ViewResult;
// Assert
Assert.IsInstanceOfType(resultView, typeof(ViewResult));
}
public async Task CreateProduct_ShouldAddProductIntoDb()
{
string name = Guid.NewGuid().ToString();
var product = new Repository.Product
{
Name = name,
Description = "DESC",
Price = 333,
DeliveryPrice = 11
};
await _productController.Create(product);
var response = await _productController.SearchByName(name);
ObjectContent content = response.Content as ObjectContent;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(name, ((List <Product>)content.Value)[0].Name);
}
public void DB_EditEntry_Test()
{
ProductsController controller = new ProductsController(db);
Product testProduct = new Product();
testProduct.Name = "Pepperoni";
testProduct.Cost = 12.75;
testProduct.Country = "USA";
controller.Create(testProduct);
testProduct.Name = "Fromage";
controller.Edit(testProduct);
var collection = (controller.Index() as ViewResult).ViewData.Model as List <Product>;
Assert.AreEqual(testProduct.Name, "Fromage");
}
public void Mock_PostViewResultCreate_ViewResult()
{
// Arrange
Product testProduct = new Product
{
ProductId = 1,
Name = "Giant Gummi"
};
DbSetup();
ProductsController controller = new ProductsController(mock.Object);
// Act
var resultView = controller.Create(testProduct) as RedirectToActionResult;
// Assert
Assert.IsInstanceOfType(resultView, typeof(RedirectToActionResult));
}
public void DB_EditsEntries_Collection()
{
ProductsController controller = new ProductsController(db);
Product testProduct = new Product();
testProduct.Name = "5 Lb. Bag (Assorted Flavors)";
testProduct.Price = 12.99m;
testProduct.Description = "Yummi Gummis!";
testProduct.ProductId = 1;
// Act
controller.Create(testProduct);
testProduct.Name = "2.5 Lb. Bag (Assorted Flavors)";
controller.Edit(testProduct);
var foundProduct = (controller.Details(testProduct.ProductId) as ViewResult).ViewData.Model as Product;
// Assert
Assert.AreEqual(foundProduct.Name, "2.5 Lb. Bag (Assorted Flavors)");
}
public async Task Create_ReturnsViewResultWithModel()
{
var product = new Product
{
Name = "Keyboard",
Description = "",
Quantity = 10,
};
var mockService = new Mock <IEntityService <Product> >();
var controller = new ProductsController(mockService.Object);
var result = await controller.Create(product); // as ViewResult;
var viewResult = Assert.IsType <RedirectToActionResult>(result);
Assert.NotNull(viewResult);
Assert.Equal(nameof(controller.Index), viewResult.ActionName);
}
public void DB_CreatesNewReviews_Collection()
{
//arrange
ReviewsController controller = new ReviewsController(db);
ProductsController otherController = new ProductsController(pdb);
Product testProduct = new Product("Sponge", "Sponges up liquids", (decimal)1.99);
Review testReview = new Review("bob", "this is a great sponge", 5);
//act
otherController.Create(testProduct);
testReview.ProductId = testProduct.ProductId;
controller.Create(testReview);
var collection = (controller.Index() as ViewResult).ViewData.Model as List <Review>;
//assert
CollectionAssert.Contains(collection, testReview);
}
public void Create_GetRequest_ReturnViewResult()
{
var mockProductService = new Mock <IProductService>();
var mockCategoryService = new Mock <ICategoryService>();
var mockCategoryProductService = new Mock <ICategoryAndProductService>();
var controller = new ProductsController(mockProductService.Object,
mockCategoryService.Object,
mockCategoryProductService.Object);
mockCategoryService.Setup(x => x.GetAllCategories()).Returns(GetCategories());
var result = controller.Create();
var vm = result as ViewResult;
var categories = ((ProductCreateEditFormViewModel)vm.ViewData.Model).Categories.ToList();
Assert.IsInstanceOfType(result, typeof(ViewResult));
Assert.AreEqual(4, categories.Count);
Assert.AreEqual(3, categories[2].Id);
}
public async Task Create_ReturnsARedirectToIndexWhenProductHasBeenCreated()
{
//Arrange
var products = new Products {
ProductId = 1
};
var mockProductsService = new Mock <IProductsService>();
mockProductsService.Setup(srv => srv.Create(products)).Returns(Task.CompletedTask);
var controller = new ProductsController(mockProductsService.Object, null, null);
// Act
var result = await controller.Create(products);
//Assert
var redirectToActionResult =
Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirectToActionResult.ActionName);
}
public void DB_EditSpecificEntry_Product()
{
ProductsController controller = new ProductsController(db);
Product testProduct = new Product
{
Name = "Gummi Couch",
Description = "Maybe not practical, but definitely possible.",
Cost = 299.99m
};
controller.Create(testProduct, null);
var collection = (controller.Index() as ViewResult).ViewData.Model as List <Product>;
Product productToEdit = (controller.Edit(collection[0].ProductId) as ViewResult).ViewData.Model as Product;
productToEdit.Description = "You'll never lose your change now.";
controller.Edit(productToEdit);
var collection2 = (controller.Index() as ViewResult).ViewData.Model as List <Product>;
Assert.AreNotEqual("Maybe not practical, but definitely possible.", collection2[0].Description);
}
public void Create_ShouldReturnViewResult()
{
// Arrange
var productServiceMock = new Mock <IProductService>();
var authorizationServiceMock = new Mock <IAuthorizationService>();
var mockUserStore = new Mock <IUserStore <IdentityUser> >();
var userManager = new Mock <UserManager <IdentityUser> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
var productsController = new ProductsController(
productServiceMock.Object,
authorizationServiceMock.Object,
userManager.Object
);
// Act
IActionResult actionResult = productsController.Create();
// Assert
actionResult.ShouldBeOfType <ViewResult>();
}
public void Create_WithValidProduct_ShouldReturnView()
{
//Arrange
bool serviceCalled = false;
var mockRepository = new Mock <IAdminCategoryService>();
var mockRepositoryProduct = new Mock <IAdminProductService>();
mockRepositoryProduct
.Setup(service => service.CreateProductAsync(It.IsAny <ProductCreationBindingModel>()))
.Callback(() => serviceCalled = true);
var controller = new ProductsController(mockRepositoryProduct.Object, mockRepository.Object);
//Act
var result = controller.Create(new ProductCreationBindingModel());
//Assert
Assert.IsTrue(serviceCalled);
}
public void DB_CreatesNewEntries_Collection()
{
// Arrange
ProductsController productController = new ProductsController(productDb);
ReviewsController reviewController = new ReviewsController(reviewDb);
Product testProduct = new Product {
ProductId = 1, Name = "Giant Gummi", Description = "12 oz. gummi bear", Cost = 4.99m, ImageUrl = "https://i.ytimg.com/vi/1CbfG0epWHo/maxresdefault.jpg"
};
Review testReview = new Review {
ReviewId = 1, Title = "Love It!", Author = "Sara", Content_Body = "This is the best gummy bear I have ever had.", Rating = 5, ProductId = 1
};
// Act
productController.Create(testProduct);
reviewController.Create(testReview);
var collection = (reviewController.Index() as ViewResult).ViewData.Model as List <Review>;
// Assert
CollectionAssert.Contains(collection, testReview);
}
public async Task CreateSuccess()
{
var productModel = new ProductModel();
var product = new Product();
var validator = new Mock <IValidator>(MockBehavior.Strict);
validator
.Setup(x => x.ValidateAsync(productModel))
.ReturnsAsync(ValidationResult.New)
.Verifiable("Validation operation not performed");
var apiLayerTranslator = new Mock <IApiLayerTranslator>(MockBehavior.Strict);
apiLayerTranslator
.Setup(x => x.Translate(productModel))
.Returns(product)
.Verifiable("Translation operation not performed");
var productsPortal = new Mock <IProductsPortal>(MockBehavior.Strict);
productsPortal
.Setup(x => x.UpsertAsync(new[] { product }))
.Returns(Task.CompletedTask)
.Verifiable("process operation not performed");
var controller = new ProductsController(
logger: _logger,
productsPortal: productsPortal.Object,
apiLayerTranslator: apiLayerTranslator.Object,
validator: validator.Object);
var result = await controller.Create(productModel);
Assert.That(result, Is.TypeOf <OkObjectResult>());
validator.VerifyAll();
apiLayerTranslator.VerifyAll();
productsPortal.VerifyAll();
}
public async Task Create_ReturnViewResult_GivenInvalidModel()
{
//Arrange
int productId = 1;
int categoriesId = 2;
int suppliersId = 3;
var mockProductsService = new Mock <IProductsService>();
var mockCategoriesService = new Mock <ICategoriesService>();
mockCategoriesService.Setup(srv => srv.GetCategoriesSelectListAsync(categoriesId))
.ReturnsAsync(new SelectList(new List <Categories> {
new Categories {
CategoryId = categoriesId
}
}));
var mockSuppliersService = new Mock <ISuppliersService>();
var controller = new ProductsController(mockProductsService.Object, mockCategoriesService.Object, mockSuppliersService.Object);
mockSuppliersService.Setup(srv => srv.GetSuppliersSelectListAsync(suppliersId))
.ReturnsAsync(new SelectList(new List <Suppliers> {
new Suppliers {
SupplierId = suppliersId
}
}));
controller.ModelState.AddModelError("error", "some error");
var products = new Products
{
ProductId = productId,
SupplierId = suppliersId,
CategoryId = categoriesId
};
// Act
var result = await controller.Create(products);
//Assert
var viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <SelectList>(viewResult.ViewData["CategoryId"]);
Assert.IsAssignableFrom <SelectList>(viewResult.ViewData["SupplierId"]);
}
public async Task Create_ReturnViewResult()
{
//Arrange
var mockProductsService = new Mock <IProductsService>();
var mockCategoriesService = new Mock <ICategoriesService>();
mockCategoriesService.Setup(srv => srv.GetCategoriesSelectListAsync(null)).ReturnsAsync(new SelectList(new List <Categories>()));
var mockSuppliersService = new Mock <ISuppliersService>();
mockSuppliersService.Setup(srv => srv.GetSuppliersSelectListAsync(null)).ReturnsAsync(new SelectList(new List <Suppliers>()));
var controller = new ProductsController(mockProductsService.Object, mockCategoriesService.Object, mockSuppliersService.Object);
// Act
var result = await controller.Create();
//Assert
var viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <SelectList>(viewResult.ViewData["CategoryId"]);
Assert.IsAssignableFrom <SelectList>(viewResult.ViewData["SupplierId"]);
}
public void CreateSaleTest()
{
// Arrange
string usersId = "test1";
string description = "A generic football";
int currentPrice = 100;
DateTime endTime = DateTime.Now.AddDays(2);
string name = "football";
int startingPrice = 50;
string location = "testlocation";
int productTypes_id = 9;
int productsId = productsController.Create(name, startingPrice, location, productTypes_id);
// Act
bool returnValue = salesController.Create(usersId, productsId, description, currentPrice, endTime);
// Assert
Assert.AreEqual(true, returnValue, "Sale created correctly");
}
public void Create_PostValidModel_RedirectsToActionIndex()
{
var mockProductService = new Mock <IProductService>();
var mockCategoryService = new Mock <ICategoryService>();
var mockCategoryProductService = new Mock <ICategoryAndProductService>();
var controller = new ProductsController(mockProductService.Object,
mockCategoryService.Object,
mockCategoryProductService.Object);
var productCreateEditFormViewModel = new ProductCreateEditFormViewModel
{
Name = "Test Product",
Description = "Test Product Description",
CategoryId = 1
};
var result = controller.Create(productCreateEditFormViewModel) as RedirectToRouteResult;
Assert.AreEqual(result.RouteValues["Action"], "Index");
}
public void Mock_PostViewResultCreate_ViewResult()
{
// Arrange
Product testProduct = new Product
{
ProductId = 1,
Name = "1lb Gummy Bear",
Cost = 10,
Description = "BIG OLE BEAR"
};
DbSetup();
ProductsController controller = new ProductsController(mock.Object);
// Act
var resultView = controller.Create(testProduct);
// Assert
Assert.IsInstanceOfType(resultView, typeof(RedirectToActionResult));
}
public void Create()
{
// Arrange
ProductsController controller = new ProductsController();
Product product = new Product()
{
Id = 10,
Name = "Shoes",
Category = "Common",
Price = 1000,
Quantity = 1,
Short_desc = "Shoes",
Small_img = "image"
};
// Act
ViewResult result = controller.Create(product, null, null) as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void Mock_PostViewResultCreate_ViewResult()
{
//Arrange
Product testProduct = new Product
{
Id = 1,
Cost = 10,
Description = "Dummy Bear shaped lollipop with rainbow sprinkles",
Name = "Dummy Bear Pop"
};
DbSetup();
ProductsController controller = new ProductsController(mock.Object);
//Act
var resultView = controller.Create(testProduct) as ViewResult;
//Assert
Assert.IsInstanceOfType(resultView, typeof(ViewResult));
}
public void Test_ProductsController_Create_CallsAddOrUpdate()
{
// Arrange
Mock <IProductRepository> mockProductRepo = new Mock <IProductRepository>();
ProductsController controller = new ProductsController(mockProductRepo.Object);
Product p = new Product
{
Title = "Blueberry Cookie",
Description = "100 grams of delicious crunchyness!!!",
ImgUrl = "Content/img/products/12.jpg",
Price = 20,
StockCount = 253
};
// Act
controller.Create(p);
// Assert
mockProductRepo.Verify(mock => mock.AddOrUpdate(p));
}
public void Mock_PostViewResultCreate_ViewResult()
{
// Arrange
Product testProduct = new Product
{
ProductId = 1,
Name = "5 Lb. Bag (Assorted Flavors)",
Price = 12.99m,
Description = "Yummi Gummis!"
};
DbSetup();
ProductsController controller = new ProductsController(mock.Object);
// Act
var resultView = controller.Create(testProduct) as ViewResult;
// Assert
Assert.IsInstanceOfType(resultView, typeof(ViewResult));
}
public void DB_CreateNewEntryPOST_Test()
{
//Arange
var productController = new ProductsController(db);
var testProduct = new Product()
{
Name = "Kitfo",
Cost = 10,
CountryOfOrigin = "Ethiopia",
ProductImg = null
};
//Act
productController.Create(testProduct);
var indexViewResult = productController.Index() as ViewResult;
var collection = indexViewResult.ViewData.Model as List <Product>;
//Assert
CollectionAssert.Contains(collection, testProduct);
}
public void DB_CreateNewEntry_Test()
{
//Arrange
ReviewsController controller = new ReviewsController(db);
ProductsController productsController = new ProductsController(db2);
Product testProduct = new Product()
{
ProductId = 1, Name = "Linguine", Cost = 3.00, CountryOfOrigin = "Italy"
};
Review testReview = new Review()
{
Author = "Kaili", ContentBody = "We enjoyed this pasta. It cooked quickly and evenly.", Rating = 5, ProductId = 1
};
controller.Create(testReview);
productsController.Create(testProduct);
var collection = (controller.Index() as ViewResult).ViewData.Model as List <Review>;
//Assert
CollectionAssert.Contains(collection, testReview);
}
public void Mock_PostViewResultCreate_ViewResult()
{
// Arrange
Product testProduct = new Product
{
//ProductId = 1,
Name = "Gummies",
Cost = 20,
Description = "Best Buy"
};
DbSetup();
ProductsController controller = new ProductsController(db);
// Act
var redirectToActionResult = controller.Create(testProduct) as RedirectToActionResult;
// Assert
Assert.IsInstanceOfType(redirectToActionResult, typeof(RedirectToActionResult));
}
private void CreateReview()
{
var productController = new ProductsController(dbp);
var reviewController = new ReviewsController(db);
var testProduct = new Product()
{
Name = "Kitfo",
Cost = 10,
CountryOfOrigin = "Ethiopia",
ProductImg = null
};
productController.Create(testProduct, null);
var productId = dbp.Products.ToList()[0].ProductId;
var testReview = new Review()
{
Author = "Mike", ContentBody = "Awesome", Rating = "4", ProductId = productId
};
reviewController.Create(testReview, null);
}
