702 lines
34 KiB
C#
702 lines
34 KiB
C#
using System.Collections;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using ThAmCo.Stock.Controllers;
|
|
using ThAmCo.Stock.Data;
|
|
using ThAmCo.Stock.Data.StockContext;
|
|
using ThAmCo.Stock.Models.Dto;
|
|
using Moq;
|
|
using System.Net.Http;
|
|
using Moq.Protected;
|
|
using System.Threading;
|
|
using Newtonsoft.Json;
|
|
using System.Text;
|
|
using ThAmCo.Stock.Models.ViewModel;
|
|
using System;
|
|
using Microsoft.AspNetCore.Http;
|
|
|
|
namespace ThAmCo.Stock.Tests.Controllers
|
|
{
|
|
[TestClass]
|
|
public class StockControllerTests
|
|
{
|
|
private static class Data
|
|
{
|
|
public static List<ProductStock> ProductStocks() => new List<ProductStock>
|
|
{
|
|
new ProductStock { Id = 1, Stock = 10, PriceId = 1, ProductId = 436 },
|
|
new ProductStock { Id = 2, Stock = 0, PriceId = 3, ProductId = 326 },
|
|
new ProductStock { Id = 3, Stock = 4, PriceId = 4, ProductId = 273 },
|
|
new ProductStock { Id = 4, Stock = 43, PriceId = 6, ProductId = 456 },
|
|
new ProductStock { Id = 5, Stock = 2, PriceId = 7, ProductId = 32 },
|
|
new ProductStock { Id = 6, Stock = 14, PriceId = 8, ProductId = 33 },
|
|
new ProductStock { Id = 7, Stock = 1, PriceId = 9, ProductId = 21 }
|
|
};
|
|
|
|
public static List<Price> Prices() => new List<Price>
|
|
{
|
|
new Price { Id = 1, ProductStockId = 1, ProductPrice = 8.99 },
|
|
new Price { Id = 2, ProductStockId = 2, ProductPrice = 24.99 },
|
|
new Price { Id = 3, ProductStockId = 2, ProductPrice = 19.99 },
|
|
new Price { Id = 4, ProductStockId = 3, ProductPrice = 54.56 },
|
|
new Price { Id = 5, ProductStockId = 4, ProductPrice = 73.00 },
|
|
new Price { Id = 6, ProductStockId = 4, ProductPrice = 29.99 },
|
|
new Price { Id = 7, ProductStockId = 5, ProductPrice = 13.65 },
|
|
new Price { Id = 8, ProductStockId = 6, ProductPrice = 3.99 },
|
|
new Price { Id = 9, ProductStockId = 7, ProductPrice = 5.67}
|
|
};
|
|
|
|
public static List<ProductStockDto> ProductStockDtos() => new List<ProductStockDto>
|
|
{
|
|
new ProductStockDto { ProductStock = ProductStocks()[0], Price = Prices()[0] },
|
|
new ProductStockDto { ProductStock = ProductStocks()[1], Price = Prices()[2] },
|
|
new ProductStockDto { ProductStock = ProductStocks()[2], Price = Prices()[3] },
|
|
new ProductStockDto { ProductStock = ProductStocks()[3], Price = Prices()[5] },
|
|
new ProductStockDto { ProductStock = ProductStocks()[4], Price = Prices()[6] },
|
|
new ProductStockDto { ProductStock = ProductStocks()[5], Price = Prices()[7] },
|
|
new ProductStockDto { ProductStock = ProductStocks()[6], Price = Prices()[8] }
|
|
};
|
|
|
|
public static List<VendorProductDto> VendorProducts() => new List<VendorProductDto>
|
|
{
|
|
new VendorProductDto { Id = 1, Ean = "Sample Ean 1", CategoryId = 3, CategoryName = "Sample Category Name 1", BrandId = 5, BrandName = "Sample Brand Name 1", Name = "Sample Name 1", Description = "Sample Description 1", Price = 9.1, InStock = true, ExpectedRestock = null },
|
|
new VendorProductDto { Id = 2, Ean = "Sample Ean 2", CategoryId = 4, CategoryName = "Sample Category Name 2", BrandId = 6, BrandName = "Sample Brand Name 2", Name = "Sample Name 2", Description = "Sample Description 2", Price = 8.16, InStock = true, ExpectedRestock = null },
|
|
new VendorProductDto { Id = 3, Ean = "Sample Ean 3", CategoryId = 5, CategoryName = "Sample Category Name 3", BrandId = 7, BrandName = "Sample Brand Name 3", Name = "Sample Name 3", Description = "Sample Description 3", Price = 1.9, InStock = true, ExpectedRestock = null },
|
|
new VendorProductDto { Id = 4, Ean = "Sample Ean 4", CategoryId = 3, CategoryName = "Sample Category Name 4", BrandId = 5, BrandName = "Sample Brand Name 4", Name = "Sample Name 4", Description = "Sample Description 4", Price = 23.21, InStock = true, ExpectedRestock = null }
|
|
};
|
|
}
|
|
|
|
private const int OutOfBoundsId = 8;
|
|
private const int NegativeId = -1;
|
|
|
|
private Mock<HttpMessageHandler> CreateHttpMock(HttpResponseMessage expected)
|
|
{
|
|
var mock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
|
|
mock.Protected()
|
|
.Setup<Task<HttpResponseMessage>>(
|
|
"SendAsync",
|
|
ItExpr.IsAny<HttpRequestMessage>(),
|
|
ItExpr.IsAny<CancellationToken>())
|
|
.ReturnsAsync(expected)
|
|
.Verifiable();
|
|
return mock;
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task GetAll_AllValid_AllReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
|
|
var result = await controller.ProductStocks();
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result.Result as OkObjectResult;
|
|
Assert.IsNotNull(objectResult);
|
|
var enumerableResult = objectResult.Value as IEnumerable<ProductStockDto>;
|
|
Assert.IsNotNull(enumerableResult);
|
|
var listResult = enumerableResult.ToList();
|
|
foreach (var p in listResult)
|
|
{
|
|
Assert.AreEqual(p.Price.Date, Data.Prices()[p.Price.Id - 1].Date);
|
|
Assert.AreEqual(p.Price.Id, Data.Prices()[p.Price.Id - 1].Id);
|
|
Assert.AreEqual(p.Price.ProductPrice, Data.Prices()[p.Price.Id - 1].ProductPrice);
|
|
Assert.AreEqual(p.Price.ProductStockId, Data.Prices()[p.Price.Id - 1].ProductStockId);
|
|
|
|
Assert.AreEqual(p.ProductStock.Id, Data.ProductStocks()[p.ProductStock.Id - 1].Id);
|
|
Assert.AreEqual(p.ProductStock.Stock, Data.ProductStocks()[p.ProductStock.Id - 1].Stock);
|
|
Assert.AreEqual(p.ProductStock.PriceId, Data.ProductStocks()[p.ProductStock.Id - 1].PriceId);
|
|
Assert.AreEqual(p.ProductStock.ProductId, Data.ProductStocks()[p.ProductStock.Id - 1].ProductId);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task GetAll_EmptyModel_EmptyListReturned()
|
|
{
|
|
var context = new MockStockContext(new List<ProductStock>(), new List<Price>(), null);
|
|
var controller = new StockController(context, null);
|
|
|
|
var result = await controller.ProductStocks();
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result.Result as OkObjectResult;
|
|
Assert.IsNotNull(objectResult);
|
|
var enumerableResult = objectResult.Value as IEnumerable<ProductStockDto>;
|
|
Assert.IsNotNull(enumerableResult);
|
|
var listResult = enumerableResult.ToList();
|
|
Assert.AreEqual(listResult.Count, 0);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task GetDetails_ValidIdPassed_CorrectAndValidObjectReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = 2;
|
|
|
|
var result = await controller.Details(id);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result.Result as OkObjectResult;
|
|
Assert.IsNotNull(objectResult);
|
|
var returnedResult = objectResult.Value as ProductStockDetailsDto;
|
|
Assert.IsNotNull(returnedResult);
|
|
|
|
Assert.AreEqual(returnedResult.ProductID, Data.ProductStocks()[id - 1].ProductId);
|
|
Assert.AreEqual(returnedResult.Price, Data.Prices().FirstOrDefault( p => p.Id == Data.ProductStocks()[id - 1].PriceId)?.ProductPrice);
|
|
Assert.AreEqual(returnedResult.Stock, Data.ProductStocks()[id - 1].Stock);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task GetDetails_OutOfBoundsPositiveId_NotFoundReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = OutOfBoundsId;
|
|
|
|
var result = await controller.Details(id);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result.Result as NotFoundResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task GetDetails_OutOfBoundsNegativeId_NotFoundReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = NegativeId;
|
|
|
|
var result = await controller.Details(id);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result.Result as NotFoundResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task PriceHistory_ValidIdPassed_CorrectAndValidObjectReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = 1;
|
|
|
|
var result = await controller.PriceHistory(id);
|
|
var validPrices = Data.Prices().Where(p => p.ProductStockId == id).ToList();
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result.Result as OkObjectResult;
|
|
Assert.IsNotNull(objectResult);
|
|
var returnedResult = objectResult.Value as ProductStockPricingHistoryDto;
|
|
Assert.IsNotNull(returnedResult);
|
|
|
|
Assert.AreEqual(returnedResult.ProductID, Data.ProductStocks()[id - 1].ProductId);
|
|
Assert.AreEqual(returnedResult.Stock, Data.ProductStocks()[id - 1].Stock);
|
|
Assert.AreEqual(returnedResult.Prices.Count, validPrices.Count);
|
|
foreach (var prices in returnedResult.Prices)
|
|
{
|
|
Assert.AreEqual(prices.Id, validPrices.FirstOrDefault(p => p.Id == prices.Id)?.Id);
|
|
Assert.AreEqual(prices.Date, validPrices.FirstOrDefault(p => p.Id == prices.Id)?.Date);
|
|
Assert.AreEqual(prices.ProductPrice, validPrices.FirstOrDefault(p => p.Id == prices.Id)?.ProductPrice);
|
|
Assert.AreEqual(prices.ProductStockId, validPrices.FirstOrDefault(p => p.Id == prices.Id)?.ProductStockId);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task PriceHistory_OutOfBoundsPositiveId_NotFoundReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = OutOfBoundsId;
|
|
|
|
var result = await controller.PriceHistory(id);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result.Result as NotFoundResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task PriceHistory_OutOfBoundsNegativeId_NotFoundReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = NegativeId;
|
|
|
|
var result = await controller.PriceHistory(id);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result.Result as NotFoundResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Low_ValidCountPassedLowerThanDefault_CorrectAndValidObjectReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int count = 4;
|
|
|
|
var result = controller.Low(count);
|
|
var expectedResult = Data.ProductStockDtos().OrderBy(ps => ps.ProductStock.Stock).Take(count).ToList();
|
|
|
|
Assert.IsNotNull(result);
|
|
var priceResult = result.Result as ViewResult;
|
|
Assert.IsNotNull(priceResult);
|
|
var objectResult = priceResult.Model as IEnumerable<ProductStockDto>;
|
|
Assert.IsNotNull(objectResult);
|
|
var returnedListResult = objectResult.ToList();
|
|
Assert.AreEqual(returnedListResult.Count, count);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
Assert.AreEqual(returnedListResult[i].Price.Date, expectedResult[i].Price.Date);
|
|
Assert.AreEqual(returnedListResult[i].Price.Id, expectedResult[i].Price.Id);
|
|
Assert.AreEqual(returnedListResult[i].Price.ProductPrice, expectedResult[i].Price.ProductPrice);
|
|
Assert.AreEqual(returnedListResult[i].Price.ProductStockId, expectedResult[i].Price.ProductStockId);
|
|
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.Id, expectedResult[i].ProductStock.Id);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.Stock, expectedResult[i].ProductStock.Stock);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.PriceId, expectedResult[i].ProductStock.PriceId);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.ProductId, expectedResult[i].ProductStock.ProductId);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Low_ValidCountPassedHigherThanDefault_CorrectAndValidObjectReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int count = 6;
|
|
|
|
var result = controller.Low(count);
|
|
var expectedResult = Data.ProductStockDtos().OrderBy(ps => ps.ProductStock.Stock).Take(count).ToList();
|
|
|
|
Assert.IsNotNull(result);
|
|
var priceResult = result.Result as ViewResult;
|
|
Assert.IsNotNull(priceResult);
|
|
var objectResult = priceResult.Model as IEnumerable<ProductStockDto>;
|
|
Assert.IsNotNull(objectResult);
|
|
var returnedListResult = objectResult.ToList();
|
|
Assert.AreEqual(returnedListResult.Count, count);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
Assert.AreEqual(returnedListResult[i].Price.Date, expectedResult[i].Price.Date);
|
|
Assert.AreEqual(returnedListResult[i].Price.Id, expectedResult[i].Price.Id);
|
|
Assert.AreEqual(returnedListResult[i].Price.ProductPrice, expectedResult[i].Price.ProductPrice);
|
|
Assert.AreEqual(returnedListResult[i].Price.ProductStockId, expectedResult[i].Price.ProductStockId);
|
|
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.Id, expectedResult[i].ProductStock.Id);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.Stock, expectedResult[i].ProductStock.Stock);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.PriceId, expectedResult[i].ProductStock.PriceId);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.ProductId, expectedResult[i].ProductStock.ProductId);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Low_NullValuePassed_DefaultAmountCorrectAndValidObjectsReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int count = 5;
|
|
|
|
var result = controller.Low(null);
|
|
var expectedResult = Data.ProductStockDtos().OrderBy(ps => ps.ProductStock.Stock).Take(count).ToList();
|
|
|
|
Assert.IsNotNull(result);
|
|
var priceResult = result.Result as ViewResult;
|
|
Assert.IsNotNull(priceResult);
|
|
var objectResult = priceResult.Model as IEnumerable<ProductStockDto>;
|
|
Assert.IsNotNull(objectResult);
|
|
var returnedListResult = objectResult.ToList();
|
|
Assert.AreEqual(returnedListResult.Count, count);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
Assert.AreEqual(returnedListResult[i].Price.Date, expectedResult[i].Price.Date);
|
|
Assert.AreEqual(returnedListResult[i].Price.Id, expectedResult[i].Price.Id);
|
|
Assert.AreEqual(returnedListResult[i].Price.ProductPrice, expectedResult[i].Price.ProductPrice);
|
|
Assert.AreEqual(returnedListResult[i].Price.ProductStockId, expectedResult[i].Price.ProductStockId);
|
|
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.Id, expectedResult[i].ProductStock.Id);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.Stock, expectedResult[i].ProductStock.Stock);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.PriceId, expectedResult[i].ProductStock.PriceId);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.ProductId, expectedResult[i].ProductStock.ProductId);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Low_OutOfBoundsCountPassed_AllValuesReturnedCorrectly()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int count = OutOfBoundsId;
|
|
|
|
var result = controller.Low(OutOfBoundsId);
|
|
var expectedResult = Data.ProductStockDtos().OrderBy(ps => ps.ProductStock.Stock).Take(count).ToList();
|
|
|
|
Assert.IsNotNull(result);
|
|
var priceResult = result.Result as ViewResult;
|
|
Assert.IsNotNull(priceResult);
|
|
var objectResult = priceResult.Model as IEnumerable<ProductStockDto>;
|
|
Assert.IsNotNull(objectResult);
|
|
var returnedListResult = objectResult.ToList();
|
|
Assert.AreEqual(returnedListResult.Count, expectedResult.Count);
|
|
|
|
for (int i = 0; i < expectedResult.Count; i++)
|
|
{
|
|
Assert.AreEqual(returnedListResult[i].Price.Date, expectedResult[i].Price.Date);
|
|
Assert.AreEqual(returnedListResult[i].Price.Id, expectedResult[i].Price.Id);
|
|
Assert.AreEqual(returnedListResult[i].Price.ProductPrice, expectedResult[i].Price.ProductPrice);
|
|
Assert.AreEqual(returnedListResult[i].Price.ProductStockId, expectedResult[i].Price.ProductStockId);
|
|
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.Id, expectedResult[i].ProductStock.Id);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.Stock, expectedResult[i].ProductStock.Stock);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.PriceId, expectedResult[i].ProductStock.PriceId);
|
|
Assert.AreEqual(returnedListResult[i].ProductStock.ProductId, expectedResult[i].ProductStock.ProductId);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Low_OutOfBoundsNegativePassed_NotFoundReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int count = NegativeId;
|
|
|
|
var result = controller.Low(count);
|
|
|
|
Assert.IsNotNull(result);
|
|
var priceResult = result.Result as NotFoundResult;
|
|
Assert.IsNotNull(priceResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GETAdjustCost_ValidIdPassed_CorrectDataReturnedToView()
|
|
{
|
|
const int id = 2;
|
|
var expectedHttpResponse = new ProductDto { Id = id, Name = "NameTest", Description = "DescriptionTest" };
|
|
var expectedJson = JsonConvert.SerializeObject(expectedHttpResponse);
|
|
var expectedResponse = new HttpResponseMessage
|
|
{
|
|
StatusCode = System.Net.HttpStatusCode.OK,
|
|
Content = new StringContent(expectedJson,
|
|
Encoding.UTF8,
|
|
"application/json")
|
|
};
|
|
var httpClient = new HttpClient(CreateHttpMock(expectedResponse).Object);
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null) { HttpClient = httpClient };
|
|
|
|
var expectedResult = Data.ProductStockDtos().FirstOrDefault(psd => psd.ProductStock.Id == id);
|
|
var result = controller.AdjustCost(id);
|
|
|
|
Assert.IsNotNull(result);
|
|
var adjustResult = result.Result.Result as ViewResult;
|
|
Assert.IsNotNull(adjustResult);
|
|
var adjustProductStock = adjustResult.Model as AdjustCostViewModel;
|
|
Assert.IsNotNull(adjustProductStock);
|
|
|
|
Assert.AreEqual(expectedResult.ProductStock.Id, adjustProductStock.Id);
|
|
Assert.AreEqual(expectedResult.Price.ProductPrice, adjustProductStock.Cost);
|
|
Assert.AreEqual(expectedHttpResponse.Name, adjustProductStock.Name);
|
|
Assert.AreEqual(expectedHttpResponse.Description, adjustProductStock.Description);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task GETAdjustCost_InvalidIdPassed_NotFoundReturned()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
|
|
var resultOutOfBounds = await controller.AdjustCost(OutOfBoundsId);
|
|
var resultNegative = await controller.AdjustCost(NegativeId);
|
|
|
|
Assert.IsNotNull(resultOutOfBounds);
|
|
var objectResultOutOfBounds = resultOutOfBounds.Result as NotFoundResult;
|
|
Assert.IsNotNull(objectResultOutOfBounds);
|
|
|
|
Assert.IsNotNull(resultNegative);
|
|
var objectResultNegative = resultNegative.Result as NotFoundResult;
|
|
Assert.IsNotNull(objectResultNegative);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task POSTAdjustCost_ValidIdAndCostPassed_PriceAddedToDatabaseAndPricePointerChanged()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = 2;
|
|
const double price = 4.32;
|
|
|
|
var previous = Data.ProductStockDtos().FirstOrDefault(ps => ps.ProductStock.Id == id);
|
|
var expected = previous;
|
|
expected.Price = new Price { Id = 10, ProductPrice = price, ProductStockId = expected.ProductStock.Id };
|
|
expected.ProductStock.PriceId = 10;
|
|
var result = await controller.AdjustCost(id, price);
|
|
var after = await context.GetProductStockAsync(id);
|
|
|
|
Assert.IsNotNull(result);
|
|
var okResult = result as OkResult;
|
|
Assert.IsNotNull(okResult);
|
|
Assert.AreEqual(previous.ProductStock.Id, after.ProductStock.Id); //Just check Id to make sure the correct product is returned.
|
|
Assert.AreEqual(expected.Price.Id, after.Price.Id);
|
|
Assert.AreEqual(expected.Price.ProductPrice, after.Price.ProductPrice);
|
|
Assert.AreEqual(expected.Price.ProductStockId, after.Price.ProductStockId);
|
|
Assert.AreEqual(expected.ProductStock.PriceId, after.ProductStock.PriceId);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task POSTAdjustCost_OutOfBoundsAndNegativeIdPassed_ReturnNotFound()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const double price = 4.32;
|
|
|
|
var resultOutOfBounds = await controller.AdjustCost(OutOfBoundsId, price);
|
|
var resultNegative = await controller.AdjustCost(NegativeId, price);
|
|
|
|
Assert.IsNotNull(resultOutOfBounds);
|
|
var objectResultOutOfBounds = resultOutOfBounds as NotFoundResult;
|
|
Assert.IsNotNull(objectResultOutOfBounds);
|
|
|
|
Assert.IsNotNull(resultNegative);
|
|
var objectResultNegative = resultNegative as NotFoundResult;
|
|
Assert.IsNotNull(objectResultNegative);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task POSTAdjustCost_NegativeCostPassed_ReturnBadRequest()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = 2;
|
|
const double price = -4.32;
|
|
|
|
var result = await controller.AdjustCost(id, price);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result as BadRequestResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task POSTAdjustCost_ZeroCostPassed_ReturnBadRequest()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = 2;
|
|
const double price = 0;
|
|
|
|
var result = await controller.AdjustCost(id, price);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result as BadRequestResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task VendorProducts_ValidSupplierPassed_ReturnAllSupplierProducts()
|
|
{
|
|
var expectedHttpResponse = Data.VendorProducts();
|
|
var expectedJson = JsonConvert.SerializeObject(expectedHttpResponse);
|
|
var expectedResponse = new HttpResponseMessage
|
|
{
|
|
StatusCode = System.Net.HttpStatusCode.OK,
|
|
Content = new StringContent(expectedJson,
|
|
Encoding.UTF8,
|
|
"application/json")
|
|
};
|
|
var httpClient = new HttpClient(CreateHttpMock(expectedResponse).Object);
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null) { HttpClient = httpClient };
|
|
const string supplier = "undercutters";
|
|
|
|
var expected = Data.VendorProducts();
|
|
var result = await controller.VendorProducts(supplier);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result as ViewResult;
|
|
Assert.IsNotNull(objectResult);
|
|
var viewResult = objectResult.Model as VendorProductIndexModel;
|
|
Assert.IsNotNull(viewResult);
|
|
var productsResult = viewResult.Products.ToList();
|
|
Assert.IsNotNull(productsResult);
|
|
|
|
Assert.AreEqual(expected.Count, productsResult.Count);
|
|
for (int i = 0; i < expected.Count; i++)
|
|
{
|
|
Assert.AreEqual(expected[i].Id, productsResult[i].Id);
|
|
Assert.AreEqual(expected[i].BrandId, productsResult[i].BrandId);
|
|
Assert.AreEqual(expected[i].BrandName, productsResult[i].BrandName);
|
|
Assert.AreEqual(expected[i].CategoryId, productsResult[i].CategoryId);
|
|
Assert.AreEqual(expected[i].CategoryName, productsResult[i].CategoryName);
|
|
Assert.AreEqual(expected[i].Description, productsResult[i].Description);
|
|
Assert.AreEqual(expected[i].Ean, productsResult[i].Ean);
|
|
Assert.AreEqual(expected[i].ExpectedRestock, productsResult[i].ExpectedRestock);
|
|
Assert.AreEqual(expected[i].InStock, productsResult[i].InStock);
|
|
Assert.AreEqual(expected[i].Name, productsResult[i].Name);
|
|
Assert.AreEqual(expected[i].Price, productsResult[i].Price);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task VendorProducts_NullSupplierPassed_ReturnNotFound()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const string supplier = null;
|
|
|
|
var result = await controller.VendorProducts(supplier);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result as NotFoundResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task VendorProducts_EmtpySupplierPassed_ReturnNotFound()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const string supplier = "";
|
|
|
|
var result = await controller.VendorProducts(supplier);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result as NotFoundResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task OrderRequest_ValidIdAndSupplierPassed_ReturnCorrectAndValidModel()
|
|
{
|
|
const int id = 2;
|
|
const string supplier = "undercutters";
|
|
var expectedHttpResponse = Data.VendorProducts().FirstOrDefault(vp => vp.Id == id);
|
|
var expectedJson = JsonConvert.SerializeObject(expectedHttpResponse);
|
|
var expectedResponse = new HttpResponseMessage
|
|
{
|
|
StatusCode = System.Net.HttpStatusCode.OK,
|
|
Content = new StringContent(expectedJson,
|
|
Encoding.UTF8,
|
|
"application/json")
|
|
};
|
|
var httpClient = new HttpClient(CreateHttpMock(expectedResponse).Object);
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null) { HttpClient = httpClient };
|
|
|
|
var expected = expectedHttpResponse;
|
|
var result = await controller.OrderRequest(id, supplier);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result as ViewResult;
|
|
Assert.IsNotNull(objectResult);
|
|
var viewResult = objectResult.Model as OrderRequestModel;
|
|
Assert.IsNotNull(viewResult);
|
|
|
|
Assert.AreEqual(id, viewResult.Id);
|
|
Assert.AreEqual(expected.Name, viewResult.Name);
|
|
Assert.AreEqual(expected.Id, viewResult.Id);
|
|
Assert.AreEqual(supplier, viewResult.Supplier);
|
|
Assert.AreEqual(expected.Description, viewResult.Description);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task OrderRequest_IncorrectProductReturned_ReturnInternalServerError()
|
|
{
|
|
const int id = 2;
|
|
const string supplier = "undercutters";
|
|
var expectedHttpResponse = Data.VendorProducts().FirstOrDefault(vp => vp.Id == id + 1);
|
|
var expectedJson = JsonConvert.SerializeObject(expectedHttpResponse);
|
|
var expectedResponse = new HttpResponseMessage
|
|
{
|
|
StatusCode = System.Net.HttpStatusCode.OK,
|
|
Content = new StringContent(expectedJson,
|
|
Encoding.UTF8,
|
|
"application/json")
|
|
};
|
|
var httpClient = new HttpClient(CreateHttpMock(expectedResponse).Object);
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null) { HttpClient = httpClient };
|
|
|
|
var result = await controller.OrderRequest(id, supplier);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result as StatusCodeResult;
|
|
Assert.IsNotNull(objectResult);
|
|
Assert.AreEqual(objectResult.StatusCode, StatusCodes.Status500InternalServerError);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task OrderRequest_EmtpySupplierPassed_ReturnNotFound()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = 2;
|
|
const string supplier = "";
|
|
|
|
var result = await controller.OrderRequest(id, supplier);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result as NotFoundResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task OrderRequest_ZeroIdPassed_ReturnNotFound()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = 0;
|
|
const string supplier = "undercutters";
|
|
|
|
var result = await controller.OrderRequest(id, supplier);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result as NotFoundResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task OrderRequest_NegativeIdPassed_ReturnNotFound()
|
|
{
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null);
|
|
const int id = NegativeId;
|
|
const string supplier = "undercutters";
|
|
|
|
var result = await controller.OrderRequest(id, supplier);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result as NotFoundResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task OrderRequest_OutOfBoundsIdPassed_ReturnNotFound()
|
|
{
|
|
const int id = 10000;
|
|
const string supplier = "undercutters";
|
|
var expectedResponse = new HttpResponseMessage
|
|
{
|
|
StatusCode = System.Net.HttpStatusCode.NotFound
|
|
};
|
|
var httpClient = new HttpClient(CreateHttpMock(expectedResponse).Object);
|
|
var context = new MockStockContext(Data.ProductStocks(), Data.Prices(), null);
|
|
var controller = new StockController(context, null) { HttpClient = httpClient };
|
|
|
|
var result = await controller.OrderRequest(id, supplier);
|
|
|
|
Assert.IsNotNull(result);
|
|
var objectResult = result as NotFoundResult;
|
|
Assert.IsNotNull(objectResult);
|
|
}
|
|
}
|
|
}
|