public async Task ListAsyncShouldReturnAListOfAddresses()
{
const int total = 8;
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <IAddressService>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
for (var i = 0; i < total; i++)
{
await SeedDatabaseFixture.AddDummyAddressAsync(context);
}
var result = await sut.ListAsync(new PaginationData
{
CurrentPage = 1,
PerPage = 10
});
var successResult = (SuccessResult <PaginationResult <Address> >)result;
var pagination = successResult.Result;
Assert.NotEmpty(pagination.Elements);
Assert.Equal(total, pagination.Total);
}
public async Task SaveShouldReturnNotFoundResultGivenNonExistingUuid()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <IAddressService>();
var unitOfWork = scope.ServiceProvider.GetRequiredService <IUnitOfWork>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
const string edited = "Edited";
var editedAddress = new Address
{
City = address.City,
Country = edited,
Id = address.Id,
Number = address.Number,
Street = address.Street,
Uuid = Guid.NewGuid(),
ZipCode = address.ZipCode,
State = address.State
};
var result = await sut.SaveAsync(editedAddress);
await unitOfWork.SaveChangesAsync();
Assert.IsType <NotFoundResult>(result);
}
public async Task AddShouldAddANewEntry()
{
using var scope = ServiceProvider.CreateScope();
var sut = Factory.CreateClient();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
var request = new AddLocalPhoneModel
{
Number = LocalPhoneFixture.Number,
AreaCode = LocalPhoneFixture.AreaCode,
AddressUuid = address.Uuid
};
var serializedRequest = JsonSerializer.Serialize(request);
var contentRequest = new StringContent(serializedRequest, Encoding.UTF8, "application/json");
var result = await sut.PostAsync("LocalPhone/Add", contentRequest);
result.EnsureSuccessStatusCode();
var insertedPhone = await context.LocalPhones.Include(x => x.PhoneAddress).FirstAsync();
Assert.Equal(LocalPhoneFixture.Number, insertedPhone.Number);
Assert.Equal(LocalPhoneFixture.AreaCode, insertedPhone.AreaCode);
Assert.NotNull(insertedPhone.PhoneAddress);
}
public async Task ListShouldReturnAListOfEntries()
{
const int total = 5;
const int perPage = 8;
using var scope = ServiceProvider.CreateScope();
var sut = Factory.CreateClient();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
for (var i = 0; i < total; i++)
{
await context.LocalPhones.AddAsync(LocalPhoneFixture.GetDummyLocalPhone(Guid.NewGuid(), address.Id));
}
await context.SaveChangesAsync();
context.ChangeTracker.Clear();
var result = await sut.GetAsync($"LocalPhone/List?currentPage=1&perPage={perPage}");
result.EnsureSuccessStatusCode();
var serializedResult = await result.Content.ReadAsStringAsync();
var list = JsonSerializer.Deserialize <PaginationResult <LocalPhoneListItemModel> >(serializedResult,
scope.ServiceProvider.GetRequiredService <JsonSerializerOptions>());
foreach (var localPhone in list.Elements)
{
Assert.Equal(LocalPhoneFixture.Number, localPhone.Number);
Assert.Equal(LocalPhoneFixture.AreaCode, localPhone.AreaCode);
Assert.Equal(address.Uuid, localPhone.AddressUuid);
Assert.NotEqual(default, localPhone.AddressDescription);
public async Task GetShouldReturnDetailedDataFromTheEntry()
{
using var scope = ServiceProvider.CreateScope();
var sut = Factory.CreateClient();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
var phoneUuid = Guid.NewGuid();
var phone = LocalPhoneFixture.GetDummyLocalPhone(phoneUuid, address.Id);
await context.LocalPhones.AddAsync(phone);
await context.SaveChangesAsync();
context.ChangeTracker.Clear();
var result = await sut.GetAsync($"LocalPhone/Get/{phoneUuid}");
result.EnsureSuccessStatusCode();
var serializedResult = await result.Content.ReadAsStringAsync();
var detailedPhone = JsonSerializer.Deserialize <LocalPhone>(serializedResult, ServiceProvider.GetRequiredService <JsonSerializerOptions>());
var detailedAddress = detailedPhone.PhoneAddress;
Assert.Equal(LocalPhoneFixture.Number, detailedPhone.Number);
Assert.Equal(LocalPhoneFixture.AreaCode, detailedPhone.AreaCode);
Assert.Equal(AddressFixture.Country, detailedAddress.Country);
Assert.Equal(AddressFixture.ZipCode, detailedAddress.ZipCode);
Assert.Equal(AddressFixture.City, detailedAddress.City);
Assert.Equal(AddressFixture.Number, detailedAddress.Number);
Assert.Equal(AddressFixture.State, detailedAddress.State);
Assert.Equal(AddressFixture.Street, detailedAddress.Street);
}
public async Task ListShouldReturnAListOfPhones()
{
const int total = 8;
const int perPage = 18;
using var scope = ServiceProvider.CreateScope();
var sut = Factory.CreateClient();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var customer = await SeedDatabaseFixture.AddDummyCustomerAsync(context);
for (var i = 0; i < total; i++)
{
await SeedDatabaseFixture.AddDummyPhoneAsync(context, customer);
}
var result = await sut.GetAsync($"Phone/List?currentPage=1&perPage={perPage}");
result.EnsureSuccessStatusCode();
var serializedResult = await result.Content.ReadAsStringAsync();
var deserializedResult = JsonSerializer.Deserialize <PaginationResult <PhoneListItemModel> >(serializedResult,
scope.ServiceProvider.GetRequiredService <JsonSerializerOptions>());
foreach (var phone in deserializedResult.Elements)
{
Assert.NotEqual(default, phone.Uuid);
public async Task SaveShouldUpdateGivenExistingEntry()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <ILocalPhoneService>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var unitOfWork = scope.ServiceProvider.GetRequiredService <IUnitOfWork>();
var(address, phone) = await SeedDatabaseFixture.AddDummyPhoneAndAddressAsync(context);
var newAddress = await SeedDatabaseFixture.AddDummyAddressAsync(context);
const string newNumber = "4578-8795";
const string newAreaCode = "84";
var phoneToEdit = new LocalPhone
{
Id = phone.Id,
Uuid = phone.Uuid,
Number = newNumber,
AreaCode = newAreaCode
};
var result = await sut.SaveAsync(phoneToEdit, newAddress.Uuid);
await unitOfWork.SaveChangesAsync();
var newPhone = await context.LocalPhones.Include(x => x.PhoneAddress).FirstAsync(x => x.Uuid == phoneToEdit.Uuid);
Assert.True(result.IsSuccessful);
Assert.Equal(phone.Uuid, newPhone.Uuid);
Assert.Equal(phone.Id, newPhone.Id);
Assert.Equal(newAddress.Uuid, newPhone.PhoneAddress.Uuid);
Assert.NotEqual(address.Uuid, newPhone.PhoneAddress.Uuid);
Assert.Equal(newNumber, newPhone.Number);
Assert.Equal(newAreaCode, newPhone.AreaCode);
}
public async Task SaveShouldEditExistingEntry()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <IAddressService>();
var unitOfWork = scope.ServiceProvider.GetRequiredService <IUnitOfWork>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
const string edited = "Edited";
var editedAddress = new Address
{
City = address.City,
Country = edited,
Id = address.Id,
Number = address.Number,
Street = address.Street,
Uuid = address.Uuid,
ZipCode = address.ZipCode,
State = address.State
};
var result = await sut.SaveAsync(editedAddress);
await unitOfWork.SaveChangesAsync();
var uniqueAddress = await context.Addresses.FirstAsync();
Assert.True(result.IsSuccessful);
Assert.Equal(edited, uniqueAddress.Country);
Assert.Equal(address.Uuid, uniqueAddress.Uuid);
}
public async Task ListAsyncShouldReturnAListOfEntries()
{
const int total = 5;
const int perPage = 8;
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <ILocalPhoneService>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
for (var i = 0; i < total; i++)
{
await SeedDatabaseFixture.AddDummyLocalPhoneAsync(context, address);
}
var result = await sut.ListAsync(new PaginationData
{
CurrentPage = 1,
PerPage = perPage
});
var successResult = (SuccessResult <PaginationResult <LocalPhone> >)result;
var phones = successResult.Result.Elements;
foreach (var phone in phones)
{
Assert.Equal(LocalPhoneFixture.Number, phone.Number);
Assert.Equal(LocalPhoneFixture.AreaCode, phone.AreaCode);
Assert.Equal(address.Uuid, phone.PhoneAddress.Uuid);
}
}
public async Task GetGuidsFromAddressShouldReturnAListOfGuids()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <ILocalPhoneRepository>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var(address, phone) = await SeedDatabaseFixture.AddDummyPhoneAndAddressAsync(context);
var result = await sut.GetGuidsFromAddress(address.Uuid);
Assert.NotEmpty(result);
Assert.Contains(phone.Uuid, result);
}
public async Task DetailAsyncShouldReturnDataGivenExistingEntry()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <IAddressService>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
var result = await sut.DetailAsync(address.Uuid);
var success = (SuccessResult <Address>)result;
Assert.NotNull(success.Result);
}
public async Task DeleteShouldSetIsActiveToFalse()
{
using var scope = ServiceProvider.CreateScope();
var sut = Factory.CreateClient();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
var result = await sut.DeleteAsync($"Address/Delete/{address.Uuid}");
result.EnsureSuccessStatusCode();
var deletedAddress = await context.Addresses.FirstAsync(x => x.Uuid == address.Uuid);
Assert.Equal(1, context.Addresses.Count());
Assert.False(deletedAddress.IsActive);
}
public async Task GetShouldReturnDetailsGivenExistingPhone()
{
using var scope = ServiceProvider.CreateScope();
var sut = Factory.CreateClient();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var(customer, phone) = await SeedDatabaseFixture.AddDummyCustomerAndPhoneAsync(context);
var result = await sut.GetAsync($"Phone/Get/{phone.Uuid}");
result.EnsureSuccessStatusCode();
var serializedResult = await result.Content.ReadAsStringAsync();
var deserializedResult = JsonSerializer.Deserialize <Phone>(serializedResult, scope.ServiceProvider.GetRequiredService <JsonSerializerOptions>());
AssertPhone(deserializedResult, customer, phone);
}
public async Task SaveShouldReturnNotFoundResultGivenNonExistingPhoneUuid()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <ILocalPhoneService>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
var dummyPhone = new LocalPhone
{
Uuid = Guid.NewGuid()
};
var result = await sut.SaveAsync(dummyPhone, address.Uuid);
Assert.IsType <NotFoundResult>(result);
}
public async Task SaveAsyncShouldAddANewCustomer()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <ICustomerService>();
var unitOfWork = scope.ServiceProvider.GetRequiredService <IUnitOfWork>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
var result = await sut.SaveAsync(CustomerFixture.GetDummyCustomer(), new [] { address.Uuid });
await unitOfWork.SaveChangesAsync();
var customer = await context.Customers.Include(x => x.Addresses).FirstAsync();
Assert.True(result.IsSuccessful);
Assert.Equal(CustomerFixture.Name, customer.Name);
Assert.NotEqual(default, customer.Email);
public async Task UpdateShouldUpdateAnExistingRecord()
{
using var scope = ServiceProvider.CreateScope();
var sut = Factory.CreateClient();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
const string newCity = "Paraíso do Tocantins";
const string newZipCode = "335045-879";
const string newCountry = "Bengium";
const string newState = "Test";
const string newStreet = "Another street";
const int newNumber = 800;
var editedAddress = new UpdateAddressModel()
{
City = newCity,
Country = newCountry,
Number = newNumber,
State = newState,
Street = newStreet,
ZipCode = newZipCode,
Id = address.Id
};
var serializedJson = JsonSerializer.Serialize(editedAddress);
var contentJson = new StringContent(serializedJson, Encoding.UTF8, "application/json");
var result = await sut.PutAsync($"Address/Update/{address.Uuid}", contentJson);
result.EnsureSuccessStatusCode();
var uniqueAddress = await context.Addresses.FirstAsync();
Assert.NotEmpty(context.Addresses);
Assert.Equal(newCity, uniqueAddress.City);
Assert.Equal(newCountry, uniqueAddress.Country);
Assert.Equal(newState, uniqueAddress.State);
Assert.Equal(newZipCode, uniqueAddress.ZipCode);
Assert.Equal(newStreet, uniqueAddress.Street);
Assert.Equal(newNumber, uniqueAddress.Number);
Assert.Equal(address.Uuid, uniqueAddress.Uuid);
}
public async Task DeleteAsyncShouldSetIsActiveToFalse()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <ILocalPhoneService>();
var unitOfWork = scope.ServiceProvider.GetRequiredService <IUnitOfWork>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var(_, phone) = await SeedDatabaseFixture.AddDummyPhoneAndAddressAsync(context);
var result = await sut.DeleteAsync(phone.Uuid);
await unitOfWork.SaveChangesAsync();
var deletedPhone = await context.LocalPhones.FirstAsync();
Assert.True(result.IsSuccessful);
Assert.Equal(phone.Uuid, deletedPhone.Uuid);
Assert.False(deletedPhone.IsActive);
}
public async Task SaveShouldANewEntry()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <ILocalPhoneService>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var unitOfWork = scope.ServiceProvider.GetRequiredService <IUnitOfWork>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
var result = await sut.SaveAsync(LocalPhoneFixture.GetDummyLocalPhone(address.Id), address.Uuid);
await unitOfWork.SaveChangesAsync();
var phone = await context.LocalPhones.Include(x => x.PhoneAddress).FirstAsync();
Assert.True(result.IsSuccessful);
Assert.Equal(LocalPhoneFixture.Number, phone.Number);
Assert.Equal(LocalPhoneFixture.AreaCode, phone.AreaCode);
Assert.NotNull(phone.PhoneAddress);
}
public async Task SaveShouldReturnNotFoundResultGivenNonExistingAddressUuid()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <ILocalPhoneService>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var(_, phone) = await SeedDatabaseFixture.AddDummyPhoneAndAddressAsync(context);
var phoneToEdit = new LocalPhone
{
Id = phone.Id,
Uuid = phone.Uuid,
Number = "4578-8795",
AreaCode = "84"
};
var result = await sut.SaveAsync(phoneToEdit, Guid.NewGuid());
Assert.IsType <NotFoundResult>(result);
}
public async Task DeleteShouldSetIsActiveToFalseToAddressAndItsPhones()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <IAddressService>();
var unitOfWork = scope.ServiceProvider.GetRequiredService <IUnitOfWork>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var(address, phone) = await SeedDatabaseFixture.AddDummyPhoneAndAddressAsync(context);
await sut.DeleteAsync(address.Uuid);
await unitOfWork.SaveChangesAsync();
var deletedAddress = await context.Addresses.FirstAsync(x => x.Uuid == address.Uuid);
var deletedPhone = await context.LocalPhones.FirstAsync(x => x.Uuid == phone.Uuid);
Assert.False(deletedAddress.IsActive);
Assert.False(deletedPhone.IsActive);
}
public async Task SaveAsyncShouldReturnNotFoundResultGivenNonExistingEntry()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <IPhoneService>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var(customer, phone) = await SeedDatabaseFixture.AddDummyCustomerAndPhoneAsync(context);
var editedPhone = new Phone
{
Id = 3587,
Uuid = phone.Uuid,
Number = "7894-8578",
CustomerId = phone.CustomerId,
AreaCode = "87"
};
var result = await sut.SaveAsync(editedPhone, customer.Uuid);
Assert.IsType <NotFoundResult>(result);
}
public async Task DetailAsyncShouldDetailAnExistingEntry()
{
using var scope = ServiceProvider.CreateScope();
var sut = scope.ServiceProvider.GetRequiredService <ILocalPhoneService>();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var(address, phone) = await SeedDatabaseFixture.AddDummyPhoneAndAddressAsync(context);
var result = await sut.DetailAsync(phone.Uuid);
var successResult = (SuccessResult <LocalPhone>)result;
var insertedPhone = successResult.Result;
var insertedAddress = insertedPhone.PhoneAddress;
Assert.Equal(LocalPhoneFixture.Number, insertedPhone.Number);
Assert.Equal(LocalPhoneFixture.AreaCode, insertedPhone.AreaCode);
Assert.Equal(AddressFixture.Country, insertedAddress.Country);
Assert.Equal(AddressFixture.ZipCode, insertedAddress.ZipCode);
Assert.Equal(AddressFixture.City, insertedAddress.City);
Assert.Equal(AddressFixture.Number, insertedAddress.Number);
Assert.Equal(AddressFixture.State, insertedAddress.State);
Assert.Equal(AddressFixture.Street, insertedAddress.Street);
}
public async Task ListShouldReturnAListOfEntries(int total, int perPage)
{
using var scope = ServiceProvider.CreateScope();
var sut = Factory.CreateClient();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
for (var i = 0; i < total; i++)
{
await SeedDatabaseFixture.AddDummyAddressAsync(context);
}
var result = await sut.GetAsync($"Address/List?currentPage=1&perPage={perPage}");
result.EnsureSuccessStatusCode();
var serializedResult = await result.Content.ReadAsStringAsync();
var deserializedResult = JsonSerializer.Deserialize <PaginationResult <AddressListItem> >(serializedResult,
scope.ServiceProvider.GetRequiredService <JsonSerializerOptions>());
Assert.NotNull(deserializedResult);
Assert.NotEmpty(deserializedResult.Elements);
Assert.Equal(Math.Min(total, perPage), deserializedResult.Elements.Count());
Assert.Equal(total, deserializedResult.Total);
}
public async Task GetShouldReturnExistingEntry()
{
using var scope = ServiceProvider.CreateScope();
var sut = Factory.CreateClient();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var address = await SeedDatabaseFixture.AddDummyAddressAsync(context);
var result = await sut.GetAsync($"Address/Get/{address.Uuid}");
result.EnsureSuccessStatusCode();
var serializedResult = await result.Content.ReadAsStringAsync();
var deserializedResult = JsonSerializer.Deserialize <Address>(serializedResult, scope.ServiceProvider.GetRequiredService <JsonSerializerOptions>());
Assert.NotNull(deserializedResult);
Assert.Equal(AddressFixture.City, deserializedResult.City);
Assert.Equal(AddressFixture.Country, deserializedResult.Country);
Assert.Equal(AddressFixture.Street, deserializedResult.Street);
Assert.Equal(AddressFixture.ZipCode, deserializedResult.ZipCode);
Assert.Equal(AddressFixture.State, deserializedResult.State);
Assert.Equal(AddressFixture.Number, deserializedResult.Number);
}
public async Task AddShouldAddNewPhone()
{
using var scope = ServiceProvider.CreateScope();
var sut = Factory.CreateClient();
var context = scope.ServiceProvider.GetRequiredService <ApplicationContext>();
var customer = await SeedDatabaseFixture.AddDummyCustomerAsync(context);
var request = new AddPhoneModel
{
Number = "7894-5698",
AreaCode = "78",
CustomerUuid = customer.Uuid
};
var serializedRequest = JsonSerializer.Serialize(request);
var contentRequest = new StringContent(serializedRequest, Encoding.UTF8, "application/json");
var result = await sut.PostAsync("Phone/Add", contentRequest);
result.EnsureSuccessStatusCode();
var savedPhone = await context.Phones.Include(x => x.Customer).FirstAsync();
Assert.Equal(request.Number, savedPhone.Number);
Assert.Equal(request.AreaCode, savedPhone.AreaCode);
Assert.Equal(request.CustomerUuid, savedPhone.Customer.Uuid);
}
