public async Task AddNewAddressToUser_ShouldAdd()
{
this.Initialize();
this.SeedUser();
this.SeedUserToAddress();
var input = new CreateAddressInputModel()
{
CityName = CityTwoName,
PostCode = PostcodeFirst,
StreetName = StreetNameFirst,
StreetNumber = NumberStrFirst
};
var viewModel = await service.AddAddressToUserAsync <CreateAddressViewModel>(input, UserOneName);
var expectedCount = 2;
Assert.Equal(expectedCount, context.Addresses.Count());
Assert.Equal(CityTwoName, viewModel.CityName);
Assert.Equal(PostcodeFirst, viewModel.CityPostCode);
Assert.Equal(StreetNameFirst, viewModel.StreetName);
Assert.Equal(NumberStrFirst, viewModel.StreetNumber);
}
public async Task <Address> CreateAsync(CreateAddressInputModel input)
{
var city = await this.citiesService.CreateAsync(input.City);
var address = this.addressRepo.All()
.FirstOrDefault(a => a.Street == input.Street &&
a.StreetNumber == input.Number &&
a.City.Name == city.Name);
if (address != null)
{
return(address);
}
address = new Address
{
Street = input.Street,
StreetNumber = input.Number,
PostalCode = input.PostalCode,
City = city,
};
await this.addressRepo.AddAsync(address);
await this.addressRepo.SaveChangesAsync();
return(address);
}
public async Task AddressShouldBeAddedToDbUponCreation()
{
var inputModel = new CreateAddressInputModel
{
City = "Test City",
Number = 1,
PostalCode = "6000",
Street = "Test street",
};
await this.addressesService.CreateAsync(inputModel);
Assert.True(this.addressList.Count == 1);
}
public async Task <TViewModel> AddAddressToUserAsync <TViewModel>(
CreateAddressInputModel model,
string username)
{
var city = this.context
.Cities
.SingleOrDefault(x => x.Name == model.CityName &&
x.PostCode == model.PostCode);
if (city == null)
{
city = this.mapper.Map <City>(model);
}
var address = this.context
.Addresses
.Include(x => x.City)
.Include(x => x.KeepFitUsers)
.SingleOrDefault(x =>
x.StreetName == model.StreetName &&
x.StreetNumber == model.StreetNumber &&
x.City.Name == model.CityName &&
x.City.PostCode == model.PostCode);
var thisUserLiveHere = address?
.KeepFitUsers
.Any(x => x.UserName == username);
if (address != null && thisUserLiveHere.HasValue)
{
return(this.mapper.Map <TViewModel>(address));
}
if (address == null)
{
address = this.mapper.Map <Address>(model);
address.City = city;
this.context.Addresses.Add(address);
}
var user = await this.context
.Users
.SingleOrDefaultAsync(x => x.UserName == username);
user.Address = address;
await this.context.SaveChangesAsync();
return(this.mapper.Map <TViewModel>(address));
}
public async Task AddAddressToFakeUser_ShouldThrow()
{
this.Initialize();
this.SeedUser();
var input = new CreateAddressInputModel()
{
CityName = CityOneName,
PostCode = PostcodeFirst,
StreetName = StreetNameFirst,
StreetNumber = NumberStrFirst
};
await Assert.ThrowsAsync <NullReferenceException>(() => service
.AddAddressToUserAsync <CreateAddressViewModel>(input, UserTwoName));
}
public async Task <ActionResult <CreateAddressResourceModel> > Create(CreateAddressInputModel inputModel)
{
try
{
var resourceModel = await this.addressesService.CreateAddress <CreateAddressResourceModel>(
inputModel.Country,
inputModel.Town,
inputModel.PostalCode,
inputModel.FullAddress, this.GetUserId(this.User));
return(this.Created(resourceModel));
}
catch (Exception ex)
{
this.loggerService.LogException(ex);
return(this.BadRequest());
}
}
public async Task AddressesPropertiesShouldBeMappedCorrectlyUponCreation()
{
var inputModel = new CreateAddressInputModel
{
City = "Test City",
Number = 1,
PostalCode = "6000",
Street = "Test street",
};
var address = await this.addressesService.CreateAsync(inputModel);
var city = "Test City";
var number = 1;
var postalCode = "6000";
var street = "Test street";
Assert.Equal(city, address.City.Name);
Assert.Equal(number, address.StreetNumber);
Assert.Equal(postalCode, address.PostalCode);
Assert.Equal(street, address.Street);
}
public async Task AddressShouldNotBeCreatedIfItIsAlreadyContainedInDb()
{
var firstModel = new CreateAddressInputModel
{
City = "Test City",
Number = 1,
PostalCode = "6000",
Street = "Test street",
};
var secondModel = new CreateAddressInputModel
{
City = "Test City",
Number = 1,
PostalCode = "6000",
Street = "Test street",
};
await this.addressesService.CreateAsync(firstModel);
await this.addressesService.CreateAsync(secondModel);
Assert.True(this.addressesRepo.Object.All().Count() == 1);
}
public async Task <ActionResult <CreateAddressViewModel> > Create(CreateAddressInputModel model)
{
var createdObj = await this.addressService.AddAddressToUserAsync <CreateAddressViewModel>(model, this.User.Identity.Name);
return(createdObj);
}
public IActionResult CreateAddress([FromBody] CreateAddressInputModel model)
{
var id = this.mainService.CreateAddress(model.Address);
return(this.Ok(id));
}
