public void Handle_PurchaseBookCommand_Customer_Not_Exists()
{
// arrange
var key = MockBuilder.Key;
var command = PurchaseBookCommandMock.Get(key);
// act
var result = Handle(command);
// assert
result.Should().BeTrue();
var customers = MockRepository.Query <Customer>().ToList();
var customerExpected = CustomerMock.Get(key);
customers.Should().BeEquivalentToEntity(MockBuilder.List(customerExpected));
var orders = MockRepository.Query <Order>()
.Include(x => x.Items)
.Include(x => x.Customer)
.ToList();
var orderExpected = OrderMock.Get(key);
orderExpected.Customer = customerExpected;
orders.Should().BeEquivalentToEntity(MockBuilder.List(orderExpected));
}
public void Crud_EntityTest()
{
var customer = CustomerMock.GetCustomer();
_configurationMock.Setup(x => x.GetSection(It.IsAny <string>()))
.Returns(new Mock <IConfigurationSection>().Object);
var entityContext = new EntityContext(_entityOptions);
var unitOfWork = new UnitOfWork(entityContext);
var dapperContext = new DapperContext(_configurationMock.Object);
var customerRepository = new CustomerRepository(entityContext, dapperContext);
customerRepository.Add(customer);
var IsSaveCustomer = unitOfWork.Commit();
customerRepository.Update(customer);
var IsUpdateCustomer = unitOfWork.Commit();
customerRepository.Remove(customer);
var IsRemoverCustomer = unitOfWork.Commit();
Assert.Equal(1, IsSaveCustomer);
Assert.Equal(1, IsUpdateCustomer);
Assert.Equal(1, IsRemoverCustomer);
}
public static void SeedingsData(this AssignmentDbContext assignmentDbContext)
{
if (!assignmentDbContext.Customers.Any() || !assignmentDbContext.Transactions.Any())
{
CustomerMock.MockCustomer(assignmentDbContext);
TransactionMock.MockTransaction(assignmentDbContext);
}
}
public void DeleteCustomer()
{
var id = 1L;
var result = new CustomerMock().DeleteCustomer(id).Result;
Assert.IsTrue(result.Code == Status.Ok, result.Message);
}
public void GetCustomer()
{
var document = "123456";
var result = new CustomerMock().GetCustomer(document).Result;
if (result.Data != null && result.Data.CustId == -1)
{
result.Code = Status.NotFound;
}
Assert.IsTrue(result.Code == Status.Ok || result.Code == Status.NotFound, result.Message);
}
public void Remove_SucessTestAsync()
{
var customer = CustomerViewModelMock.GetCustomer();
_mapperMock.Setup(x => x.Map <Customer>(It.IsAny <CustomerViewModel>()))
.Returns(CustomerMock.GetCustomer());
var customerService = new CustomerService(_customerRepositoryMock.Object,
_viaCEPServiceMock.Object, _domainNotificationMock.Object,
_unitOfWorkMock.Object, _mapperMock.Object);
customerService.Remove(customer);
Assert.NotNull(customer);
}
public void RunOn()
{
CustomerMock customer = new CustomerMock
{
Salary = 1000,
Expenses = 3000
};
CustomerRuleSetMock customerRuleSet = new CustomerRuleSetMock();
IRuleEngine <CustomerMock> customerRuleEngine = RuleEngineFactory.Create <CustomerMock>(customerRuleSet);
IEnumerable <RuleResult> ruleResults = customerRuleEngine.RunOn(customer);
ruleResults.Should().HaveCount(2);
}
public void LoginCustomer()
{
var data = new CustomerAuthModel()
{
Username = "******",
Password = "******"
};
var result = new CustomerMock().LoginCustomer(data).Result;
if (result.Data != null && result.Data.CustId == -1)
{
result.Code = Status.NotFound;
}
Assert.IsTrue(result.Code == Status.Ok, result.Message);
}
public async Task TestCreate()
{
CustomerMock customer = new CustomerMock
{
Email = "*****@*****.**",
Phone = "65421895154",
Lastname = "Maria",
Firstname = "Julia",
Genre = "Autres",
Address = null,
ZipCode = "6854",
City = "Limoges"
};
var actionResult = await _controller.CreateItem(customer);
var result = actionResult.Result as ObjectResult;
var okResult = result.Should().BeOfType <OkObjectResult>().Subject;
}
public async Task GetAddressByIdAsync_ReturnCustomerAddressViewModelTestAsync()
{
int id = 1;
var customerId = CustomerViewModelMock.GetCustomerId(id);
_customerRepositoryMock.Setup(x => x.GetAddressByIdAsync(id))
.ReturnsAsync(CustomerMock.GetCustomerAddress());
_mapperMock.Setup(x => x.Map <CustomerAddressViewModel>(It.IsAny <CustomerAddress>()))
.Returns(CustomerViewModelMock.GetCustomerAddress());
var customerService = new CustomerService(_customerRepositoryMock.Object,
_viaCEPServiceMock.Object, _domainNotificationMock.Object,
_unitOfWorkMock.Object, _mapperMock.Object);
var customeMethod = await customerService.GetAddressByIdAsync(customerId);
var customerResult = Assert.IsAssignableFrom <CustomerAddressViewModel>(customeMethod);
Assert.NotNull(customerResult);
}
public void Add_ReturnCustomerViewModelTestAsync()
{
var customer = CustomerViewModelMock.GetCustomer();
_mapperMock.Setup(x => x.Map <Customer>(It.IsAny <CustomerViewModel>()))
.Returns(CustomerMock.GetCustomer());
_mapperMock.Setup(x => x.Map <CustomerViewModel>(It.IsAny <Customer>()))
.Returns(CustomerViewModelMock.GetCustomer());
_customerRepositoryMock.Setup(x => x.GetByNameAsync(customer.Name))
.ReturnsAsync(CustomerMock.GetCustomerAddress());
var customerService = new CustomerService(_customerRepositoryMock.Object,
_viaCEPServiceMock.Object, _domainNotificationMock.Object,
_unitOfWorkMock.Object, _mapperMock.Object);
customerService.Add(customer);
Assert.NotNull(customer);
}
public async Task GetAddressByNameAsync_ReturnCustomerAddressViewModelTestAsync()
{
var name = "Diuor PleaBolosmakh";
var customerName = CustomerViewModelMock.GetCustomerName(name);
_customerRepositoryMock.Setup(x => x.GetByNameAsync(name))
.ReturnsAsync(CustomerMock.GetCustomerAddress());
_mapperMock.Setup(x => x.Map <CustomerAddressViewModel>(It.IsAny <CustomerAddress>()))
.Returns(CustomerViewModelMock.GetCustomerAddress());
var customerService = new CustomerService(_customerRepositoryMock.Object,
_viaCEPServiceMock.Object, _domainNotificationMock.Object,
_unitOfWorkMock.Object, _mapperMock.Object);
var customeMethod = await customerService.GetAddressByNameAsync(customerName);
var customerResult = Assert.IsAssignableFrom <CustomerAddressViewModel>(customeMethod);
Assert.NotNull(customerResult);
}
public void InsertCustomer()
{
var data = new CustomerModel()
{
Address = "addres prueba",
CreditCardNumber = "0000000000000000",
CreditCardType = "MASTERCARD",
DocNumber = "987654",
Status = "1",
Email = "*****@*****.**",
FName = "prueba",
LName = "prueba",
PhoneNumber = "3110000000",
UserName = "******",
Password = "******"
};
var result = new CustomerMock().InsertCustomer(data).Result;
Assert.IsTrue(result.Code == Status.Ok, result.Message);
}
public async Task GetAll_ReturnCustomerAddressViewModelTestAsync()
{
var cep = "17052520";
_customerRepositoryMock.Setup(x => x.GetAllAsync())
.ReturnsAsync(CustomerMock.GetCustomersAddress());
_mapperMock.Setup(x => x.Map <IEnumerable <CustomerAddressViewModel> >(It.IsAny <IEnumerable <CustomerAddress> >()))
.Returns(CustomerViewModelMock.GetCustomersAddress());
_viaCEPServiceMock.Setup(x => x.GetByCEPAsync(cep))
.ReturnsAsync(ViaCEPMock.GetCEP());
var customerService = new CustomerService(_customerRepositoryMock.Object,
_viaCEPServiceMock.Object, _domainNotificationMock.Object,
_unitOfWorkMock.Object, _mapperMock.Object);
var customeMethod = await customerService.GetAllAsync();
var customerResult = Assert.IsAssignableFrom <IEnumerable <CustomerAddressViewModel> >(customeMethod);
Assert.NotNull(customerResult);
Assert.NotEmpty(customerResult);
}
