public async System.Threading.Tasks.Task RetournerStatutOkRecherchePizzaById(int id)
{
var actionResult = await _controllerC.GetById(id, "");
var result = actionResult.Result as ObjectResult;
Assert.AreEqual((int)System.Net.HttpStatusCode.OK, result.StatusCode);
}
public void GetCustomersById()
{
GetReady();
var actRes = controller.GetById(1);
var response = actRes.ExecuteAsync(CancellationToken.None).Result;
Assert.IsNotNull(response.Content);
}
public void GetById_WhenExistingIdPassed_ShouldReturnCorrectItem()
{
// Arrange
var testDataContext = new DataFileData {
Customers = _testCustomers
};
var customersRepository = new CustomersRepository(new DatabaseFactory(testDataContext));
var customersServicesInst = new CustomersServices(customersRepository);
//var mockStaticLoggerInstWrapper = new Mock<IStaticLoggerInstanceWrapper>();
var customersController = new CustomersController(customersServicesInst);
// Act
var response = customersController.GetById(2);
// Assert
Assert.IsNotNull(response);
Assert.IsInstanceOfType(response, typeof(OkObjectResult));
var foundCustomer = (Customer)((OkObjectResult)response).Value;
Assert.IsInstanceOfType(foundCustomer, typeof(Customer));
}
public async Task TestGetBYId()
{
var actionResult = await _controller.GetById(2, "");
var result = actionResult.Result as ObjectResult;
var okResult = result.Should().BeOfType <OkObjectResult>().Subject;
}
public void ControllerGetCustomerInvalidId()
{
var controller = new CustomersController();
var response = controller.GetById(25);
var result = (NotFoundResult)response;
Assert.IsNotNull(result);
}
public void ControllerGetCustomerSuccess()
{
var controller = new CustomersController();
var response = controller.GetById(1);
var result = (OkNegotiatedContentResult <CustomerModel>)response;
Assert.IsNotNull(result);
Assert.IsNotNull(result.Content);
}
public void GetById_WithValidId_ShouldReturnOkWithCustomerDTO()
{
mockedCustomerService.Setup(x => x.GetById(It.IsAny <string>())).Returns(new CustomerDTO());
var controller = new CustomersController(mockedCustomerService.Object);
var response = controller.GetById(string.Empty) as OkNegotiatedContentResult <CustomerDTO>;
Assert.IsNotNull(response);
}
public void GetById_WithInvalidId_ShouldReturnBadRequestWithMessage()
{
mockedCustomerService.Setup(x => x.GetById(It.IsAny <string>())).Returns((CustomerDTO)null);
var controller = new CustomersController(mockedCustomerService.Object);
var response = controller.GetById(string.Empty) as BadRequestErrorMessageResult;
Assert.IsNotNull(response);
}
public void GetById_ReturnsSingleCustomerDetails_AsExpected()
{
// Arrrange
mockService.Setup(x => x.GetCustomerById(customers.LastOrDefault().Id)).Returns(customers.LastOrDefault());
// Act
var response = underTest.GetById(customers.LastOrDefault().Id) as ObjectResult;
// Assert
Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
Assert.AreEqual(customers.LastOrDefault(), response.Value);
}
public void ThenANotFoundResponseIsReturned()
{
var customersRepository = new Mock <ICustomersRepository>();
customersRepository.Setup(mock => mock.GetById(1)).Returns(default(Customer));
var subject = new CustomersController(customersRepository.Object);
var result = subject.GetById(1);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.TypeOf <NotFoundResult>());
}
public async Task Get_shouldReturnNotFoundWhenPersonIdNotExists()
{
Customer customer = null;
string anyCpf = "04107332020";
Moq.Mock <ICustomerService> mockCustomerService = new Moq.Mock <ICustomerService>();
mockCustomerService.Setup(customerService => customerService.GetAsync(It.IsAny <string>())).Returns(Task.FromResult(customer));
var customerController = new CustomersController(mockCustomerService.Object);
var response = await customerController.GetById(anyCpf);
Assert.IsType <NotFoundResult>(response.Result);
}
public void Return_notfound_getting_an_unknown_customer_id()
{
//Arrange
var repoLogger = new Mock <ILogger <CustomersRepository> >();
var inMemRepo = new CustomersRepository(repoLogger.Object);
var controllerLogger = new Mock <ILogger <CustomersController> >();
var controller = new CustomersController(inMemRepo, controllerLogger.Object);
//Act
var response = controller.GetById(Guid.NewGuid());
// Assert
Assert.IsType <NotFoundResult>(response);
}
public async Task ForCustomer_ReturnHttpNotFound_ForInvalidId()
{
// Arrange
int invalidId = 99999;
var mockLogger = new Mock <ILogger <CustomersController> >();
var mockRepository = new Mock <ICustomerRepository>();
var controller = new CustomersController(mockLogger.Object, mapper, mockRepository.Object);
// Act
var result = await controller.GetById(invalidId);
// Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result.Result);
Assert.Equal(invalidId, notFoundObjectResult.Value);
}
public async Task Get_shouldReturnBadRequestWhenPersonIdIsInvalid()
{
Customer customer = new Customer()
{
Cpf = "1",
Name = "Ramires",
State = "RJ"
};
Moq.Mock <ICustomerService> mockCustomerService = new Moq.Mock <ICustomerService>();
mockCustomerService.Setup(customerService => customerService.GetAsync(It.IsAny <string>())).Returns(Task.FromResult(customer));
var customerController = new CustomersController(mockCustomerService.Object);
var response = await customerController.GetById(customer.Cpf);
Assert.IsType <BadRequestObjectResult>(response.Result);
}
public async Task Action_GetCustomerByValidId_ReturnsNotFound()
{
//Arrange
var customerId = _customerId;
_mockCustomerService.Setup(serv => serv.IsCustomerIdValid(customerId))
.Returns(PropertyIsValid);
_mockCustomerService.Setup(serv => serv.GetDataByIdAsync(int.Parse(customerId)))
.ReturnsAsync((CustomerViewModel)null);
var controller = new CustomersController(_mockCustomerService.Object);
//Act
var result = await controller.GetById(customerId.ToString());
//Assert
Assert.IsType <NotFoundResult>(result);
}
public async Task Action_GetCustomerByInValidId_ReturnsBadRequestAndMessage()
{
//Arrange
var customerId = _customerId;
var messageValue = "Invalid Customer ID";
_mockCustomerService.Setup(serv => serv.IsCustomerIdValid(customerId))
.Returns(PropertyIsInValid);
var controller = new CustomersController(_mockCustomerService.Object);
//Act
var result = await controller.GetById(customerId.ToString());
var value = (result as BadRequestObjectResult).Value;
//Assert
Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal(value, messageValue);
}
public void TestGetCustomerById_ShouldReturnAValidCustomerWhenGivenAValidId()
{
//Arrange
var customersControllerUnderTest = new CustomersController();
const int idUnderTest = 1;
//Act
var returnedResult = customersControllerUnderTest.GetById(idUnderTest);
//Assert
Assert.IsNotNull(returnedResult, $"The GetbyId method didn't return any customer for ID= {idUnderTest}");
Assert.AreEqual(returnedResult.GetType(), typeof(ObjectResult),
$"The GetbyId returned type: {returnedResult.GetType()} instead of {typeof(ObjectResult)}");
Assert.IsInstanceOfType((returnedResult as ObjectResult).Value, typeof(Customer),
$"The object result returned GetbyId contains type: {(returnedResult as ObjectResult).Value.GetType()} instead of {typeof(Customer)}");
Customer returnedCustomer = (Customer)(returnedResult as ObjectResult).Value;
Assert.AreEqual(idUnderTest, returnedCustomer.Id,
$"The customer result returned GetbyId has Id: {returnedCustomer.Id} instead of {idUnderTest}");
}
public void SetUp()
{
_customer = new Customer
{
Id = 1,
FirstName = "Customer",
LastName = "One",
Email = "*****@*****.**",
Password = "******"
};
var customersRepository = new Mock <ICustomersRepository>();
customersRepository.Setup(mock => mock.GetById(1)).Returns(_customer);
var subject = new CustomersController(customersRepository.Object);
_result = subject.GetById(1) as OkObjectResult;
}
public async Task ForCustomer_ReturnCustomer_ForValidId()
{
// Arrange
int validId = 9;
var mockLogger = new Mock <ILogger <CustomersController> >();
var mockRepository = new Mock <ICustomerRepository>();
mockRepository.Setup(repo => repo.GetByIdAsync(validId))
.ReturnsAsync(GetTestCustomer(validId));
var controller = new CustomersController(mockLogger.Object, mapper, mockRepository.Object);
// Act
var result = await controller.GetById(validId);
// Assert
var apiResult = Assert.IsType <OkObjectResult>(result.Result);
var model = Assert.IsAssignableFrom <CustomerGetViewModel>(apiResult.Value);
Assert.Equal(validId, model.Id);
}
public async Task Get_shouldGetCustomerById()
{
Customer customer = new Customer()
{
Cpf = "64985418064",
Name = "Ramires",
State = "RJ"
};
Moq.Mock <ICustomerService> mockCustomerService = new Moq.Mock <ICustomerService>();
mockCustomerService.Setup(customerService => customerService.GetAsync(It.IsAny <string>())).Returns(Task.FromResult(customer));
var customerController = new CustomersController(mockCustomerService.Object);
var response = await customerController.GetById(customer.Cpf);
var okObjetResult = Assert.IsType <OkObjectResult>(response.Result);
Assert.IsType <Customer>(okObjetResult.Value);
Assert.Equal(customer, (okObjetResult.Value));
}
public void GetById_WhenPassedUnknownId_ShouldReturnNotFoundResult()
{
// Arrange
var testDataContext = new DataFileData {
Customers = _testCustomers
};
var customersRepository = new CustomersRepository(new DatabaseFactory(testDataContext));
var customersServicesInst = new CustomersServices(customersRepository);
//var mockStaticLoggerInstWrapper = new Mock<IStaticLoggerInstanceWrapper>();
var customersController = new CustomersController(customersServicesInst);
// Act
var response = customersController.GetById(0);
// Assert
Assert.IsNotNull(response);
Assert.IsInstanceOfType(response, typeof(NotFoundResult));
}
public async Task Action_GetCustomerByValidId_ReturnsJsonResult_Code200AndData()
{
//Arrange
var customerId = "1";
int code200 = StatusCodes.Status200OK;
_mockCustomerService.Setup(serv => serv.GetDataByIdAsync(int.Parse(customerId)))
.ReturnsAsync(GetCustomer);
_mockCustomerService.Setup(serv => serv.IsCustomerIdValid(customerId))
.Returns(PropertyIsValid);
var controller = new CustomersController(_mockCustomerService.Object);
//Act
var result = await controller.GetById(customerId.ToString());
var code = (result as JsonResult).Value.GetType().GetProperty("StatusCode").GetValue((result as JsonResult).Value);
//Assert
Assert.IsType <JsonResult>(result);
Assert.Equal(code200, code);
}
public void Return_one_customer()
{
//Arrange
var repoLogger = new Mock <ILogger <CustomersRepository> >();
var inMemRepo = new CustomersRepository(repoLogger.Object);
var controllerLogger = new Mock <ILogger <CustomersController> >();
var controller = new CustomersController(inMemRepo, controllerLogger.Object);
//Act
var response = controller.GetById(new Guid("65e51c54-21c5-41e8-8e22-21500379b275"));
var viewResult = Assert.IsType <OkObjectResult>(response).Value;
var customer = (Customer)viewResult;
// Assert
Assert.Equal(typeof(OkObjectResult), response.GetType());
var checkCustomer = inMemRepo.GetListOf(c => c.Id == new Guid("65e51c54-21c5-41e8-8e22-21500379b275"))
.SingleOrDefault();
Assert.NotNull(checkCustomer);
Assert.Equal(checkCustomer.Id, customer.Id);
}
