public async Task GetAll_Should_Return_List_Of_Pruducts_If_Exist()
{
//Arrange
List <ProductModel> products = new List <ProductModel>
{
new ProductModel
{
Id = 1,
Inventory = 2,
Name = "Product 1",
Price = 20
},
new ProductModel
{
Id = 2,
Inventory = 20,
Name = "Product 2",
Price = 400
}
};
_productQueryMock.Setup(o => o.GetAllAsync()).ReturnsAsync(() => (true, products, null));
//Act
var result = await _sut.GetAll();
//Assert
var okResult = Assert.IsType <OkObjectResult>(result);
okResult.Value.ShouldBe(products);
}
public void Get_WhenCalled_ReturnsOkResult()
{
// Act
var okResult = _controller.GetAll();
// Assert
Assert.IsType <OkObjectResult>(okResult.Result);
}
public async Task Return_NoContent_When_NoProductsFound()
{
_getProductsHandler
.Setup(g => g.GetAll())
.ReturnsAsync(new List <GetProductsResponse>());
var response = await _productsController.GetAll();
Assert.Multiple(() =>
{
var objectResult = (NoContentResult)response;
Assert.IsNotNull(objectResult);
Assert.AreEqual((int)HttpStatusCode.NoContent, objectResult.StatusCode);
});
}
public void 取得商品清單()
{
// Arrange
var expected = new List <Product>
{
new Product {
Id = 1, Name = "科幻四小俠", Price = 299, InStock = 6, Brief = "垃圾書刊"
},
new Product {
Id = 2, Name = "宇宙科幻", Price = 560, InStock = 2, Brief = "暢銷書籍"
},
new Product {
Id = 3, Name = "名偵探-ㄎㄅ", Price = 250, InStock = 5, Brief = "都在唬爛"
},
new Product {
Id = 4, Name = "這不是我認識的偵探", Price = 520, InStock = 0, Brief = "._."
}
};
var stubRepository = Substitute.For <IRepository <Product> >();
stubRepository.ReadAll().Returns(expected);
var controller = new ProductsController(stubRepository);
// Act
var actual = controller.GetAll();
// Assert
Assert.AreEqual(expected, actual);
}
public void Products_Controller_GetAllSucessfully()
{
// Arrange
var product = ObjectMother.ProductValidWithId();
product.Tax = ObjectMother.ValidProductTax();
var response = new List <Product>()
{
product
}.AsQueryable();
_productServiceMock.Setup(s => s.GetAll()).Returns(response);
var id = 1;
_productUpdateCmd.Setup(p => p.Id).Returns(id);
var odataOptions = GetOdataQueryOptions <Product>(_productsController);
// Action
var callback = _productsController.GetAll(odataOptions);
//Assert
_productServiceMock.Verify(s => s.GetAll(), Times.Once);
var httpResponse = callback.Should().BeOfType <OkNegotiatedContentResult <PageResult <ProductViewModel> > >().Subject;
httpResponse.Content.Should().NotBeNullOrEmpty();
httpResponse.Content.First().Id.Should().Be(id);
}
public async Task GetAll()
{
var product = new Product();
var productModel = new ProductModel();
var productsPortal = new Mock <IProductsPortal>(MockBehavior.Strict);
productsPortal
.Setup(x => x.GetAllProductsAsync())
.ReturnsAsync(RequestResult <Product, Guid> .New(new[] { product }, new[] { new Guid() }))
.Verifiable("Request operation not performed");
var apiLayerTranslator = new Mock <IApiLayerTranslator>(MockBehavior.Strict);
apiLayerTranslator
.Setup(x => x.Translate(product))
.Returns(productModel)
.Verifiable("Translation operation not performed");
var controller = new ProductsController(
logger: _logger,
productsPortal: productsPortal.Object,
apiLayerTranslator: apiLayerTranslator.Object,
validator: Mock.Of <IValidator>(MockBehavior.Strict));
var result = await controller.GetAll();
Assert.That(result, Is.TypeOf <OkObjectResult>());
productsPortal.VerifyAll();
apiLayerTranslator.VerifyAll();
}
public void Can_Get_All_Products()
{
_mockProductRepository.Setup(x => x.GetAll()).Returns(It.IsAny <IEnumerable <Product> >());
var products = _controller.GetAll();
_mockProductRepository.Verify(x => x.GetAll(), Times.Once);
}
public void TestGetAll()
{
var controller = new ProductsController(_service.Object);
var response = controller.GetAll();
Assert.AreEqual(response.Result.Items.Count, 2);
}
public void GetAll()
{
//Arrange
var productId1 = Guid.NewGuid();
var prouctId2 = Guid.NewGuid();
var product1 = new Product
{
Id = productId1,
Name = "Dummy Name 1",
Description = "Dummy Description 1",
Price = 123.45M,
DeliveryPrice = 67.89M
};
var product2 = new Product
{
Id = prouctId2,
Name = "Dummy Name 2",
Description = "Dummy Description 2",
Price = 543.21M,
DeliveryPrice = 98.76M
};
_productsController.Create(product1);
_productsController.Create(product2);
_productIds.Add(productId1);
_productIds.Add(prouctId2);
//Act
var actual = _productsController.GetAll();
//Assert
actual.Items.Should().Contain(product1);
actual.Items.Should().Contain(product2);
}
public void GetAllTest()
{
var products = new Products();
_productService.Setup(s => s.GetAll()).Returns(() => products);
Assert.Same(products, _ctrl.GetAll());
}
public void GetAllProducts_ShouldReturnAllProducts()
{
ProductsController controller = new ProductsController(this.mockContext.Object);
IQueryable <Product> result = controller.GetAll();
Assert.IsNotNull(result);
Assert.AreNotEqual(0, result.Count());
}
public void SetUp()
{
var allProducts = _productsController.GetAll();
foreach (var product in allProducts.Items)
{
_productsController.Delete(product.Id);
}
foreach (var product in _defaultProducts)
{
_productsController.Create(product);
}
foreach (var productOptions in _defaultProductOptions)
{
_productsController.CreateOption(productOptions.ProductId, productOptions);
}
}
public async void GetAll_ReturnsTwoProducts()
{
var configuration = GetConfig();
var sut = new ProductsController(configuration);
var result = await sut.GetAll();
Assert.Equal(2, result.Count());
}
protected void Page_Load(object sender, EventArgs e)
{
ProductsController productsController = new ProductsController();
DataTable dt = productsController.GetAll();
ddlProduct.DataSource = dt.DefaultView;
ddlProduct.DataTextField = "model";
ddlProduct.DataValueField = "product_id";
ddlProduct.DataBind();
}
public void TestGetAllProduct()
{
//Arrange
//Act
var results = _testController.GetAll().Items as List <ProductModel>;
//Assert
_mockService.Verify(s => s.GetAllProduct());
}
public void GetAllProducts()
{
// Arrange
var controller = new ProductsController();
// Act
Products result = controller.GetAll();
// Assert
Assert.IsNotNull(result);
}
public async Task GetAllProducts_ShouldReturnAllProducts()
{
var testProducts = await _productRepository.GetAllProducts();
var response = await _productController.GetAll();
ObjectContent content = response.Content as ObjectContent;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(testProducts.Count, ((List <Product>)content.Value).Count);
}
public void GetAll_ReturnsActionResultContainingListOfAllProducts_WhenCalled()
{
// Arrange
var dbContext = GetDatabaseContext();
var productsController = new ProductsController(dbContext);
// Act
var products = productsController.GetAll();
// Assert
Assert.Equal(products.Value.Count(), 5);
}
public void GetAll_ReturnsTypeOfActionResultContainingListOfProducts_WhenCalled()
{
// Arrange
var dbContext = GetDatabaseContext();
var productsController = new ProductsController(dbContext);
// Act
var products = productsController.GetAll();
// Assert
Assert.IsType <ActionResult <List <Product> > >(products);
}
public async Task GetAllShouldReturnProductResponseDto()
{
// Arrange
_productInterface.Setup(x => x.GetAll()).ReturnsAsync(new QueryResponseDto <ProductsResponseDto>(new ProductsResponseDto()));
var controller = new ProductsController(_productInterface.Object);
// Act
var response = await controller.GetAll();
// Assert
Assert.IsInstanceOfType(response, typeof(OkNegotiatedContentResult <ProductsResponseDto>));
}
public async Task ProductsControllerV1_GetAll_ReturnsOk()
{
// arrange
var service = InfrastructureBuilder.GetProductService();
var controller = new ProductsController(service);
// act
var result = await controller.GetAll();
// assert
Assert.NotNull(result);
Assert.IsType <OkObjectResult>(result);
}
public void Get_All_Returns_AllProducts()
{
// Arrange
mockProductService.Setup(x => x.GetAll()).Returns(fakeProducts);
ProductsController controller = new ProductsController(mockProductService.Object);
// Act
var result = controller.GetAll();
// Assert
Assert.IsNotNull(result, null);
}
public async Task GetAllShouldReturnBadRequestWhenFail()
{
// Arrange
_productInterface.Setup(x => x.GetAll()).ReturnsAsync(new QueryResponseDto <ProductsResponseDto>("Error!"));
var controller = new ProductsController(_productInterface.Object);
// Act
var response = await controller.GetAll();
// Assert
Assert.IsInstanceOfType(response, typeof(BadRequestErrorMessageResult));
Assert.AreEqual(((BadRequestErrorMessageResult)response).Message, "Error!");
}
public void GetAllShouldReturnAllProducts()
{
// Given
var expectedProducts = new[] { Constants.Monitor, Constants.Notebook };
A.CallTo(() => _getProductsQuery.Run()).Returns(expectedProducts);
// When
var products = _productController.GetAll();
// Then
Assert.Equal(expectedProducts, products);
A.CallTo(() => _getProductsQuery.Run()).MustHaveHappened();
}
public async Task ProductsControllerV2_GetAll_ReturnsBadRequest_PageSize()
{
// arrange
var service = InfrastructureBuilder.GetProductService();
var controller = new ProductsController(service);
var productParmeters = new ProductParmeters {
PageNumber = 1, PageSize = -1
};
// act
var result = await controller.GetAll(productParmeters);
// assert
Assert.NotNull(result);
Assert.IsType <BadRequestResult>(result);
}
public void GetAllProducts()
{
var productController = new ProductsController(this._productRepositoryMock.Object);
var productCreateModel1 = TestHelper.GetProductModel();
var productCreateModel2 = TestHelper.GetProductModel();
var productCreateModel3 = TestHelper.GetProductModel();
var productCreateModel4 = TestHelper.GetProductModel();
var productList = new[] { productCreateModel1, productCreateModel2, productCreateModel3, productCreateModel4 };
this._productRepositoryMock.Setup(x => x.GetAll())
.Returns(productList);
var actualList = productController.GetAll();
this._productRepositoryMock.Verify(x => x.GetAll(), Times.Once);
Assert.AreSame(productList, actualList);
}
public async Task GetAll_ReturnsJsonResult_WithListofProducts()
{
var mockMediator = new Mock <IMediator>();
mockMediator.Setup(x => x.Send(It.IsAny <FindAllProductsQuery>(), It.IsAny <CancellationToken>())).ReturnsAsync(new List <ProductDto> {
TestProductDtoFactory.Travel()
});
var controller = new ProductsController(mockMediator.Object);
var result = await controller.GetAll();
var jsonResult = Assert.IsType <JsonResult>(result);
var items = Assert.IsType <List <ProductDto> >(jsonResult.Value);
Assert.Single(items);
}
static async Task TestProduct()
{
var prodCtrl = new ProductsController();
var prod = new Product()
{
Id = 0,
Name = "Echo Show 5",
Price = 129.99m,
InStock = true
};
prod = await prodCtrl.Create(prod);
var products = await prodCtrl.GetAll();
var prod2 = await prodCtrl.Get(1);
}
public void GetAll_NumPositiveAndCompletePage_ReturnTenProducts()
{
//Arange
int expected = 10;
int PositiveAndCompleteNumPage = 1;
//Act
List <Products.Models.ProductDTO> products = new List <Products.Models.ProductDTO>();
try
{
var response = pcMock.GetAll(PositiveAndCompleteNumPage);
products = (List <Products.Models.ProductDTO>)((OkObjectResult)response).Value;
}
catch (InvalidCastException)
{
}
//Assert
Assert.AreEqual(expected, products.Count);
}
public void ProductsController_Get_All_Products_Return_Correct_Number()
{
var baskets = new InMemoryDataStore <Basket>();
var products = new InMemoryDataStore <Product>();
products.Seed();
var pc = new ProductsController(products, _mapper);
var actionResult = pc.GetAll();
OkObjectResult okresult = actionResult as OkObjectResult;
Assert.IsNotNull(okresult);
List <ProductDto> resultProducts = okresult.Value as List <ProductDto>;
Assert.IsNotNull(resultProducts);
Assert.AreEqual(resultProducts.Count, 5);
}
