public void Can_Delete_Valid_Products()
        {
            // Arrange - create a Product
            Product prod = new Product { ProductID = 2, Name = "Test" };

            // Arrange - create the mock repository
            Mock<IProductRepository> mock = new Mock<IProductRepository>();
            mock.Setup(m => m.Products).Returns(
                new Product[] {
                    new Product {ProductID = 1, Name = "P1"},
                    prod,
                    new Product {ProductID = 3, Name = "P3"},
                }
            );

            // Arrange - create the controller
            AdminController target = new AdminController(mock.Object);

            // Act - delete the product
            target.Delete(prod.ProductID);

            // Assert - ensure that the repository delete method was
            // called with the correct Product
            mock.Verify(m => m.DeleteProduct(prod.ProductID));
        }

        public void Cannot_Save_Invalid_Changes()
        {
            // Arrange
            // - Create a mock repository
            Mock<IProductRepository> mock = new Mock<IProductRepository>();

            // Arrange
            // - Crete the controller
            AdminController target = new AdminController(mock.Object);

            // Arrange
            // - Create a product
            Product product = new Product { Name = "Test" };

            // Arrange
            // - Add an error to the model state
            target.ModelState.AddModelError("error", "error");

            // Act
            // - Try to save the product
            ActionResult result = target.Edit(product, null);

            // Assert
            // - Check that the repository was not called
            mock.Verify(m => m.SaveProduct(It.IsAny<Product>()), Times.Never());

            // Assert
            // - Check the method result type
            Assert.IsInstanceOfType(result, typeof(ViewResult));
        }

        public void Can_Edit_Product()
        {
            Mock<IProductRepository> mock = new Mock<IProductRepository>();
            mock.Setup(m => m.Products).Returns(new[]
                {
                    new Product{ProductId = 1, Name = "P1"},
                    new Product{ProductId = 2, Name = "P2"},
                    new Product{ProductId = 3, Name = "P3"}
                }.AsQueryable());

            AdminController target = new AdminController(mock.Object);

            var p1 = target.Edit(1).ViewData.Model as Product;
            var p2 = target.Edit(2).ViewData.Model as Product;
            var p3 = target.Edit(3).ViewData.Model as Product;

            target = new AdminController(mock.Object);
            var p4 = (Product)target.Edit(4).ViewData.Model;

            Assert.AreEqual(1, p1.ProductId);
            Assert.AreEqual(2, p2.ProductId);
            Assert.AreEqual(3, p3.ProductId);

            Assert.IsNull(p4);
        }

        public void Delete_product_called_with_right_parameters()
        {
            var mock = CreateRepositoryMock();
            var controller = new AdminController(mock.Object);

            controller.Delete(2);

            mock.Verify(m => m.Delete(2));
        }

        public void Index_contains_all_products()
        {
            var controller = new AdminController(CreateRepositoryMock().Object);

            var result = ((IEnumerable<Product>)controller.Index().ViewData.Model).ToArray();

            Assert.AreEqual(3, result.Length);
            Assert.AreEqual("P1", result[0].Name);
        }

 public void Can_Save_Valid_Changed()
 {
     var mock = new Mock<IProductRepository>();
     var target = new AdminController(mock.Object);
     var product = new Product {Name = "test"};
     var result = target.Edit(product);
     mock.Verify(m => m.SaveProduct(product));
     Assert.IsNotInstanceOfType(result, typeof(ViewResult));
 }

 public void Cannot_Save_Invalid_Changes()
 {
     Mock<IProductRepository> mock = new Mock<IProductRepository>();
     AdminController target = new AdminController(mock.Object);
     Product product = new Product{Name = "Test"};
     target.ModelState.AddModelError("error", "error");
     ActionResult result = target.Edit(product);
     mock.Verify(m => m.SaveProduct(It.IsAny<Product>()), Times.Never);
     Assert.IsInstanceOfType(result, typeof(ViewResult));
 }

        public void Can_Save_Valid_Changes()
        {
            Mock<IProductRepository> mock = new Mock<IProductRepository>();
            AdminController target = new AdminController(mock.Object);
            Product prod = new Product() { Name = "Test" };

            ActionResult res = target.Edit(prod);

            mock.Verify(m => m.SaveProduct(prod));
            Assert.IsNotInstanceOfType(res, typeof(ViewResult));
        }

        public void Cannot_Edit_NonExistent_Product()
        {
            // arrange
            var mock = InitializeMock();

            // arrange
            AdminController target = new AdminController(mock.Object);

            Product result = target.Edit(4).ViewData.Model as Product;

            Assert.IsNull(result);
        }

        public void Can_edit_product()
        {
            var mock = new Mock<IProductRepository>();
            var controller = new AdminController(mock.Object);

            var product = new Product { Name = "Test" };

            var result = controller.Edit(product, null);
            mock.Verify(m => m.Save(product));

            Assert.IsNotInstanceOfType(result, typeof(ViewResult));
        }

 public void Cannot_Edit_Nonexistent_Product()
 {
     var mock = new Mock<IProductRepository>();
     mock.Setup(x => x.Products).Returns(new List<Product>
     {
         new Product {Name = "P1", ProductId = 1, Category = "Apples"},
         new Product {Name = "P2", ProductId = 2, Category = "Apples"},
         new Product {Name = "P3", ProductId = 3, Category = "Plum"},
     });
     var target = new AdminController(mock.Object);
     var product = target.Edit(4).ViewData.Model as Product;
     Assert.IsNull(product);
 }

        public void AjaxDelete_PassesProductIdToRepositoryRemoveMethod_DeletesProduct()
        {
            // Arrange
            Mock<IProductRepository> mock = new Mock<IProductRepository>();

            AdminController target = new AdminController(mock.Object);

            // Act
            var result = target.AjaxDelete(new Product{ProductID = 3});

            // Assert
            mock.Verify(m => m.RemoveProduct(3), Times.Once());
        }

        public void Can_Access_Product_Editing_Screen()
        {
            // Arrange: Repository that can return any IQueryable<Product>
            var testProducts = new[] { new Product { ProductId = 12 }, new Product { ProductId = 17 } };
            var mockRepository = UnitTestHelpers.MockProductsRepository(testProducts);

            // Act
            var result = new AdminController(mockRepository).Edit(17);

            // Assert
            result.ShouldBeDefaultView();
            ((Product)result.ViewData.Model).ProductId.ShouldEqual(17);
        }

        public void Cannot_save_invalid_changes()
        {
            var mock = new Mock<IProductRepository>();
            var controller = new AdminController(mock.Object);
            var product = new Product { Name = "Test" };

            controller.ModelState.AddModelError("error", "error");

            var result = controller.Edit(product, null);
            mock.Verify(m => m.Save(product), Times.Never());

            Assert.IsInstanceOfType(result, typeof(ViewResult));
        }

        public void Can_Edit_Nonexistint_Product()
        {
            Mock<IProductRepository> mock = new Mock<IProductRepository>();
            mock.Setup(m => m.Products).Returns(new Product[]{
            new Product{ProductID=1,Name="p1"},
            new Product{ProductID=2,Name="p2"},
            new Product{ProductID=3,Name="p3"},
            }.AsQueryable());
            AdminController target = new AdminController(mock.Object);

            Product result = target.Edit(4).ViewData.Model as Product;
            Assert.IsNull(result);
        }

        public void AdminController_IndexAction_Retuns_Products()
        {
            //Arrange
            Mock<IProductRepository> mock = new Mock<IProductRepository>();
            mock.Setup(m => m.Products).Returns(products.AsQueryable());
            AdminController target = new AdminController(mock.Object);

            //Act
            Product[] result = ((IEnumerable<Product>)target.Index().Model).ToArray();

            //Assert
            Assert.AreEqual(6, result.Length);
            Assert.AreEqual(1, result[0].ProductID);
        }

        public void Cant_Edit_NonExistent_Product()
        {
            //Arrange
            Mock<IProductRepository> mock = new Mock<IProductRepository>();
            mock.Setup(m => m.Products).Returns(products.AsQueryable());

            AdminController target = new AdminController(mock.Object);

            //Act
            Product result = target.Edit(8).Model as Product;

            //Assert
            Assert.IsNull(result);
        }

        public void Can_Delete_Product()
        {
            var mockRepository = new Mock<IProductsRepository>();
            var product = new Product {ProductId = 24, Name = "P24"};

            mockRepository.Setup(x => x.Products).Returns(new[] {product}.AsQueryable());

            var controller = new AdminController(mockRepository.Object);
            var result = controller.Delete(24);

            mockRepository.Verify(x=>x.DeleteProduct(product));
            result.ShouldBeRedirectionTo(new {action = "Index"});
            controller.TempData["message"].ShouldEqual("P24 was deleted");
        }

        public void Cannot_Edit_Nonexistent_Product()
        {
            Mock<IProductRepository> mock = new Mock<IProductRepository>();
            mock.Setup(m => m.Products).Returns(new Product[] { new Product { ProductID= 1, Name="P1"},
                                                                new Product { ProductID= 2, Name="P2"},
                                                                new Product { ProductID= 3, Name="P3"}
            });

            AdminController target = new AdminController(mock.Object);

            Product result = (Product)target.Edit(4).ViewData.Model;

            Assert.IsNull(result);
        }

        public void CannotEditNonExistentProduct()
        {
            Mock<IProductRepository> mock = new Mock<IProductRepository>();
            mock.Setup(m => m.Products).Returns(new[]
            {
                new Product {ProductID = 1, Name = "P1"},
                new Product {ProductID = 2, Name = "P2"},
                new Product {ProductID = 3, Name = "P3"}
            });
            var target = new AdminController(mock.Object);

            var result = target.Edit(4).ViewData.Model as Product;

            Assert.IsNull(result);
        }