public void TestSetup()
{
controller = new ProductsController();
controller.Task = new MainTask();
controller.Task.Navigator = new StubNavigator();
controller.Task.Navigator.Task = controller.Task;
}
public void AddToControllerHttpRequestWithHttpMethod()
{
var httpMethod = "httpMethod";
var controller = new ProductsController ();
var controllerResult = new Builder ()
.WithHttpMethod (httpMethod)
.AddTo (controller);
controllerResult.Request.HttpMethod.Should ().Be (httpMethod);
}
public void PutProduct_ShouldFail_WhenDifferentID()
{
// arrange
var controller = new ProductsController(new TestStoreAppContext());
// act
var badresult = controller.PutProduct(999, this.GetDemoProduct());
// assert
Assert.IsType(typeof(BadRequestResult), badresult);
}
public void AddToControllerHttpRequestWithContentType()
{
var contentType = "Content-Type";
var controller = new ProductsController ();
var controllerResult = new Builder ()
.WithContentType (contentType)
.AddTo (controller);
controllerResult.Request.ContentType.Should ().Be (contentType);
}
public void AddToControllerHttpRequestWithHeader()
{
var header = "header";
var headerValue = "headerValue";
var controller = new ProductsController ();
var controllerResult = new Builder ()
.WithHeader (header, headerValue)
.AddTo (controller);
controllerResult.Request.Headers [header].Should ().Be (headerValue);
}
public void PostProduct_ShouldReturnSameProduct()
{
// arrange
var controller = new ProductsController(new TestStoreAppContext());
var item = this.GetDemoProduct();
// act
var result = controller.PostProduct(item) as CreatedAtRouteNegotiatedContentResult<Product>;
// assert
Assert.Equal(result.RouteName, "DefaultApi");
Assert.Equal(result.RouteValues["id"], item.Id);
Assert.Equal(result.Content.Name, item.Name);
}
public void GetProduct_ShouldReturnProductWithSameID()
{
// arrange
var context = new TestStoreAppContext();
context.Products.Add(this.GetDemoProduct());
var controller = new ProductsController(context);
// act
var result = controller.GetProduct(3) as OkNegotiatedContentResult<Product>;
// assert
Assert.Equal(3, result.Content.Id);
}
public void DeleteProduct_ShouldReturnOK()
{
// arrange
var context = new TestStoreAppContext();
var item = this.GetDemoProduct();
context.Products.Add(item);
var controller = new ProductsController(context);
// act
var result = controller.DeleteProduct(3) as OkNegotiatedContentResult<Product>;
// assert
Assert.Equal(item.Id, result.Content.Id);
}
public void GetProducts_ShouldReturnAllProducts()
{
// arrange
var context = new TestStoreAppContext();
context.Products.Add(new Product { Id = 1, Name = "Demo1", Price = 20 });
context.Products.Add(new Product { Id = 2, Name = "Demo2", Price = 30 });
context.Products.Add(new Product { Id = 3, Name = "Demo3", Price = 40 });
var controller = new ProductsController(context);
// act
var result = controller.GetProducts() as TestProductDbSet;
// assert
Assert.Equal(3, result.Local.Count);
}
public void PutProductTest()
{
Guid productId = Guid.NewGuid();
ProductDto product = new ProductDto {
Id = productId, Name = "Samsung Galaxy", Description = "mobile", Price = 199.99M, DeliveryPrice = 11.11M
};
var productsService = new Mock <IProductsService>();
productsService
.Setup(repo => repo.UpdateProduct(new ProductDoDtoConverter().ToDO(product)));
ProductsController productsController = new ProductsController(productsService.Object, Mock.Of <ILogger <ProductsController> >());
ActionResult result = productsController.PutProduct(productId, product);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(NoContentResult));
}
public async Task Put()
{
// Arrange
ProductsController controller = new ProductsController();
Product p = new Product {
ProductId = new Guid("7F80C7E9-FC41-4FB2-87FB-099081182FBC"), Price = 34.00M, ProductName = "TestProduct"
};
IHttpActionResult res = await controller.PutProduct(new Guid("7F80C7E9-FC41-4FB2-87FB-099081182FBC"), p);
Assert.IsNotNull(res);
// Assert
}
public async Task TestPatchtProductAsync()
{
//Arange
var dbContext = DbContextMocker.GetProductContext(nameof(TestPatchtProductAsync));
ProductsController controller = new ProductsController(dbContext);
ProductDescription description = new ProductDescription()
{
Description = "UnitTest"
};
//Act
var response = await controller.PatchProductAsync(1, description);
//Assert
dbContext.Dispose();
Assert.True(response is NoContentResult);
}
public void CreateGood()
{
var obj = new ProductsController();
Product aux = new Product();
aux.ProductName = "Test CreateController";
aux.Stock = 5;
aux.UnitPrice = 10.0M;
aux.Estado = true;
aux.Perecible = true;
aux.DueDate = DateTime.Parse("2003-09-01");
aux.Description = "Test Description";
var actResult = obj.Create(aux) as RedirectToRouteResult;
Assert.AreEqual("Index", actResult.RouteValues["action"]);
}
public void Delete_Product_Returns_NoContentStatusCode()
{
// Arrange
mockProductService.Setup(c => c.Delete(It.IsAny <Product>()));
ProductsController controller = new ProductsController(mockProductService.Object)
{
Request = new HttpRequestMessage()
{
Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } }
}
};
// Act
var response = controller.Delete(_productId1);
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
public void Post()
{
// Arrange
ProductsController controller = new ProductsController();
string uniqueName = new Random().Next(int.MinValue, int.MaxValue).ToString();
Product newProduct = new Product {
Name = "TEST - " + uniqueName, ProductNumber = uniqueName, StandardCost = 1, ListPrice = 9, SellStartDate = DateTime.UtcNow, rowguid = Guid.NewGuid(), ModifiedDate = DateTime.UtcNow
};
// Act
IHttpActionResult result = controller.Post(newProduct);
System.Web.Http.OData.Results.CreatedODataResult <Product> odataResult = (System.Web.Http.OData.Results.CreatedODataResult <Product>)result;
_productID = odataResult.Entity.ProductID;
// Assert
}
public void Delete_BadRequest()
{
// Prepare the mock
var mockRepository = new Mock <IProduct>();
mockRepository.Setup(x => x.DeleteProduct(1))
.Throws(new System.Exception());
var controller = new ProductsController(mockRepository.Object);
// Make the request
var response = controller.Delete(1) as ObjectResult;
// Validate the response
Assert.Equal((int)HttpStatusCode.BadRequest, response.StatusCode);
Assert.NotNull(response);
Assert.NotNull(response.Value);
}
public async Task PagingRecordsTest()
{
// Arrange
const int pageSize = 6;
IProductRepository mockRepo = new MockProductRepository();
var mockDownloadTimesApi = Substitute.For <IDownloadTimesApi>();
var mockProductTypesApi = Substitute.For <IProductTypesApi>();
var mockManufacturersApi = Substitute.For <IManufacturersApi>();
var mockInstallTypesApi = Substitute.For <IInstallTypesApi>();
var mockMobileLookupApi = Substitute.For <IMobileLookupApi>();
var mockBrandApi = Substitute.For <IBrandApi>();
IDistributedCache mockCache = Substitute.For <IDistributedCache>();
IOptions <Settings> appSettings = Substitute.For <IOptions <Settings> >();
IStringLocalizer <ProductsController> mockLocalizer = new MockStringLocalizer <ProductsController>();
IProductApi productApi = new ProductApi(appSettings, mockRepo);
var controller = new ProductsController(mockCache,
productApi,
mockDownloadTimesApi,
mockProductTypesApi,
mockManufacturersApi,
mockInstallTypesApi,
mockMobileLookupApi,
mockBrandApi,
mockLocalizer);
var request = new GetProductsWithPagingRequestModel
{
FirstRecordNumber = 0,
PageSize = pageSize,
SortField = string.Empty,
SortOrder = SortOrderEnum.Asc
};
//// Act
var actionResult = await controller.GetProductsWithPaging(request);
//// Assert
var actualRecord = ((ObjectResult)actionResult).Value;
Assert.Equal(pageSize, ((List <ProductModel>)actualRecord).Count);
}
[Fact] // test methods without any parameters
public async Task GetProducts()
{
// creates a new context
var context = MockContext.GetContext("test1");
// adds the mockdata to the context
context.Seed();
var controller = new ProductsController(_userManager, _signInManager, context);
string[] arr = new String[0];
var response = controller.Index("", arr, arr, arr, arr);
var result = response.Result;
// assert verifies the condition
// IsAssignableFrom checks if the products .. are assigned
Assert.IsAssignableFrom <ViewResult>(result);
}
public void TestEditMethod()
{
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.Update(It.IsAny <Products>())).Callback <Products>(s => products = s);
//Pass in the IRepository products
ProductsController productsController = new ProductsController(mockProductsController.Object);
var result = productsController.Edit(products) as RedirectToRouteResult;
Assert.AreEqual(result.RouteValues["action"], "Index");
}
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 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 async Task Delete_Success()
{
// Arrange
var loggerController = Loggers.ProductControllerLogger();
var loggerRepository = Loggers.ProductRepositoryLogger();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var category = NewDatas.NewCategory();
await dbContext.Categories.AddRangeAsync(category);
await dbContext.SaveChangesAsync();
var product = NewDatas.NewProduct();
product.CategoryId = category.CategoryId;
await dbContext.Products.AddAsync(product);
await dbContext.SaveChangesAsync();
var productRepository = new ProductRepository(loggerRepository, mapper, dbContext);
var productController = new ProductsController(loggerController, productRepository);
// Act
var result = await productController.RemoveProduct(product.ProductId);
// Assert
var deletedResult = Assert.IsType <OkObjectResult>(result.Result);
var deletedResultValue = Assert.IsType <ProductRespone>(deletedResult.Value);
Assert.Equal(product.Name, deletedResultValue.Name);
Assert.Equal(product.Price, deletedResultValue.Price);
Assert.Equal(product.Description, deletedResultValue.Description);
Assert.Equal(product.Image, deletedResultValue.Image);
Assert.Equal(product.Rated, deletedResultValue.Rated);
Assert.Equal(category.CategoryId, deletedResultValue.CategoryId);
Assert.Equal(category.Name, deletedResultValue.CategoryName);
await Assert.ThrowsAsync <NotFoundException>(async() =>
{
await productController.GetProduct(deletedResultValue.ProductId);
});
}
public void GetAllCategories_CategoryIdList_ReturnSameIds()
{
ProductsController productController = new ProductsController();
var mockDbconnection = new Mock <Models.ApplicationDbContext>();
List <Category> categories = new List <Category>
{
new Category
{
CategoryId = 1,
Title = "1"
},
new Category
{
CategoryId = 2,
Title = "2"
},
new Category
{
CategoryId = 3,
Title = "3"
}
};
IQueryable <Category> queryableCats = categories.AsQueryable();
var mockCategories = new Mock <DbSet <Category> >();
mockCategories.As <IQueryable <Category> >().Setup(m => m.Provider).Returns(queryableCats.Provider);
mockCategories.As <IQueryable <Category> >().Setup(m => m.Expression).Returns(queryableCats.Expression);
mockCategories.As <IQueryable <Category> >().Setup(m => m.ElementType).Returns(queryableCats.ElementType);
mockCategories.As <IQueryable <Category> >().Setup(m => m.GetEnumerator()).Returns(queryableCats.GetEnumerator());
mockDbconnection.Setup(d => d.Categories).Returns(mockCategories.Object);
var mockContext = new Mock <ControllerContext>();
productController.ControllerContext = mockContext.Object;
PrivateObject po = new PrivateObject(productController);
po.SetField("db", mockDbconnection.Object);
List <string> categoryIds = categories.Select(c => c.CategoryId.ToString()).ToList();
List <string> result = productController.GetAllCategories().OrderBy(s => s.Value).Select(s => s.Value).ToList();
Assert.AreEqual(String.Concat(result), String.Concat(categoryIds));
}
public async Task ProductsController_Put_Success()
{
var createRequest = new ProductCreateRequest
{
Name = "Test product5",
Price = 123,
Description = "product5",
ImageUrl = "http://image",
BrandId = _fixture.Brands[0].Id,
CategoryIds = new List <int> {
_fixture.Categories[0].Id
}
};
var controller = new ProductsController(_fixture.ProductService);
var createResult = await controller.Post(createRequest);
var createResponse = GetResponse <ProductCreateResponse>(createResult);
Assert.Equal("Test product5", createResponse.Name);
var updateRequest = new ProductUpdateRequest
{
Id = createResponse.Id,
Name = "New Name",
Price = 456,
Description = "new new",
ImageUrl = "http://new-image",
BrandId = _fixture.Brands[2].Id,
CategoryIds = new List <int> {
_fixture.Categories[2].Id,
_fixture.Categories[3].Id
}
};
var updateResult = await controller.Put(updateRequest);
var updateResponse = GetResponse <ProductUpdateResponse>(updateResult);
Assert.Equal(updateRequest.Id, updateResponse.Id);
Assert.Equal(updateRequest.Price, updateResponse.Price);
Assert.Equal(updateRequest.ImageUrl, updateResponse.ImageUrl);
Assert.Equal(updateRequest.BrandId, updateResponse.BrandId);
Assert.Equal(updateRequest.CategoryIds, updateResponse.CategoryIds);
}
public async Task GetProductByIdAsync_GivenProductIdThatExists_ShouldReturnTypeOk()
{
// Arrange
var productServiceMock = new Mock <IProductService>();
int productIdThatExists = 0;
productServiceMock.Setup(ps => ps.DoesProductIdExist(productIdThatExists))
.ReturnsAsync(true);
productServiceMock.Setup(ps => ps.GetProductByIdAsync(productIdThatExists))
.ReturnsAsync(new Product());
var productsController = new ProductsController(productServiceMock.Object);
// Act
ActionResult <Product> actionResult = await productsController.GetProductByIdAsync(productIdThatExists);
// Assert
actionResult.Result.ShouldBeOfType <OkObjectResult>();
}
public void ShouldReturnNotFoundWhenNoRecomendations()
{
// Arrange
var controller = new ProductsController(
new StubIProductRepository
{
GetProductInt32 = (id) => new Product()
},
new StubIProductRecommendationRepository());
SetupControllerForTests(controller);
// Act
var result = controller.GetRecommendations(1);
// Assert
Assert.AreEqual(result.StatusCode, HttpStatusCode.NotFound);
}
public void TestGetAll()
{
//Arrange
Mock <IProductApplicationService> mockProductApplicationService =
new Mock <IProductApplicationService>();
mockProductApplicationService.Setup(service => service.GetProducts())
.Returns(new List <ProductDto>()
{
new ProductDto(), new ProductDto()
});
ProductsController controller = new ProductsController(mockProductApplicationService.Object);
//Act
IActionResult actionResult = controller.Get();
//Assert
Assert.IsType <OkObjectResult>(actionResult);
}
public void Add()
{
// arrange
var controller = new ProductsController(new Repository.Repository());
var newProduct = new Product()
{
Description = "Pear",
Price = 0.65M,
};
// act
controller.Post(newProduct);
var result = controller.Get();
// asset
result.Count().Should().Be(4);
}
public void DetailsTest_correctInfo()
{
ProductsController testController = new ProductsController(mock.Object);
ViewResult infoView1 = testController.Details(0) as ViewResult;
Product details1 = infoView1.ViewData.Model as Product;
ViewResult infoView2 = testController.Details(1) as ViewResult;
Product details2 = infoView1.ViewData.Model as Product;
ViewResult infoView3 = testController.Details(2) as ViewResult;
Product details3 = infoView1.ViewData.Model as Product;
Assert.AreEqual(details1.Name, "testName1");
Assert.AreEqual(details1.Cost, 999);
Assert.AreEqual(details2.Name, "testName2");
Assert.AreEqual(details2.Cost, 1);
Assert.AreEqual(details3.Name, "testName3");
Assert.AreEqual(details3.Cost, 25);
}
public void Get_ShouldReturnProductWithSameId()
{
// Arrange
var mockRepository = new Mock<IProductRepository>();
mockRepository.Setup(x => x.GetProduct("Found"))
.Returns(new Product { Id = "Found" });
var controller = new ProductsController(mockRepository.Object);
// Act
IHttpActionResult actionResult = controller.Get("Found");
var contentResult = actionResult as OkNegotiatedContentResult<Product>;
// Assert
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual("Found", contentResult.Content.Id);
}
public void UpdateProduct_BadResult()
{
//Arrange
var controller = new ProductsController(_uow);
var productId = 2;
var product = new Product
{
ProductId = 3,
Name = "Produto Teste Update"
};
//Act
var result = controller.Put(productId, product);
//Assert
Assert.IsType <BadRequestObjectResult>(result.Result);
}
public void ShouldReturnNotFoundForProducts()
{
// Arrange
var productRepository = new StubIProductRepository()
{
GetProductsInt32 = subcategoryId => null
};
var recommendationRepository = new StubIProductRecommendationRepository();
var controller = new ProductsController(productRepository, recommendationRepository);
SetupControllerForTests(controller);
// Act
var result = controller.GetProducts(1);
// Assert
Assert.AreEqual(result.StatusCode, HttpStatusCode.NotFound);
}
public void Mock_IndexModelContainsProducts_Collection() // Confirms presence of known entry
{
// Arrange
DbSetup();
ProductsController controller = new ProductsController(mock.Object);
Product testProduct = new Product {
ProductId = 1, Name = "1lb Gummy Bear", Cost = 10, Description = "BIG OLE BEAR"
};
testProduct.ProductId = 1;
// Act
ViewResult indexView = controller.Index() as ViewResult;
List <Product> collection = indexView.ViewData.Model as List <Product>;
// Assert
CollectionAssert.Contains(collection, testProduct);
}
public void GetReturnsAllProducts()
{
// Arrange
var mockRepository = new Mock <ProductServiceContext>();
mockRepository.Setup(x => x.Products)
.Returns(GetQueryableMockDbSet(MockProductListFull).Object);
var controller = new ProductsController(mockRepository.Object);
// Act
IHttpActionResult actionResult = controller.Get();
var contentResult = actionResult as OkNegotiatedContentResult <List <Product> >;
// Assert
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
CollectionAssert.AreEqual(MockProductListFull, contentResult.Content);
}
public void DB_IndexListAllProducts_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);
//act
controller.Create(testProduct1);
controller.Create(testProduct2);
var collection = (controller.Index() as ViewResult).ViewData.Model as List <Product>;
List <Product> result = new List <Product> {
testProduct1, testProduct2
};
//assert
CollectionAssert.AreEqual(result, collection);
}
public ProductsControllerTests()
{
mockProductsService = new Mock <IProductService>();
IOptions <Settings> someOptions = Options.Create <Settings>(new Settings()
{
MaxCountProducts = 0
});
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new ViewMappingProfile());
});
mapper = config.CreateMapper();
controller = new ProductsController(mockProductsService.Object, someOptions, mapper);;
}
public void GetReturnsAllProducts()
{
MockRepository mockRespository = new MockRepository();
MockJsonHelper mockJsonHelper = new MockJsonHelper(mockRespository);
var controller = new ProductsController(mockJsonHelper);
controller.Request = new HttpRequestMessage();
controller.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
var response = controller.Get(2);
String firstname;
Assert.IsTrue(response.TryGetContentValue <String>(out firstname));
Assert.AreEqual("Leonardo", firstname);
}
public void Mock_DeleteProduct_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.Delete(testProduct.ProductId) as ViewResult;
var model = resultView.ViewData.Model as Product;
//assert
Assert.IsInstanceOfType(resultView, typeof(ViewResult));
Assert.IsInstanceOfType(model, typeof(Product));
}
public void UpdateProdust_WhenNotExist()
{
// Arrange
var mockService = new Mock <IProductDomainService>();
Guid testId = Guid.NewGuid();
mockService.Setup(ms => ms.UpdateProduct(testId, It.IsAny <Product>()))
.Throws <Exception>();
var controller = new ProductsController(mockService.Object);
// Act & Assert
var testRequest = new ProductRequest()
{
Name = "Guasha"
};
Assert.Throws <Exception>(() => controller.UpdateProduct(testId, testRequest));
}
public ProductControllerTest()
{
repository = new Mock <IProductRepository>();
logger = new Mock <ILogger <ProductsController> >();
sut = new ProductsController(repository.Object,
logger.Object);
AutoMapper.Mapper.Initialize(cfg =>
{
cfg.CreateMap <Entities.Product, Models.ProductDto>();
cfg.CreateMap <Entities.ProductOption, Models.ProductOptionDto>();
cfg.CreateMap <Models.ProductForCreationDto, Entities.Product>();
cfg.CreateMap <Models.ProductForUpdateDto, Entities.Product>();
cfg.CreateMap <Models.ProductOptionForCreationDto, Entities.ProductOption>();
cfg.CreateMap <Models.ProductOptionForUpdateDto, Entities.ProductOption>();
});
}
private ProductsController SetupController()
{
//const string ProductDescription = "SomeDescr";
var autoMapperConfig = new AutoMapperConfig();
autoMapperConfig.Execute(typeof(ProductsController).Assembly);
var productsServiceMock = new Mock<IProductsService>();
productsServiceMock
.Setup(x => x.GetById(It.IsAny<string>()))
.Returns(new Product()
{
Title = "someName",
ShortDescription = this.ProductDescription,
Category = new Category()
{
Name = "someName"
}
});
var cacheServiceMock = new Mock<ICacheService>();
var controller = new ProductsController(productsServiceMock.Object, cacheServiceMock.Object);
return controller;
}
public void Put_ShouldFail_WhenDifferentID()
{
// Arrange
var mockRepository = new Mock<IProductRepository>();
ProductsController controller = new ProductsController(mockRepository.Object);
// Act
var badresult = controller.Put("999", Helpers.CreateTestProduct());
// Assert
Assert.IsInstanceOfType(badresult, typeof(BadRequestResult));
}
public void PutProduct_ShouldReturnStatusCode()
{
// arrange
var controller = new ProductsController(new TestStoreAppContext());
var item = this.GetDemoProduct();
// act
var result = controller.PutProduct(item.Id, item) as StatusCodeResult;
// assert
Assert.IsType(typeof(StatusCodeResult), result);
Assert.Equal(HttpStatusCode.NoContent, result.StatusCode);
}
public void Get_ShouldReturnNotFoundWhenProductDoesNotExist()
{
// Arrange
var mockRepository = new Mock<IProductRepository>();
mockRepository.Setup(x => x.GetProduct("Not Found"));
var controller = new ProductsController(mockRepository.Object);
// Act
IHttpActionResult actionResult = controller.Get("Not Found");
// Assert
Assert.IsInstanceOfType(actionResult, typeof(NotFoundResult));
}
public void Get_ShouldReturnAllProducts()
{
// Arrange
var mockRepository = new Mock<IProductRepository>();
var testData = Helpers.GetTestData();
mockRepository.Setup(x => x.GetAllProducts())
.Returns(testData.AsQueryable());
var controller = new ProductsController(mockRepository.Object);
// Act
IEnumerable<Product> products = controller.Get();
// Assert
Assert.IsNotNull(products);
Assert.AreEqual(testData.Count, products.Count());
}
public void Post_ShouldSetRouteValues()
{
// Arrange
var mockRepository = new Mock<IProductRepository>();
ProductsController controller = new ProductsController(mockRepository.Object);
controller.Request = new HttpRequestMessage
{
RequestUri = new Uri(string.Format("http://{0}:{1}/api/inventory/products", "localhost", 65217))
};
controller.Configuration = new HttpConfiguration();
controller.Configuration.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/inventory/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
controller.RequestContext.RouteData = new HttpRouteData(
route: new HttpRoute(),
values: new HttpRouteValueDictionary { { "controller", "products" } });
// Act
Product product = new Product() { Id = "MyTitle", Title = "Product1" };
var actionResult = controller.Post(product);
// Assert
var response = actionResult as CreatedAtRouteNegotiatedContentResult<Product>;
// Implementation uses WebAPI helper class to ensure that the response headers are set correct.
// Only need to test that the ROute VAlues are configured
Assert.IsNotNull(response);
Assert.AreEqual("DefaultApi", response.RouteName);
Assert.AreEqual("MyTitle", response.RouteValues["Id"]);
mockRepository.Verify(m => m.InsertProduct(It.Is<Product>(arg => arg.Id == "MyTitle")));
}
public void Post_ShouldAddProductToRepo()
{
// Arrange
var mockRepository = new Mock<IProductRepository>();
ProductsController controller = new ProductsController(mockRepository.Object);
controller.Request = new HttpRequestMessage
{
RequestUri = new Uri(string.Format("http://{0}:{1}/api/inventory/products", "localhost", 65217))
};
controller.Configuration = new HttpConfiguration();
controller.Configuration.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/inventory/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
controller.RequestContext.RouteData = new HttpRouteData(
route: new HttpRoute(),
values: new HttpRouteValueDictionary { { "controller", "products" } });
// Act
Product product = new Product() { Id = "MyTitle", Title = "Product1" };
var actionResult = controller.Post(product);
// Assert
mockRepository.Verify(m => m.InsertProduct(It.Is<Product>(arg => arg.Id == "MyTitle")));
}
public void Delete_ShouldReturnProductWithSameId()
{
// Arrange
var item = Helpers.CreateTestProduct();
var mockRepository = new Mock<IProductRepository>();
mockRepository.Setup(x => x.GetProduct(item.Id)).Returns(item);
mockRepository.Setup(x => x.DeleteProduct(item));
var controller = new ProductsController(mockRepository.Object);
// Act
IHttpActionResult actionResult = controller.Delete(item.Id);
var contentResult = actionResult as OkNegotiatedContentResult<Product>;
// Assert
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(item.Id, contentResult.Content.Id);
}
public void Get_ShouldReturnOkResult()
{
// Arrange
var mockRepository = new Mock<IProductRepository>();
mockRepository.Setup(x => x.GetProduct("Found"))
.Returns(new Product { Id = "Found" });
var controller = new ProductsController(mockRepository.Object);
// Act
IHttpActionResult actionResult = controller.Get("Found");
// Assert
Assert.IsInstanceOfType(actionResult, typeof(OkNegotiatedContentResult<Product>));
}
public void Delete_ShouldReturnNotFoundWhenProductDoesNotExist()
{
// Arrange
var item = Helpers.CreateTestProduct();
var mockRepository = new Mock<IProductRepository>();
mockRepository.Setup(x => x.GetProduct(item.Id));
var controller = new ProductsController(mockRepository.Object);
// Act
IHttpActionResult actionResult = controller.Delete(item.Id);
// Assert
Assert.IsInstanceOfType(actionResult, typeof(NotFoundResult));
}
public void Delete_ShouldReturnOkResult()
{
// Arrange
var item = Helpers.CreateTestProduct();
var mockRepository = new Mock<IProductRepository>();
mockRepository.Setup(x => x.GetProduct(item.Id)).Returns(item);
//mockRepository.Setup(x => x.DeleteProduct(item.Id));
var controller = new ProductsController(mockRepository.Object);
// Act
IHttpActionResult actionResult = controller.Delete(item.Id);
// Assert
Assert.IsInstanceOfType(actionResult, typeof(OkNegotiatedContentResult<Product>));
}
public void Put_ShouldChangeProductInRepo()
{
// Arrange
var item = Helpers.CreateTestProduct();
var mockRepository = new Mock<IProductRepository>();
mockRepository.Setup(x => x.ProductExists(item.Id)).Returns(true);
ProductsController controller = new ProductsController(mockRepository.Object);
controller.Request = new HttpRequestMessage
{
RequestUri = new Uri(string.Format("http://{0}:{1}/api/inventory/products", "localhost", 65217))
};
controller.Configuration = new HttpConfiguration();
controller.Configuration.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/inventory/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
controller.RequestContext.RouteData = new HttpRouteData(
route: new HttpRoute(),
values: new HttpRouteValueDictionary { { "controller", "products" } });
// Act
var actionResult = controller.Put(item.Id, item);
// Assert
mockRepository.Verify(m => m.ChangeProduct(It.Is<Product>(arg => arg.Id == item.Id)));
}
public void Put_ShouldFail_WhenModelStateInvalid()
{
// Arrange
var mockRepository = new Mock<IProductRepository>();
ProductsController controller = new ProductsController(mockRepository.Object);
controller.ModelState.AddModelError("key", "error message");
var item = Helpers.CreateTestProduct();
// Act
var badresult = controller.Put(item.Id, item);
// Assert
Assert.IsInstanceOfType(badresult, typeof(InvalidModelStateResult));
}
public void Put_ShouldReturnStatusCode()
{
// Arrange
var item = Helpers.CreateTestProduct();
var mockRepository = new Mock<IProductRepository>();
mockRepository.Setup(x => x.ProductExists(item.Id)).Returns(true);
mockRepository.Setup(x => x.ChangeProduct(item));
ProductsController controller = new ProductsController(mockRepository.Object);
// Act
var result = controller.Put(item.Id, item) as StatusCodeResult;
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(StatusCodeResult));
Assert.AreEqual(HttpStatusCode.NoContent, result.StatusCode);
}
public void Put_ShouldFail_WhenProductNotFound()
{
// Arrange
var item = Helpers.CreateTestProduct();
var mockRepository = new Mock<IProductRepository>();
mockRepository.Setup(x => x.ProductExists(item.Id)).Returns(false);
ProductsController controller = new ProductsController(mockRepository.Object);
// Act
var actionResult = controller.Put(item.Id, item);
// Assert
Assert.IsInstanceOfType(actionResult, typeof(NotFoundResult));
}