public async Task DetailsReturnsARedirectToIndexWhenIdIsNotFound()
{
int testProductId = 0;
var mockService = new Mock <IProductsService>();
mockService.Setup(p => p.GetAsync(testProductId, true, true, false)).ReturnsAsync((Products)null);
var controller = new ProductsController(mockService.Object);
var result = await controller.Details(testProductId);
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirectToActionResult.ActionName);
}
public void DetailAction_InvalidID_NotFoundStatus()
{
//Arrange
ProductsController pc = new ProductsController();
int ExpectedStatusCode = new HttpStatusCodeResult(HttpStatusCode.NotFound).StatusCode;
//Act
HttpStatusCodeResult r = pc.Details(-1) as HttpStatusCodeResult;
int ActualStatusCode = r.StatusCode;
//Assert
Assert.AreEqual(ExpectedStatusCode, ActualStatusCode);
}
public void DetailAction_NullID_BadHTTPStatus()
{
//Arrange
ProductsController pc = new ProductsController();
int ExpectedHttpStatusCode = new HttpStatusCodeResult(HttpStatusCode.BadRequest).StatusCode;
//Act
HttpStatusCodeResult r = pc.Details(null) as HttpStatusCodeResult;
int ActualHttpStatusCode = r.StatusCode;
//Assert
Assert.AreEqual(ExpectedHttpStatusCode, ActualHttpStatusCode);
}
public async Task DetailsProductsController()
{
var context = GetInMemoryDbMetData();
var controller = new ProductsController(context, _hostingEnvironment);
var result = await controller.Details(products[0].Id);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <Product>(viewResult.ViewData.Model);
Assert.Equal(1, model.Id);
Assert.Equal("ProductIndex", model.Title);
Assert.NotNull(viewResult);
}
public void DetailsViewModelNotNull()
{
// Arrange
var mock = new Mock <ILocalService>();
var id = "1";
mock.Setup(a => a.GetProductById(id)).Returns(new StoreItem());
ProductsController controller = new ProductsController(mock.Object);
// Act
ViewResult result = controller.Details(id) as ViewResult;
// Assert
Assert.IsNotNull(result.Model);
}
public void Mock_GetDetails_ReturnsView()
{
//Arrange
DbSetup();
Product testProduct = new Product(9, "gummi bear", "yummy treat", 3, 2);
ProductsController controller = new ProductsController(mock.Object);
//Act
ViewResult resultView = controller.Details(testProduct.ProductId) as ViewResult;
Product model = resultView.ViewData.Model as Product;
//Assert
Assert.IsInstanceOfType(resultView, typeof(ActionResult));
}
public async Task GetProductDetails_NullPassed_NotFoundReturned()
{
var brands = Data.Brands();
var categories = Data.Categories();
var products = Data.Products();
var context = new MockProductsContext(products, brands, categories);
var controller = new ProductsController(context, null);
var result = await controller.Details(-1);
Assert.IsNotNull(result);
var productResult = result as NotFoundResult;
Assert.IsNotNull(productResult);
}
public void RepositoryThrowsException()
{
// Arrange
var testrepo = new ProductsRepository();
Exception exception = new Exception();
testrepo.ExceptionToThrow = exception;
var controller = new ProductsController(new LocalService(testrepo));
var grabsvc = new Mock <IGrabService>();
var testitem = GetTestItem();
var result = (ViewResult)controller.Details(testitem.ItemID);
Assert.AreEqual("", result.ViewName);
ModelState modelState = result.ViewData.ModelState[""];
}
public void GetProductDetails()
{
// Arrange
ProductsController controller = new ProductsController(_productService, _logManager);
// Act
ViewResult result = controller.Details("abc-jacket") as ViewResult;
// Assert
Assert.IsNotNull(result);
var model = (ProductVm)result.Model;
Assert.AreEqual(2, model.Id);
}
public async Task Detail_ReturnsNotFoundResult_WhenInvalidProductIdOrWebCompanyId()
{
// Arrange
long productId = 1000;
long webCompanyId = 1000;
IProductService productServiceFake = new ProductServiceFake();
var mockRepo = new Mock <IProductService>();
mockRepo.Setup(repo => repo.Get(productId))
.Returns(productServiceFake.Get(productId));
ProductsController productsController = new ProductsController(mockRepo.Object);
var result = await productsController.Details(productId);
var viewResult = Assert.IsType <NotFoundResult>(result);
}
public async Task Details_Returns_BadRequestResult()
{
int id = 4;
var product = GetProducts().FirstOrDefault(p => p.Id == id);
//Arrange
mock.Setup(p => p.GetByIdAsync(id)).Throws(new Exception());
controller = new ProductsController(mock.Object);
//Act
var result = await controller.Details(id);
//Assert
var badRequestResult = Assert.IsType <BadRequestResult>(result);
}
public async Task Details_ReturnsExpectedProduct()
{
// Arrange
serviceMoq.Setup(x => x.FindAsync(100)).ReturnsAsync(GetTestProduct);
ProductsController controller = new ProductsController(serviceMoq.Object);
// Act
var result = await controller.Details(100);
var viewResult = result as ViewResult;
var model = viewResult.Model as Product;
// Assert
Assert.NotNull(viewResult);
Assert.NotNull(model);
Assert.Equal(100, model.Id);
}
public void TestDetailsMethod()
{
Products product = new Products {
ProductId = 1, ProductName = "Harry Porter", Price = 10
};
//Mock IRepository of products
Mock <IRepository <Products> > mockProductsController = new Mock <IRepository <Products> >();
mockProductsController.Setup(b => b.GetByID(It.IsAny <int>())).Returns(product);
//Pass in the IRepository products
ProductsController productsController = new ProductsController(mockProductsController.Object);
ViewResult result = productsController.Details(1) as ViewResult;
Assert.AreEqual(product, result.Model);
}
public void DetailAction_Returns_ProductModel()
{
//Arrange
//ProductsController pc = new ProductsController();
ProductsController pc = new ProductsController(new ProductArrayRepository());
Type ExpectedModelType = typeof(DBModel.Product);
//Act
ViewResult r = pc.Details(3) as ViewResult;
Type ActualModelType = r.Model.GetType();
//Assert
Assert.AreEqual(ExpectedModelType, ActualModelType);
}
public void DB_EditProduct_ProductName()
{
//arrange
ProductsController controller = new ProductsController(db);
Product testProduct1 = new Product("sponge", "Sponges up liquid", (decimal)1.99);
controller.Create(testProduct1);
//act
testProduct1.Name = "better sponge";
var resultProduct = (controller.Details(testProduct1.ProductId) as ViewResult).ViewData.Model as Product;
controller.Edit(testProduct1);
//assert
Assert.AreEqual(testProduct1.Name, resultProduct.Name);
}
public async Task Details_Returns_ViewResult_ProductByID()
{
int id = 4;
var product = GetProducts().FirstOrDefault(p => p.Id == id);
//Arrange
mock.Setup(p => p.GetByIdAsync(id)).ReturnsAsync(product);
controller = new ProductsController(mock.Object);
//Act
var result = await controller.Details(id);
//Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <Product>(viewResult.ViewData.Model);
product.Should().BeEquivalentTo(model);
}
public void Mock_GetDetails_ReturnsView()
{
//arrange
Product testProduct = new Product {
ProductId = 1, Name = "Sponge", Description = "Sponges up liquids", Cost = (decimal)1.99
};
DbSetup();
ProductsController controller = new ProductsController(mock.Object);
//act
var resultView = controller.Details(testProduct.ProductId) as ViewResult;
var model = resultView.ViewData.Model as Product;
//assert
Assert.IsInstanceOfType(resultView, typeof(ViewResult));
Assert.IsInstanceOfType(model, typeof(Product));
}
public async Task Details_ReturnsHttpNotFound_ForNonexistingId()
{
// Arrange
int nonexistingId = 2;
int productId = 1;
var mockService = new Mock <IProductsService>();
mockService.Setup(srv => srv.GetByIdAsync(productId)).ReturnsAsync(new Products()
{
ProductId = productId
});
var controller = new ProductsController(mockService.Object, null, null);
// Act
var result = await controller.Details(nonexistingId);
// Assert
Assert.IsType <NotFoundResult>(result);
}
public void Mock_GetDetails_ReturnsView()
{
DbSetup();
Product testProduct = new Product
{
ProductId = 1,
Name = "Gummi Crown",
Description = "A Gummi headdress worthy of royalty.",
Cost = 9999.99m,
Image = null
};
ProductsController controller = new ProductsController(mock.Object);
var resultView = controller.Details(testProduct.ProductId) as ViewResult;
var model = resultView.ViewData.Model as ProductReview;
Assert.IsInstanceOfType(resultView, typeof(ViewResult));
Assert.IsInstanceOfType(model, typeof(ProductReview));
}
//TEST: PRODUCTS_DETAILS_TEST
//Test the functionality of the Product Details method using test data.
public void Products_Details_Test()
{
//ARRANGE
ProductsController productsController = new ProductsController();
MyDataEntities db = new MyDataEntities();
//Grab the previously created test product and find its ProductID
var array = db.Products.Where(x => x.ProductName == "testProduct").ToList();
int testProductID = 0;
foreach (var item in array)
{
testProductID = item.ProductID;
}
//ACT
ActionResult result = productsController.Details(testProductID);
//ASSERT
Assert.IsInstanceOfType(result, typeof(ViewResult));
}
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 TestDetailsShouldBeReturnProductDetailViewModel()
{
int id = 1;
ProductDetailViewModel viewModel = new ProductDetailViewModel
{
Id = 1,
Name = "Test",
NoOfUnit = 12,
ReOrderLevel = 1,
UnitPrice = 100
};
_productDetailViewModelFactory.Setup(m => m.Create(id))
.ReturnsAsync(viewModel);
var result = await _controller.Details(id) as ViewResult;
Assert.That(result.ViewData.Model.GetType(), Is.EqualTo(typeof(ProductDetailViewModel)));
Assert.That(result.ViewData.Model, Is.EqualTo(viewModel));
}
public void ProductsController_DetailModelContainsCorrectData_ReviewList()
{
//Arrange
DbSetup();
ProductsController controller = new ProductsController();
IActionResult actionResult = controller.Details(1);
ViewResult indexView = new ProductsController(productTestRepo.Object, mock.Object).Details(1) as ViewResult;
//Act
var result = indexView.ViewData.Model as Product;
//Assert
Assert.IsInstanceOfType(result.Reviews, typeof(Review[]));
}
public void Mock_GetDetails_ReturnsView()
{
// Arrange
Product testProduct = new Product
{
ProductId = 1,
Name = "Giant Gummi"
};
DbSetup();
ProductsController controller = new ProductsController(mock.Object);
// Act
var resultView = controller.Details(testProduct.ProductId) as ViewResult;
var model = resultView.ViewData.Model as Product;
// Assert
Assert.IsInstanceOfType(resultView, typeof(ViewResult));
Assert.IsInstanceOfType(model, typeof(Product));
}
public async Task Details_ReturnProductWithExistingId()
{
// Arrange
int productId = 1;
var mockService = new Mock <IProductsService>();
mockService.Setup(srv => srv.GetByIdAsync(1)).ReturnsAsync(new Products()
{
ProductId = productId
});
var controller = new ProductsController(mockService.Object, null, null);
// Act
var result = await controller.Details(productId);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <Products>(viewResult.ViewData.Model);
Assert.NotNull(model);
Assert.Equal(productId, model.ProductId);
}
public void Mock_GetDetails_ReturnsView()
{
//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.Details(testProduct.Id) as ViewResult;
var model = resultView.ViewData.Model as Product;
//Assert
Assert.IsInstanceOfType(resultView, typeof(ViewResult));
Assert.IsInstanceOfType(model, typeof(Product));
}
public void Mock_GetDetails_ReturnsView()
{
// 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.Details(testProduct.ProductId) as ViewResult;
var model = resultView.ViewData.Model as Product;
// Assert
Assert.IsInstanceOfType(resultView, typeof(ViewResult));
Assert.IsInstanceOfType(model, typeof(Product));
}
public async Task Details_GivenProductIdThatDoesNotExist_ShouldReturnNotFound()
{
// Arrange
var productServiceMock = new Mock <IProductService>();
var productIdThatDoesNotExist = 0;
productServiceMock.Setup(ps => ps.DoesProductIdExist(productIdThatDoesNotExist))
.ReturnsAsync(false);
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 = await productsController.Details(productIdThatDoesNotExist);
// Assert
actionResult.ShouldBeOfType <NotFoundResult>();
}
public void TestDetail()
{
var result = _productService.Details(null);
}
public void DetailsMissingId()
{
var result = productsController.Details(null).Result;
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
