public async Task CreateAsyncShouldWorkCorrectlyWithUnexistingCityUsingMoq(string cityName, string cityZIPCode, int countryId)
{
var addressRepository = new Mock <IDeletableEntityRepository <Address> >();
var cityRepository = new Mock <IRepository <City> >();
var citiesList = new List <City>
{
new City {
Id = 1, Name = "Ruse", ZIPCode = "7000", CountryId = 42
},
new City {
Id = 2, Name = "Sofia", ZIPCode = "1000", CountryId = 42
},
};
var addressesList = new List <Address>
{
new Address {
Id = "TestId1", CreatedOn = DateTime.UtcNow, Street = "TestStreet", City = citiesList.ElementAt(0), CityId = 1, Description = "TestDescription", UserId = "TestUserId"
},
};
addressRepository.Setup(r => r.AllAsNoTracking()).Returns(addressesList.AsQueryable());
addressRepository.Setup(r => r.AddAsync(It.IsAny <Address>())).Callback((Address item) => addressesList.Add(item));
addressRepository.Setup(r => r.SaveChangesAsync()).Verifiable();
cityRepository.Setup(r => r.All()).Returns(citiesList.AsQueryable());
cityRepository.Setup(r => r.AddAsync(It.IsAny <City>())).Callback((City item) => citiesList.Add(item));
var service = new AddressesService(addressRepository.Object, cityRepository.Object);
var model = new AddressInputViewModel
{
Street = "TestStreet",
Description = "TestDescription",
UserId = "TestUserId",
City = cityName,
ZIPCode = cityZIPCode,
CountryId = countryId,
};
Assert.True(await service.CreateAsync(model));
Assert.Equal(2, addressesList.Count);
Assert.Equal("TestStreet", addressesList.ElementAt(1).Street);
Assert.Equal("TestDescription", addressesList.ElementAt(1).Description);
Assert.Equal("TestUserId", addressesList.ElementAt(1).UserId);
Assert.Equal(cityName, addressesList.ElementAt(1).City.Name);
Assert.Equal(3, citiesList.Count);
Assert.Equal(cityName, citiesList.Last().Name);
Assert.Equal(cityZIPCode, citiesList.Last().ZIPCode);
Assert.Equal(countryId, citiesList.Last().CountryId);
cityRepository.Verify(x => x.All(), Times.Once);
cityRepository.Verify(x => x.AddAsync(It.IsAny <City>()), Times.Once);
addressRepository.Verify(x => x.AllAsNoTracking(), Times.Once);
addressRepository.Verify(x => x.AddAsync(It.IsAny <Address>()), Times.Once);
addressRepository.Verify(x => x.SaveChangesAsync());
}
public async Task <IActionResult> CreateAddress(AddressInputViewModel inputModel)
{
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction("Index"));
}
await this.ordersService.CreateAddressToOrderAsync(inputModel);
return(this.LocalRedirect("/Payments/Index"));
}
private async Task <Address> GetAddressAsync(AddressInputViewModel inputModel, string userId)
{
var address = await this.dbContext.Addresses
.Where(a => a.IsDeleted == false)
.Where(a => a.UserId == userId)
.Where(a => a.Country == inputModel.Country)
.Where(a => a.City.Name == inputModel.City)
.Where(a => a.BuildingNumber == inputModel.BuildingNumber)
.Where(a => a.City.PostCode == inputModel.PostCode)
.Where(a => a.Street == inputModel.Address)
.FirstOrDefaultAsync();
return(address);
}
public async Task CreateAsyncShouldReturnFalseIfAddressAlreadyExistsUsingMoq()
{
var addressRepository = new Mock <IDeletableEntityRepository <Address> >();
var cityRepository = new Mock <IRepository <City> >();
var citiesList = new List <City>
{
new City {
Id = 1, Name = "Ruse", ZIPCode = "7000", CountryId = 42
},
new City {
Id = 2, Name = "Sofia", ZIPCode = "1000", CountryId = 42
},
};
var addressesList = new List <Address>
{
new Address {
Id = "TestId1", CreatedOn = DateTime.UtcNow, Street = "TestStreet", City = citiesList.ElementAt(0), CityId = 1, Description = "TestDescription", UserId = "TestUserId"
},
};
addressRepository.Setup(r => r.AllAsNoTracking()).Returns(addressesList.AsQueryable());
cityRepository.Setup(r => r.All()).Returns(citiesList.AsQueryable());
var service = new AddressesService(addressRepository.Object, cityRepository.Object);
var model = new AddressInputViewModel
{
Street = "TestStreet",
Description = "TestDescription",
UserId = "TestUserId",
City = "Ruse",
ZIPCode = "7000",
CountryId = 42,
};
Assert.False(await service.CreateAsync(model));
cityRepository.Verify(x => x.All(), Times.Once);
addressRepository.Verify(x => x.AllAsNoTracking(), Times.Once);
}
public async Task <IActionResult> Create(AddressInputViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction("Create", "Orders"));
}
var createResult = await this.addressesService.CreateAsync(model);
if (createResult)
{
this.TempData["Alert"] = "Successfully added address.";
}
else
{
this.TempData["Error"] = "There was a problem adding the address.";
}
return(this.RedirectToAction("Create", "Orders"));
}
public async Task <bool> CreateAsync(AddressInputViewModel model)
{
var address = new Address
{
Street = model.Street,
Description = model.Description,
UserId = model.UserId,
};
var city = this.citiesRepository.All()
.FirstOrDefault(x => x.Name == model.City && x.ZIPCode == model.ZIPCode && x.CountryId == model.CountryId);
if (city == null)
{
city = new City
{
Name = model.City,
ZIPCode = model.ZIPCode,
CountryId = model.CountryId,
};
await this.citiesRepository.AddAsync(city);
}
address.City = city;
var addressExists = this.addressRepository.AllAsNoTracking()
.Any(x => x.Street == address.Street && x.Description == address.Description && x.CityId == city.Id && x.UserId == model.UserId);
if (addressExists)
{
return(false);
}
await this.addressRepository.AddAsync(address);
await this.addressRepository.SaveChangesAsync();
return(true);
}
public async Task CreateAddressToOrderAsync(AddressInputViewModel inputModel)
{
var userId = this.usersService.GetLoggedUserId();
var userFromDb = await this.usersService.GetLoggedUserByIdAsync(userId);
var order = await this.dbContext.Orders
.Where(o => o.IsDeleted == false)
.Where(o => o.Status != OrderStatus.Sent)
.FirstOrDefaultAsync(o => o.UserId == userId);
if (order == null)
{
var newOrder = new Order
{
UserId = userId,
PaymentStatus = PaymentStatus.Unpaid,
};
await this.dbContext.Orders.AddAsync(newOrder);
await this.dbContext.SaveChangesAsync();
order = newOrder;
}
var currentAddress = await this.GetAddressAsync(inputModel, userId);
if (order.DeliveryAddressId == null || currentAddress == null)
{
var city = new City();
if (!this.dbContext.Cities.Any(c => c.PostCode == inputModel.PostCode &&
c.Name == inputModel.City))
{
city = new City
{
Name = inputModel.City,
PostCode = inputModel.PostCode,
};
await this.dbContext.Cities.AddAsync(city);
await this.dbContext.SaveChangesAsync();
}
else
{
city = await this.dbContext.Cities
.FirstOrDefaultAsync(c => c.Name == inputModel.City &&
c.PostCode == inputModel.PostCode);
}
var address = new Address
{
Country = inputModel.Country,
Description = inputModel.DeliveryInstructions,
Street = inputModel.Address,
BuildingNumber = inputModel.BuildingNumber,
CityId = city.Id,
UserId = userId,
};
await this.dbContext.Addresses.AddAsync(address);
await this.dbContext.SaveChangesAsync();
userFromDb.Addresses.Add(address);
address.Orders.Add(order);
order.DeliveryAddressId = address.Id;
this.dbContext.Update(order);
city.Addresses.Add(address);
this.dbContext.Update(address);
this.dbContext.Update(city);
this.dbContext.Update(userFromDb);
await this.dbContext.SaveChangesAsync();
return;
}
else if (currentAddress != null && inputModel.DeliveryInstructions != null)
{
currentAddress.Description = inputModel.DeliveryInstructions;
this.dbContext.Update(currentAddress);
await this.dbContext.SaveChangesAsync();
return;
}
else if (currentAddress != null)
{
return;
}
}
public IViewComponentResult Invoke(AddressInputViewModel inputModel)
{
return(this.View(inputModel));
}
