public void GetCustomerReturnsCustomerByIdTest()
{
var okResult = _controller.GetCustomer(new Guid("ab2bd817-98cd-4cf3-a80a-53ea0cd9c200")).Result as OkObjectResult;
var customer = Assert.IsType <Entities.Customer>(okResult?.Value);
Assert.Equal("James", customer.FirstName);
Assert.Equal("Smith", customer.LastName);
}
public void GetCustomerById_CustomerIsNull_ReturnsNotFound(int id)
{
_mockContainer.Setup(x => x.Get(id)).Returns(_customerServiceModel);
var result = custController.GetCustomer(id);
Assert.True(result.GetType().Equals(typeof(NotFoundResult)));
}
public void getCustomer_CustomerProvided_ReturnsCustomer()
{
var customer = new Customer();
_mockRepository.Setup(r => r.GetCustomer(1)).Returns(customer);
var result = _controller.GetCustomer(1);
result.Should().BeOfType <OkNegotiatedContentResult <Customer> >();
}
public async Task GetCustomer_ShouldReturnBadRequest_WhenModelStateIsInvalid()
{
//Arrange
_customersController.ModelState.AddModelError("Error", "Modal State is invalid");
//Act
var result = await _customersController.GetCustomer(5);
//Assert
Assert.IsType <BadRequestObjectResult>(result);
}
public void TestGetCustomer()
{
// arrange
// act
var response = _controller.GetCustomer("CUST1").Result as OkNegotiatedContentResult <Customer>;;
var customer = response.Content;
// assert
Assert.IsTrue(customer.CustomerID == "CUST1");
}
public void Get_WhenCalled_ReturnsOkResult()
{
// Arrange
_auth.IsAuthenticated(null).Returns(true);
// Act
var okResult = _controller.GetCustomer().Result;
// Assert
Assert.IsType<OkObjectResult>(okResult.Result);
}
public async void GetCustomer_ReturnsNotFound_WhenCustomerCannotBeFound()
{
// Arange
var notACustomer = 1;
mockMediator.Setup(x => x.Send(It.IsAny <Get.Query>(), default(CancellationToken))).ReturnsAsync((Get.QueryResult)null);
// Act
var actualResult = await sut.GetCustomer(notACustomer);
// Assert
actualResult.Should().BeOfType <NotFoundResult>();
}
public void Should_GetCustomer()
{
Customer testCustomer = new Customer
{
Id = 1,
UserId = Guid.NewGuid().ToString(),
Address1 = "Addr1",
Address2 = "Addr2",
Address3 = "Addr3",
Address4 = "Addr4",
Address5 = "Addr5",
ContactEmail = "*****@*****.**",
ContactPhone = "01234567898",
FirstName = "First",
LastName = "Last"
};
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
mock.Setup(f => f.Customers.GetById(1)).Returns(testCustomer);
CustomersController controller = new CustomersController(mock.Object, null);
var customer = controller.GetCustomer(1);
Assert.IsType <OkObjectResult>(customer);
}
public async Task GetCustomer_ValidId_ReturnsOk()
{
var customer = new CustomerDto()
{
Id = 1, Name = "Elon Musk", Email = "*****@*****.**"
};
var mockRepository = Substitute.For <ICustomersRepository>();
mockRepository.GetCustomerAsync(customer.Id).Returns(customer);
var controller = new CustomersController(mockRepository);
var response = await controller.GetCustomer(customer.Id);
response.Should().NotBeNull();
response.Result.Should().BeOfType <OkObjectResult>()
.Which.StatusCode.Should().Be((int)HttpStatusCode.OK);
var ok = response.Result as OkObjectResult;
ok.Value.Should().BeOfType <CustomerDto>();
ok.Value.Should().BeEquivalentTo(customer,
opt => opt.IgnoringCyclicReferences().Excluding(c => c.Orders));
await mockRepository.Received().GetCustomerAsync(customer.Id);
}
public void TestController()
{
DbConnection effortConnection = DbConnectionFactory.CreatePersistent("MyInstanceName");
var context = new CustomerModel(effortConnection);
Transaction tr = new Transaction {
ID = 200, Amount = 200, Currency = "USD", Datetime = new DateTime(), Status = "Success"
};
var transactionsList = new LinkedList <Transaction>();
transactionsList.AddFirst(tr);
Customer user = new Customer {
ID = 41, Name = "us1", Email = "*****@*****.**", MobileNo = 345346364346, Transactions = transactionsList
};
var mockHttpContext = new Mock <HttpRequestMessage>();
var mockRequest = new Mock <HttpRequestMessage>();
mockRequest.Object.Content = new StringContent("{ \"ID\" : 41 }");
context.Customers.Add(user);
context.SaveChanges();
var ctrl = new CustomersController(context);
var contentResult = ctrl.GetCustomer(mockRequest.Object) as OkNegotiatedContentResult <Customer>;
var returnedCustomer = contentResult.Content;
var returnedTransactions = returnedCustomer.Transactions;
Assert.AreEqual(returnedCustomer, user);
Assert.AreEqual(returnedTransactions, transactionsList);
}
public void TestGetCustomer()
{
string date = DateTime.Now.ToString();
Moip.Models.CustomerRequest customerRequest = Helpers.RequestsCreator.CreateCustomerRequest(date);
string customerId = controller.CreateCustomer(customerRequest).Id;
Moip.Models.CustomerResponse customerResponse = controller.GetCustomer(customerId);
Assert.NotNull(customerResponse.Id, "Id should not be null");
Assert.AreEqual("OFulanoDeTal" + date, customerResponse.OwnId, "Should match exactly (string literal match)");
Assert.AreEqual("Fulano de Tal", customerResponse.Fullname, "Should match exactly (string literal match)");
Assert.AreEqual("1990-01-01", customerResponse.BirthDate, "Should match exactly (string literal match)");
Assert.AreEqual("*****@*****.**", customerResponse.Email, "Should match exactly (string literal match)");
Assert.AreEqual("Rua test", customerResponse.ShippingAddress.Street, "Should match exactly (string literal match)");
Assert.AreEqual("123", customerResponse.ShippingAddress.StreetNumber, "Should match exactly (string literal match)");
Assert.AreEqual("Ap test", customerResponse.ShippingAddress.Complement, "Should match exactly (string literal match)");
Assert.AreEqual("Bairro test", customerResponse.ShippingAddress.District, "Should match exactly (string literal match)");
Assert.AreEqual("TestCity", customerResponse.ShippingAddress.City, "Should match exactly (string literal match)");
Assert.AreEqual("SP", customerResponse.ShippingAddress.State, "Should match exactly (string literal match)");
Assert.AreEqual("BRA", customerResponse.ShippingAddress.Country, "Should match exactly (string literal match)");
Assert.AreEqual("01234000", customerResponse.ShippingAddress.ZipCode, "Should match exactly (string literal match)");
Assert.AreEqual("55", customerResponse.Phone.CountryCode, "Should match exactly (string literal match)");
Assert.AreEqual("11", customerResponse.Phone.AreaCode, "Should match exactly (string literal match)");
Assert.AreEqual("66778899", customerResponse.Phone.Number, "Should match exactly (string literal match)");
Assert.AreEqual("CPF", customerResponse.TaxDocument.Type, "Should match exactly (string literal match)");
Assert.AreEqual("33333333333", customerResponse.TaxDocument.Number, "Should match exactly (string literal match)");
}
public async Task GetCustomer_Test()
{
string userid = "google-1";
// Arrange
var mockService = new Mock <ICustomersService>();
mockService.Setup(x => x.GetCustomerByUsername(userid))
.Returns(Task.FromResult(new CustomerPoco {
UserId = "google-1"
}));
// Arrange
var controller = new CustomersController(mockService.Object);
// Act
IActionResult actionResult = await controller.GetCustomer(userid);
// Assert
var contentResult = actionResult as OkObjectResult;
Assert.NotNull(contentResult);
var customer = contentResult.Value as CustomerPoco;
Assert.Equal(userid, customer.UserId);
}
public void GetCustomerShouldReturnCustomerWhenFound()
{
// ARRANGE
mockCustomerService.Setup(cs => cs.GetById(1)).Returns(new CustomerDTO.WithRelations
{
Id = 1
});
// ACT
var result = customerController.GetCustomer(1) as OkNegotiatedContentResult <CustomerDTO.WithRelations>;
// ASSERT
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <CustomerDTO.WithRelations>));
Assert.IsNotNull(result.Content);
Assert.IsTrue(result.Content.Id == 1);
}
public async Task GetCustomer_ReturnsNotFound_GivenInvalidId()
{
var controller = new CustomersController(_context);
var result = await controller.GetCustomer(99);
Assert.IsType <NotFoundResult>(result);
}
public async Task IdOfNonExistentCustomer_GetCustomer_ReturnNotFound()
{
const int customerId = -1;
var response = await _customerController.GetCustomer(customerId);
Assert.IsType <ActionResult <CustomerModel> >(response);
Assert.IsType <NotFoundResult>(response.Result);
}
public void GetCustomerById_CustomerIsNull_ReturnsInternalError(int id)
{
custController = new CustomersController(null, null, _logger.Object);
var result = custController.GetCustomer(id);
Assert.IsType <StatusCodeResult>(result);
var objectResponse = result as StatusCodeResult;
Assert.Equal(500, objectResponse.StatusCode);
}
public async Task GetCustomer_InvalidId_ReturnsNotFound()
{
var mockRepository = Substitute.For <ICustomersRepository>();
mockRepository.GetCustomerAsync(Arg.Any <int>()).Returns((CustomerDto)null);
var controller = new CustomersController(mockRepository);
var response = await controller.GetCustomer(1);
ActAndAssertForNotFoundResponse(response, controller);
}
public void GetCustomerTest()
{
// Arrange
// Act
var data = _controller.GetCustomer("ANATR").Result as OkNegotiatedContentResult <Customer>;
var result = data.Content;
// Assert
Assert.IsTrue(result.ContactName == "Ana Trujillo");
}
public async Task GetCustomer_ReturnsCustomer_GivenValidId()
{
var controller = new CustomersController(_context);
var result = await controller.GetCustomer(2);
var objectResult = Assert.IsType <OkObjectResult>(result);
var customer = Assert.IsAssignableFrom <Customer>(objectResult.Value);
Assert.Equal("Summer Smith", customer.Name);
}
public void GetCustomer_ShouldReturnItemWithSameID()
{
var context = new CustomersWebApiContext();
context.Customers.Add(GetTestCustomers());
var controller = new CustomersController(context);
var result = controller.GetCustomer(3) as OkNegotiatedContentResult <Customer>;
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Content.Id);
}
public void GetCustomerIdShouldNot()
{
// Arrange
int id = 1005;
CustomersController controller = new CustomersController();
// Act
IHttpActionResult actionResult = controller.GetCustomer(id);
// Assert
Assert.IsType <NotFoundResult>(actionResult);
}
public void Can_get_Customer()
{
SeedOptions();
using (var context = new CustomerContext(ContextOptions))
{
var controller = new CustomersController(context);
var result = controller.GetCustomer(1);
Assert.Equal(1, result.Id);
}
}
public async Task TestGetCustomerAsync()
{
var dbContext = DbContextMocker.GetContext(nameof(this.TestGetCustomerAsync));
var customersRepository = new CustomersRepository(dbContext);
var customerService = new CustomersService(customersRepository, null);
var controller = new CustomersController(customerService, AutoMapperConfiguration.ConfigureForWeb().CreateMapper());
var response = await controller.GetCustomer(1);
var value = response.Value;
dbContext.Dispose();
Assert.Equal("John Johnson", value.CustomerName);
}
public void GetCustomerIdShould()
{
// Arrange
int id = 1;
CustomersController controller = new CustomersController();
// Act
IHttpActionResult actionResult = controller.GetCustomer(id);
var contentResult = actionResult as OkNegotiatedContentResult <Customer>;
// Assert
Assert.NotNull(contentResult);
Assert.NotNull(contentResult.Content);
Assert.Equal(id, contentResult.Content.ID);
}
public void GetCustomerShould()
{
// Arrange
DBEntities db = new DBEntities();
CustomersController controller = new CustomersController();
// Act
IQueryable <Customer> expected = db.Customer;
IQueryable <Customer> actual = controller.GetCustomer();
// Assert
Assert.True(actual != null);
Assert.Equal(expected.Count(), actual.Count());
}
public async Task TestGetCustomerUnitAsync()
{
var customerService = new Mock <ICustomersService>();
customerService.Setup(repo => repo.GetCustomer(It.IsAny <int>())).ReturnsAsync(new Customer()
{
CustomerName = "Test"
});
var controller = new CustomersController(customerService.Object, AutoMapperConfiguration.ConfigureForWeb().CreateMapper());
var response = await controller.GetCustomer(1);
var value = response.Value;
Assert.NotNull(value);
}
public void GetCustomers_ReturnsAllCustomers()
{
var mockRepo = new Mock <ICustomerRepository>();
var logger = Mock.Of <ILogger <CustomersController> >();
mockRepo.Setup(m => m.GetAll()).Returns(Task.FromResult(GetCustomers()));
var customersController = new CustomersController(mockRepo.Object, logger);
var response = customersController.GetCustomer();
Assert.IsNotNull(response);
Assert.IsInstanceOfType(response.Result, typeof(OkObjectResult));
}
private void getCustomerButton_Click(object sender, EventArgs e)
{
try
{
int customerId = Convert.ToInt32(idTextBox.Text);
Customer c = CustomersController.GetCustomer(customerId);
firstNameTextBox.Text = c.GetFirstName();
lastNameTextBox.Text = c.GetLastName();
phoneTextBox.Text = c.GetPhoneNumber();
emailTextBox.Text = c.GetEmailAddress();
}
catch
{
MessageBox.Show(idNoSuccssString);
}
}
public void GetCustomer_ShouldReturnCustomer_WhenCustomerExists()
{
//Arrange
var customerId = 1;
var customerMock = new Mock <Customer>(customerId);
_unitOfWork.Setup(x => x.Customers.Get(customerId)).Returns(customerMock.Object);
//Act
var result = controller.GetCustomer(customerId);
var okResult = result as OkObjectResult;
var cusDto = okResult.Value as CustomerDto;
//Assert
Assert.NotNull(okResult);
Assert.Equal(200, okResult.StatusCode);
Assert.Equal(customerId, cusDto.Id);
}
public async Task GetCustomerById_ActionExecute_ReturnCustomerById()
{
// Arrange
int id = 1;
_mockrepo.Setup(repo => repo.Customer.GetCustomerById(id))
.ReturnsAsync(GetTestCustomers().FirstOrDefault(
c => c.Id == id));
// Act
var result = await _controller.GetCustomer(id);
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
var customer = Assert.IsType <CustomerViewModel>(okResult.Value);
Assert.Equal(id, customer.Id);
Assert.Equal("Trang Uyen", customer.Name);
}
