public async Task Get_AllProducts_CallsService_ReturnsOk() { var products = new List <Product>() { new Product() { Name = "Virus" }, new Product() { Name = "Cold" } }; _productService .Setup(call => call.GetProducts(It.IsAny <string>())) .Returns(Task.FromResult(products.AsEnumerable())) .Verifiable(); var result = await _productsController.Get(); var items = result.Items; Assert.That(items.Count, Is.EqualTo(2)); }
public void GetAllProducts_ReturnProductsById() { // Arrange var productservice = Substitute.For <IProductService>(); int _id = 13860428; var productlist = Productslist().Where(a => a.Id == _id).FirstOrDefault(); productservice.GetById(_id).Returns(productlist); productservice.GetProductNameandPrice(productlist, true).Returns(productlist); var productcontroller = new ProductsController(productservice) { Request = new HttpRequestMessage(), Configuration = new HttpConfiguration() }; // Act var productsfromcontroller = productcontroller.Get(_id).Content.ReadAsStringAsync().Result; JObject jObject = JObject.Parse(productsfromcontroller); var products = productcontroller.Get(_id); Assert.IsTrue(products.TryGetContentValue <Products>(out Products product)); // Assert Assert.AreEqual(productlist.ProductName, product.ProductName); Assert.AreEqual(_id, jObject["Id"]); }
public void GetTest() { var result = _productsController.Get(); var okResult = Assert.IsType <OkObjectResult>(result); Assert.IsType <List <Product> >(okResult.Value); }
public void GetByIdSuccessTest() { bus.Setup(w => w.RequestAsync <string, ProductModel>(It.IsAny <string>())).Returns(Task.FromResult(new ProductModel())); var result = productsController.Get(123); Assert.IsInstanceOfType(result, typeof(Task <ActionResult>)); }
public void GetProduct_ReturnProductSameID() { //arrange // these two lines are the moq equivalent of this: // var context = new TestStoreAppContext(); // context.Products.Add(GetDemoProduct()); var mockContext = new Mock <IBookStoreAppContext>(); mockContext.Setup(x => x.Get(3)).Returns(GetDemoProduct()); // act // sut (system under test) var sut = new ProductsController(mockContext.Object); // assert // try to get an object that doesn't exist and we should get a not found var result = sut.Get(1); Assert.IsInstanceOfType(result, typeof(NotFoundObjectResult)); var httpResult = sut.Get(3) as OkObjectResult; var product = httpResult.Value as Product; // trying to get a product that exists should return our demo object // this could have been done in a better way than comparing field by field...but time Assert.AreEqual(product.Id, GetDemoProduct().Id); Assert.AreEqual(product.Name, GetDemoProduct().Name); Assert.AreEqual(product.Price, GetDemoProduct().Price); }
public void UpdatesProductCorrectly() { using (var context = new ProductContext(optionsBuilder.Options)) { context.Database.EnsureCreated(); ProductsController productsController = new ProductsController(context, mapper); Guid id = new Guid("2136EAAD-4D96-435C-ABCC-7A3B549CFCDD"); var productInitial = productsController.Get(id); ProductDto productDtoInitial = (productInitial.Result as OkObjectResult).Value as ProductDto; Assert.That("Asus", Is.Not.EqualTo(productDtoInitial.Description)); var statusUpdated = productsController.UpdateDescription(id, "Asus"); Assert.That(statusUpdated, Is.InstanceOf(typeof(NoContentResult))); Assert.That((statusUpdated as NoContentResult).StatusCode, Is.EqualTo(204)); var productUpdated = productsController.Get(id); ProductDto productDtoUpdated = (productUpdated.Result as OkObjectResult).Value as ProductDto; Assert.That("Asus", Is.EqualTo(productDtoUpdated.Description)); } }
public void Get_Returns_All() { // Act var results = _controller.Get() as ActionResult <IEnumerable <Product> >; // Assert var items = Assert.IsType <ActionResult <IEnumerable <Product> > >(results); //Assert.Equal(3, results.Value.Count()); }
public void GetAllProducts() { TestHelper.InitDatabase(); GetReady(); var actRes = controller.Get(); var response = actRes.ExecuteAsync(CancellationToken.None).Result; Assert.IsNotNull(response.Content); }
public void GetProductById() { GetReady(); var actRes = controller.Get(1); var response = actRes.ExecuteAsync(CancellationToken.None).Result; Assert.IsNotNull(response.Content); }
public void GetById_ExistingIdPassed_ReturnsOkResult() { // Act var okResult = _controller.Get(1); // Assert Assert.IsType <OkObjectResult>(okResult); }
public async Task GetAllProducts_ShouldReturnTwoItems() { //Act var result = await _controller.Get(); //Assert result.Should().BeOfType <List <ProductDto> >(); Assert.AreEqual(2, result.Count); }
public async Task ItGetsPagedProducts() { var mock = new PagedResultDto <ProductDto>(Mock.Of <List <ProductDto> >(), Mock.Of <PagerDto>()); service.Setup(s => s.GetAsync(It.IsAny <PagerDto>(), It.IsAny <short>())).ReturnsAsync(mock); var result = await ctrl.Get((short)1); Assert.IsType <PagedResultDto <ProductDto> >(result); }
public void Get_gets_all_Products_via_service() { //Act var products = _Controller.Get(); //Assert Assert.IsNotNull(products); Assert.AreEqual(products.Items.Count, 2); }
public async Task GetProducts_NoUserId_RequestsAllProducts() { //Arrange //Act ActionResult <List <Product> > response = await _classUnderTest.Get(0); //Assert _productsProviderMock.Verify(x => x.GetFoodProductsByCarbs()); }
public void GetAll_ReturnsSuccess() { //act var result = ProductsController.Get() as OkNegotiatedContentResult <IQueryable <Product> >; //assert A.CallTo(() => ProductRepository.Retrieve()).MustHaveHappened(); Assert.NotNull(result); Assert.Equal(result.Content, MockedProducts); }
public async Task given_invalid_id_product_should_not_be_returned() { var productId = Guid.NewGuid(); var result = await _controller.Get(productId); await _dispatcher.Received().QueryAsync(Arg.Is <GetProduct>( q => q.Id == productId)); result.Value.ShouldBeNull(); }
public void GetActionTest() { var controller = new ProductsController(); Assert.IsType <OkObjectResult>(controller.Get()); foreach (var key in FakeData.Products.Keys) { Assert.IsType <OkObjectResult>(controller.Get(key)); } }
public void Should_Call_GetProducts_On_ProductService() { var actionResult = _productsController.Get(); var result = actionResult as OkObjectResult; result.Should().NotBeNull(); result.Value.Should().NotBeNull(); _mockedService.Verify(r => r.GetProducts(), Times.Once); }
public async void Get_ShouldReturnProduct() { _mockService.Setup(s => s.GetAsync(It.IsAny <string>())).Returns(Task.FromResult(product1)); var result = await _productcController.Get("1"); var objectResult = result.Result as OkObjectResult; Assert.NotNull(objectResult); Assert.Equal(200, objectResult.StatusCode); }
public void GetAllProductsReturnsCorrectListFromRepository() { // Arrange repository.Setup(x => x.GetAll()).Returns(products); // Act var result = sut.Get(); // Assert result.ShouldBe(products); }
public void Test_Get_Product_by_Id_ReturnsOkResult() { var response = _productController.Get(1); Assert.IsType <OkObjectResult>(response.Result); var okResult = response.Result as OkObjectResult; var product = Assert.IsType <ProductDto>(okResult.Value); Assert.Equal("Samsung Galaxy S20", product.Name); }
public async void GetProductsByIdTest() { //Given //When var result = await _controller.Get(1); //Then Assert.NotNull(result); // Test if null Assert.IsType <Product>(result); // Test type Assert.Equal(1, result.Id); // Verify it is the right product }
public void product_delete_returnTrue() { // Arrange ProductsController controller = new ProductsController(new ProductService(new ProductRepository())); var expects = controller.Get(); // Act bool actual = controller.Delete(expects.ToList().LastOrDefault().ProductID); int actualCount = controller.Get().Count(); // Assert Assert.IsTrue(actual); Assert.AreEqual(expects.Count(), actualCount + 1); }
public async Task GetAsync_ProductById() { // Arrange var guid = new Guid(); //var recordNotFoundId = new Guid(); //var exceptionId = new Guid(); var mockIProductService = new Mock <IProductService>(); mockIProductService .Setup(arg => arg.GetProductAsync(guid)) .ReturnsAsync(new Product()); var mockIProductOptionService = new Mock <IProductOptionService>(); var sut = new ProductsController(mockIProductService.Object, mockIProductOptionService.Object); // Act var response = await sut.Get(guid); // Assert Assert.IsType <OkObjectResult>(response); var objectResponse = response as ObjectResult; Assert.Equal(200, objectResponse.StatusCode); // Arrange mockIProductService.Setup(arg => arg.GetProductAsync(guid)) .ThrowsAsync(new RecordNotFoundException(guid, "product")); // Act response = await sut.Get(guid); // Assert Assert.IsType <NotFoundObjectResult>(response); objectResponse = response as ObjectResult; Assert.Equal(404, objectResponse.StatusCode); Assert.Equal($"product not found for the Id {guid}", objectResponse.Value); // Arrange mockIProductService.Setup(arg => arg.GetProductAsync(guid)) .ThrowsAsync(new Exception()); // Act response = await sut.Get(guid); // Assert Assert.IsType <StatusCodeResult>(response); Assert.Equal(500, ((StatusCodeResult)response).StatusCode); }
public void GetAll_Returns_Ok_When_All_Valid() { //Arrange var productList = new List <Product> { new Product { ProductID = 1, ProductName = "milk", ProductDescription = "2%Milk", UnitsInStock = 250, SellPrice = 3.99m, DiscountPercentage = 10, UnitsMax = 1250 }, new Product { ProductID = 2, ProductName = "bread", ProductDescription = "White", UnitsInStock = 1050, SellPrice = 4.99m, DiscountPercentage = 5, UnitsMax = 6250 }, new Product { ProductID = 3, ProductName = "butter", ProductDescription = "unsalted", UnitsInStock = 50, SellPrice = 1.99m, DiscountPercentage = 7, UnitsMax = 500 } }; mockService.Setup(m => m.GetProductList()) .Returns(productList); //Act ActionResult actionResult = controller.Get(); //Asserts Assert.NotNull(actionResult); var result = Assert.IsType <OkObjectResult>(actionResult); List <Product> list = result.Value as List <Product>; Assert.Equal(3, list.Count); }
public async Task GetProducts_ReturnsOkResult_IfProductsFound() { //Arrange var products = _fixture.CreateMany <Product>(3); _productService.Setup(x => x.GetProductByNameAsync(null)).ReturnsAsync(products); //Act var result = await _productsController.Get(); //Assert result.Should().NotBeNull().And.BeAssignableTo <IStatusCodeActionResult>() .Which.StatusCode.Should().Be((int)HttpStatusCode.OK); }
public void GetProductByID() { var target = new ProductsController(this._EFProductRepository, this._MockMapper); var okResult = target.Get(3) as OkObjectResult; var product = (ReturnProductDto)okResult.Value; Assert.Equal(200, okResult.StatusCode); Assert.Equal("TestProduct01", product.Name.ToString()); var badRequestResult = target.Get(4) as BadRequestObjectResult; Assert.Equal(400, badRequestResult.StatusCode); }
public async Task WhenIProvideUserId_ItFiltersTheResults() { var productsController = new ProductsController(new LdClient("key"), new ProductsProvider(_connectionString), new InMemoryUsersProvider()); ActionResult <List <Product> > response0 = await productsController.Get(0); ActionResult <List <Product> > response1 = await productsController.Get(1); var result0 = response0.Result as ObjectResult; var products0 = result0?.Value as List <Product>; var result1 = response1.Result as ObjectResult; var products1 = result1?.Value as List <Product>; Assert.IsTrue(products0.Count > products1.Count); }
public void CanGetAllProducts() { var controller = new ProductsController(db); var result = controller.Get(); Assert.NotNull(result); }
public void get_product_detail_by_id_return_product_detail() { // Arrange int product_id = 2; var mockService = new Mock <IProductService>(); mockService.Setup( service => service.getProductDetail(product_id)) .Returns( new ProductsModel { id = 2, name = "43 Piece dinner Set", gender = "Female", age = "3_to_5", availability = "InStock", brand = "CoolKidz" } ); var controller = new ProductsController(mockService.Object); var expected_product = new ProductsModel { id = 2, name = "43 Piece dinner Set", gender = "Female", age = "3_to_5", availability = "InStock", brand = "CoolKidz" }; //Act var result = controller.Get(product_id); // Assert var user = Assert.IsType <ProductsModel>(result); Assert.Equal("43 Piece dinner Set", user.name); }
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 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 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()); }