public async Task GetAll_Returns_AllCustomer()
{
// Arrange
mockCustomerService.Setup(service => service.GetAll()).Returns(Task.FromResult <IEnumerable <Customer> >(CustomerFixture.Customers()));
// Act
var results = await controller.GetAll();
// Assert
var objectResult = Assert.IsType <OkObjectResult>(results);
var actuals = Assert.IsAssignableFrom <IEnumerable <Customer> >(objectResult.Value);
Assert.Equal(3, actuals.Count());
}
public void Get_WhenCalled_ReturnsAllItems()
{
var okResult = _controller.GetAll().Result as OkObjectResult;
var items = Assert.IsType <List <Customer> >(okResult.Value);
Assert.Equal(3, items.Count);
}
public async Task CustomerIntegrationTest()
{
// Create DB Context
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.AddEnvironmentVariables()
.Build();
var optionsBuilder = new DbContextOptionsBuilder <CustomerContext>();
optionsBuilder.UseSqlServer(configuration["ConnectionStrings:DefaultConnection"]);
var context = new CustomerContext(optionsBuilder.Options);
// Just to make sure: Delete all existing customers in the DB
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
// Create Controller
var controller = new CustomersController(context);
// Add customer
await controller.Add(new Customer()
{
CustomerName = "FooBar"
});
// Check: Does GetAll return the added customer?
var result = (await controller.GetAll()).ToArray();
Assert.Single(result);
Assert.Equal("FooBar", result[0].CustomerName);
}
public async void GetCustomers_ActionExecutes_ReturnResultWithCustomersDto()
{
_mockService.Setup(x => x.GetAllAsync()).ReturnsAsync(Response <IEnumerable <CustomerDto> > .Success(customers, 200));
var result = await _controller.GetAll();
Assert.IsType <ObjectResult>(result);
}
public async Task GetAll_ReturnOk()
{
var customersResponse = new CustomersResponse()
{
Customers = new List <CustomerDto>()
{
new CustomerDto()
{
Id = 1,
Name = "ООО Рога и Копыта"
},
new CustomerDto()
{
Id = 2,
Name = "АО Пивной дворик"
}
}
};
_mockMediator.Setup(mediator => mediator.Send(It.IsAny <GetAllCustomersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(customersResponse);
var result = await _controller.GetAll();
var resultValue = ((OkObjectResult)result).Value as CustomersResponse;
_mockMediator.Verify(mediator => mediator.Send(It.IsAny <GetAllCustomersQuery>(), It.IsAny <CancellationToken>()), Times.Once);
Assert.Equal(2, resultValue.Customers.Count);
Assert.Equal(1, resultValue.Customers[0].Id);
Assert.Equal("ООО Рога и Копыта", resultValue.Customers[0].Name);
Assert.IsAssignableFrom <IActionResult>(result);
}
public async Task GetAllAsync_ShouldReturn200_WhenCustomerExist()
{
// arrange
_customerRepository.GetCustomers().Returns(_customersList);
// act
var customers = await _customerController.GetAll();
var result = customers as ObjectResult;
// assert
var items = Assert.IsAssignableFrom <IEnumerable <Customer> >(
Assert.IsType <List <Customer> >(result.Value));
Assert.NotNull(result);
Assert.True(result is OkObjectResult);
Assert.Equal(2, items.Count());
Assert.Equal(StatusCodes.Status200OK, result.StatusCode);
}
public void GetAll_ShouldReturnOkWithIListOfCustomerDTOs()
{
mockedCustomerService.Setup(x => x.GetAll(It.IsAny <string>())).Returns(new List <CustomerDTO>());
var controller = new CustomersController(mockedCustomerService.Object);
var response = controller.GetAll() as OkNegotiatedContentResult <IEnumerable <CustomerDTO> >;
Assert.IsNotNull(response);
}
public void GetAllCustomersInLondonTest()
{
// ACT
IHttpActionResult actionResult = _customersController.GetAll("London");
var contentResult = actionResult as OkNegotiatedContentResult <IQueryable <Customer> >;
// ASSERT
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(contentResult.Content.Count(), 6);
}
public async Task TestGetAll()
{
var actionResult = await _controller.GetAll(new Params());
//var result = actionResult.Result as ObjectResult;
var values = actionResult.Value as IEnumerable <Customer>;
//Assert.AreEqual((int)HttpStatusCode.OK, result.StatusCode);
Assert.IsNotNull(values);
Assert.AreEqual(_context.Customers.Count(), values.Count());
}
public async void GetAll_ShouldReturn_ListOfCustomers()
{
var customers = CreateCustomers();
var dtoExpected = MapListCustomerToDto(customers);
_customerRepositoryMock.Setup(c => c.GetAll()).ReturnsAsync(customers);
_mapperMock.Setup(mock => mock.Map <CustomerDto[]>(It.IsAny <List <Customer> >())).Returns(dtoExpected.ToArray());
var result = await _customersController.GetAll();
Assert.Equal(dtoExpected, result);
}
public async Task GetAllCustomers(int page, int pageSize)
{
var controller = new CustomersController(unit.Context);
var response = await controller.GetAll(page, pageSize) as ObjectResult;
var value = response.Value as List <CustomerModel>;
Assert.AreEqual(200, response.StatusCode);
Assert.AreEqual(2, value.Count()); //there are 2 customers in the test database
}
public void Given_No_Customers_When_GetAll_Should_Return_Zero_Customers()
{
var customers = new List <Customer> {
};
var result = Result <IEnumerable <Customer>, HttpErrorCode> .Ok(customers);
_mockManager.GetAll().Returns(result);
var controller = new CustomersController(_mockManager);
var actualResult = controller.GetAll() as OkObjectResult;
Assert.IsNotNull(actualResult);
Assert.AreEqual(200, actualResult.StatusCode);
var acutalCustomers = ((List <Customer>)actualResult.Value);
Assert.AreEqual(0, acutalCustomers.Count);
}
public void GetAll_NoClaim_ReturnStatus500()
{
// Arrange
var customerRepositoryMock = new Mock <ICustomerRepository>();
var controller = new CustomersController(customerRepositoryMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
controller.ControllerContext.HttpContext.User = new ClaimsPrincipal(new List <ClaimsIdentity>());
// Act
var result = controller.GetAll();
// Assert
Assert.IsType <JsonResult>(result);
Assert.True(result.StatusCode == StatusCodes.Status500InternalServerError);
customerRepositoryMock.Verify(foo => foo.GetAll(string.Empty), Times.Never());
}
public void GetAll_AdminClaim_RepositoryIsCalled()
{
// Arrange
var customerRepositoryMock = new Mock <ICustomerRepository>();
var controller = new CustomersController(customerRepositoryMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var claimsIdentity = new ClaimsIdentity();
claimsIdentity.AddClaim(new Claim(Constants.AdminClaimTypeName, string.Empty));
controller.ControllerContext.HttpContext.User = new ClaimsPrincipal(claimsIdentity);
// Act
var result = controller.GetAll();
// Assert
var jsonResult = Assert.IsType <JsonResult>(result);
Assert.NotNull(jsonResult.Value);
customerRepositoryMock.Verify(foo => foo.GetAll(string.Empty), Times.Once());
}
public void Given_Customers_When_GetAll_Should_Return_All_Customers()
{
var customers = new List <Customer> {
new Customer {
Id = 1, Name = "Tom"
}, new Customer {
Id = 2, Name = "Harry"
}
};
var result = Result <IEnumerable <Customer>, HttpErrorCode> .Ok(customers);
_mockManager.GetAll().Returns(result);
var controller = new CustomersController(_mockManager);
var actualResult = controller.GetAll() as OkObjectResult;
Assert.IsNotNull(actualResult);
Assert.AreEqual(200, actualResult.StatusCode);
var acutalCustomers = ((List <Customer>)actualResult.Value);
Assert.AreEqual(2, acutalCustomers.Count);
Assert.IsTrue(acutalCustomers.Any(c => c.Id == customers[0].Id && c.Name == customers[0].Name));
Assert.IsTrue(acutalCustomers.Any(c => c.Id == customers[1].Id && c.Name == customers[1].Name));
}
public void ShouldGetAllCustomers()
{
ICustomerAdapter adapter = Substitute.For <ICustomerAdapter>();
IEnumerable <CustomerData> data = new List <CustomerData>()
{
new CustomerData()
};
adapter.GetCustomers().Returns(data);
using (CustomersController controller = new CustomersController(adapter))
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "~/api/customers"))
{
request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
HttpResponseMessage response = controller.GetAll(request);
Assert.IsInstanceOfType(response.Content, typeof(ObjectContent <CustomerData[]>), "An array of customer data wasn't returned.");
ObjectContent <CustomerData[]> content = (ObjectContent <CustomerData[]>)response.Content;
CustomerData[] results = (CustomerData[])content.Value;
Assert.AreEqual(1, results.Length, "There should have been one customer.");
Assert.AreSame(data.First(), results[0], "The wrong customer was returned.");
adapter.Received().GetCustomers();
}
}
public void ReturnOk()
{
var actual = sut.GetAll();
actual.Result.Should().BeOfType <OkObjectResult>();
}
