public async void DeleteConfirmed_ActionExecutes_ReturnRedirectToIndexAction(int productid) { var result = await _controller.DeleteConfirmed(productid); Assert.IsType <RedirectToActionResult>(result); }
public async void DeletePOST_ActionExecutes_ReturnRedirectToIndexPage(int Id) { var result = await _controller.DeleteConfirmed(Id); var redirectResult = Assert.IsType <RedirectToActionResult>(result); Assert.Equal("Index", redirectResult.ActionName); }
public async void DeleteConfirmed_ActionExecute_ReturnRedirectToActionIndex(int productId) { var result = await _controller.DeleteConfirmed(productId); var viewResult = Assert.IsType <RedirectToActionResult>(result); Assert.Equal("Index", viewResult.ActionName); }
public void DeleteConfirmedSuccess() { var id = 1; var result = controller.DeleteConfirmed(id); // valid ID var product = _context.Products.Find(id); Assert.AreEqual(product, null); }
public async void DeleteConfirmed_ActionExecutes_ReturnRedirectToActionResult(int id) { _mockRepository.Setup(x => x.GetById(id)).ReturnsAsync(products.First(x => x.Id == id)); var result = await _controller.DeleteConfirmed(id); var redToAction = Assert.IsType <RedirectToActionResult>(result); Assert.Equal("Index", redToAction.ActionName); }
public async Task DeleteConfirmed_ReturnsRedirectToIndex() { //Arrange int productId = 1; var products = new Products { ProductId = productId }; var mockService = new Mock <IProductsService>(); mockService.Setup(srv => srv.GetByIdAsync(productId)).ReturnsAsync(new Products() { ProductId = productId }); mockService.Setup(srv => srv.Delete(productId)).Returns(Task.CompletedTask); var controller = new ProductsController(mockService.Object, null, null); // Act var result = await controller.DeleteConfirmed(productId); //Assert var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result); Assert.Equal("Index", redirectToActionResult.ActionName); }
public void DB_DeletesSpecificEntry_Collection() { ProductsController controller = new ProductsController(db); Product testProduct = new Product { Name = "Gummi Couch", Description = "Maybe not practical, but definitely possible.", Cost = 299.99m }; Product testProduct2 = new Product { Name = "Gummi Dignity", Description = "Dignity is hard to preserve sometimes, but when it's gummi maybe it's more resilent and tasty.", Cost = 19.99m }; controller.Create(testProduct, null); controller.Create(testProduct2, null); var collection = (controller.Index() as ViewResult).ViewData.Model as List <Product>; controller.DeleteConfirmed(collection[0].ProductId); var collection2 = (controller.Index() as ViewResult).ViewData.Model as List <Product>; CollectionAssert.DoesNotContain(collection2, testProduct); }
public async Task SoftDeleteProduct_Valid_ActiveIsFalse() { 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.DeleteConfirmed(1); var resultContent = context.GetProductAsync(1).Result; var expectedResult = products.FirstOrDefault(p => p.Id == 1); if (expectedResult != null) { expectedResult.Active = false; } Assert.IsNotNull(expectedResult); Assert.IsNotNull(result); var productResult = result as RedirectToActionResult; Assert.IsNotNull(productResult); Assert.AreEqual(expectedResult.Id, resultContent.Id); Assert.AreEqual(expectedResult.Name, resultContent.Name); Assert.AreEqual(expectedResult.Active, resultContent.Active); Assert.AreEqual(expectedResult.BrandId, resultContent.BrandId); Assert.AreEqual(expectedResult.CategoryId, resultContent.CategoryId); Assert.AreEqual(expectedResult.Description, resultContent.Description); }
public void DeleteConfirmedValidId() { var result = controller.DeleteConfirmed(87).Result; var redirectResult = (RedirectToActionResult)result; Assert.AreEqual("Index", redirectResult.ActionName); }
public void DeleteConfirmedNull() { var obj = new ProductsController(); var actResult = obj.DeleteConfirmed(700) as RedirectToRouteResult; Assert.AreEqual("Index", actResult.RouteValues["action"]); }
public void DeleteProduct_DeleteProductFromCollection() { //Arrange DbSetup(); ProductsController controller = new ProductsController(mock.Object); Product testProduct = new Product { Id = 1, Cost = 10, Description = "Dummy Bear shaped lollipop with rainbow sprinkles", Name = "Dummy Bear Pop" }; Product testProduct2 = new Product { Id = 2, Cost = 100, Description = "Contains all magic spells from the CareBears, including the Care Bear stare", Name = "Care Bear Spellbook" }; //Act controller.Create(testProduct); controller.Create(testProduct2); var collection = (controller.Index() as ViewResult).ViewData.Model as List <Product>; controller.DeleteConfirmed(collection[0].Id); var collection2 = (controller.Index() as ViewResult).ViewData.Model as List <Product>; //Assert CollectionAssert.DoesNotContain(collection2, testProduct); }
public void DeleteConfirmed() { ProductsController controller = new ProductsController(_mockSupRepository.Object, _mockProdRepository.Object); RedirectToRouteResult redirect = controller.DeleteConfirmed(1) as RedirectToRouteResult; Assert.IsNotNull(redirect); Assert.AreEqual("Index", redirect.RouteValues["action"]); }
public async void Should_DeleteConfirmAction_Returns_RedirectToIndex(int productId) { _mockRepo.Setup(x => x.GetEntity(productId)).Returns(Task.FromResult(products.FirstOrDefault(x => x.Id == productId))); _mockRepo.Setup(x => x.Delete(products.FirstOrDefault(x => x.Id == productId))); var result = await controller.DeleteConfirmed(productId); Assert.IsType <RedirectToActionResult>(result); }
public void Mock_GetViewResultDeletePost_ActionResult() // Confirms route returns view { DbSetup(); Product product = new Product { ProductId = 3, Name = "Test 3", Description = "Its one more test", Cost = 6 }; ProductsController controller = new ProductsController(mock.Object); var result = controller.DeleteConfirmed(2); Assert.IsInstanceOfType(result, typeof(RedirectToActionResult)); }
public async Task DeleteProductController() { DatabaseContext context = GetInMemoryDbMetData(); var controller = new ProductsController(context, _hostingEnvironment); var result = await controller.DeleteConfirmed(products[1].Id); var viewResult = Assert.IsType <RedirectToActionResult>(result); Assert.Equal("Index", viewResult.ActionName); }
public void DeleteComfirmedPOST_ActionExecute_ReturnRedirectToActionIndex(int id) { _productRepositoryMock.Setup(p => p.GetById(id)).Returns(Product); _productRepositoryMock.Setup(p => p.Delete(Product)); IActionResult actionResult = _productsController.DeleteConfirmed(id); _productRepositoryMock.Verify(p => p.Delete(It.IsAny <Product>()), Times.Once); //1 kere çalışması lazım. var redirectToActionResult = Assert.IsType <RedirectToActionResult>(actionResult); Assert.Equal("Index", redirectToActionResult.ActionName); }
public void DB_DeleteEntry_Test() { ProductsController controller = new ProductsController(db); Product cherries = new Product("Cherries", 1.00, "USA"); Product tomatoes = new Product("Tomatoes", 1.00, "USA"); controller.Create(cherries); controller.Create(tomatoes); controller.DeleteConfirmed(cherries.ProductId); var collection = (controller.Index() as ViewResult).ViewData.Model as List <Product>; Assert.AreEqual(tomatoes.Name, collection[0].Name); }
public async Task DeletePOST_Returns_ProductInfoForDeleting() { int id = 4; var product = GetProducts().FirstOrDefault(p => p.Id == id); //Arrange mock.Setup(p => p.DeleteAsync(product.Id)).Throws(new Exception()); controller = new ProductsController(mock.Object); //Act var result = await controller.DeleteConfirmed(product.Id); //Assert var viewResult = Assert.IsType <ViewResult>(result); }
public async Task DeleteProductInvalid() { var context = MockContext.GetContext("test8"); context.Seed(); var controller = new ProductsController(_userManager, _signInManager, context); //await controller.Delete(product.Id); await controller.DeleteConfirmed(10); var plants = context.Products; var count = plants.Count(); Assert.Equal(2, count); }
public void TestDeleteConfirmedMethod() { Products products = 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.Delete(It.IsAny <int>())); //Pass in the IRepository products ProductsController productsController = new ProductsController(mockProductsController.Object); var result = productsController.DeleteConfirmed(1) as RedirectToRouteResult; Assert.AreEqual(result.RouteValues["action"], "Index"); }
public void DB_DeleteConfirmedEntryPOST_Test() { CreateProduct(); //Arange var productController = new ProductsController(db); int productId = db.Products.ToList()[0].ProductId; var viewResult = productController.Delete(productId) as ViewResult; var productToDelete = viewResult.ViewData.Model as Product; //Act productController.DeleteConfirmed(productId); var indexViewResult = productController.Index() as ViewResult; var collection = indexViewResult.ViewData.Model as List <Product>; //Assert CollectionAssert.DoesNotContain(collection, productToDelete); }
public async Task DeletePost_ReturnsARedirectAndDeleteProduct() { // Arrange _mockService .MockGetByIdAsync(_testProductId, _testProduct) .MockDeleteAsync(_testProductId); // Act var result = await _controller.DeleteConfirmed(_testProductId); // Assert var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result); Assert.Null(redirectToActionResult.ControllerName); Assert.Equal("Index", redirectToActionResult.ActionName); _mockService.Verify(); _mockService.VerifyDeleteAsync(Times.Once); }
public async Task DeletePOST_Returns_RedirectToActionResult() { int id = 4; var product = GetProducts().FirstOrDefault(p => p.Id == id); //Arrange mock.Setup(p => p.DeleteAsync(product.Id)); controller = new ProductsController(mock.Object); //Act var result = await controller.DeleteConfirmed(product.Id); //Assert var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result); Assert.Null(redirectToActionResult.ControllerName); Assert.Equal("Index", redirectToActionResult.ActionName); mock.Verify(p => p.DeleteAsync(product.Id)); }
public void TestDeleteP() { var db = new CS4PEntities(); var product = db.Products.AsNoTracking().First(); var controller = new ProductsController(); var context = new Mock <HttpContextBase>(); var server = new Mock <HttpServerUtilityBase>(); context.Setup(c => c.Server).Returns(server.Object); controller.ControllerContext = new ControllerContext(context.Object, new System.Web.Routing.RouteData(), controller); var filePath = String.Empty; var tempDir = System.IO.Path.GetTempFileName(); server.Setup(s => s.MapPath(It.IsAny <string>())).Returns <string>(s => { filePath = s; return(tempDir); }); using (var scope = new TransactionScope()) { System.IO.File.Delete(tempDir); System.IO.Directory.CreateDirectory(tempDir); tempDir = tempDir + "/"; System.IO.File.Create(tempDir + product.id).Close(); Assert.IsTrue(System.IO.File.Exists(tempDir + product.id)); var result = controller.DeleteConfirmed(product.id) as RedirectToRouteResult; Assert.IsNotNull(result); Assert.AreEqual("Index", result.RouteValues["action"]); var entity = db.Products.Find(product.id); Assert.IsNull(entity); Assert.AreEqual("~/Upload/Products/", filePath); Assert.IsFalse(System.IO.File.Exists(tempDir + product.id)); } }
public async Task Delete_ReturnsNotFoundResult() { var product = new Product { Id = Guid.NewGuid(), Name = "Keyboard", Description = "", Quantity = 10, Enable = true }; var mockService = new Mock <IEntityService <Product> >(); var controller = new ProductsController(mockService.Object); var result = await controller.DeleteConfirmed(product.Id); // as ViewResult; var viewResult = Assert.IsType <NotFoundResult>(result); Assert.NotNull(viewResult); Assert.Equal(404, viewResult.StatusCode); }
public void DB_DeleteProduct_Collection() { //arrange ProductsController controller = new ProductsController(db); Product testProduct1 = new Product("sponge", "Sponges up liquid", (decimal)1.99); Product testProduct2 = new Product("many sponges", "Sponges up liquid", (decimal)5.00); controller.Create(testProduct1); controller.Create(testProduct2); //act List <Product> result = new List <Product> { testProduct1 }; controller.DeleteConfirmed(testProduct2.ProductId); var collection = (controller.Index() as ViewResult).ViewData.Model as List <Product>; //assert CollectionAssert.AreEqual(collection, result); }
public async Task SoftDeleteProduct_OutOfBounds_NoChange() { 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 unchangedResult = context.GetAll().Result.ToList(); var result = await controller.DeleteConfirmed(outOfBoundsId); var resultContent = context.GetAll().Result.ToList(); Assert.AreEqual(unchangedResult.Count, resultContent.Count); Assert.IsNotNull(result); var productResult = result as RedirectToActionResult; Assert.IsNotNull(productResult); CollectionAssert.AreEqual(unchangedResult, resultContent); }
public async void CanDelete() { var options = new DbContextOptionsBuilder <ProductDbContext>() .UseInMemoryDatabase(databaseName: "testDb") .Options; var builder = new ConfigurationBuilder().AddEnvironmentVariables(); builder.AddUserSecrets <Startup>(); var configuration = builder.Build(); using (var context = new ProductDbContext(options)) { context.Products.AddRange( new Product { Name = "Fighter Gear", Description = "All you need", Cost = 10.99m, Url = "http://placehold.it/300x300" }, new Product { Name = "Rogue Gear", Description = "All you need", Cost = 10.99m, Url = "http://placehold.it/300x300" }, new Product { Name = "Ranger Gear", Description = "All you need", Cost = 10.99m, Url = "http://placehold.it/300x300" }, new Product { Name = "Wizard Gear", Description = "All you need", Cost = 10.99m, Url = "http://placehold.it/300x300" } ); context.SaveChanges(); var controller = new ProductsController(context); var result = await controller.DeleteConfirmed(1); var product = await context.Products .SingleOrDefaultAsync(m => m.Id == 1); Assert.DoesNotContain <Product>(product, context.Products.ToListAsync().Result); } }
public void DB_PostDeleteProduct_Product() { //Arrange ProductsController controller = new ProductsController(db); Product testProduct1 = new Product(4, "plummi beer", "beer made of plums", 3, 2); testProduct1.Reviews = new List <Review>(); controller.Create(testProduct1); Product testProduct2 = new Product(5, "gummi bear", "yummy treat", 3, 2); controller.Create(testProduct2); //Act var result = controller.DeleteConfirmed(testProduct1.ProductId) as RedirectToActionResult; var indexView = controller.Index() as ViewResult; List <Product> collection = indexView.ViewData.Model as List <Product>; //Assert Assert.AreEqual(5, collection[0].ProductId); Assert.IsInstanceOfType(result, typeof(RedirectToActionResult)); }
public void DeleteConfirmedPostRedirect() { RedirectToRouteResult result = pc.DeleteConfirmed(0) as RedirectToRouteResult; Assert.AreEqual("Index", result.RouteValues["action"]); }