public async Task GetAddressByUserIdShouldGetAddress()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var repository = new EfDeletableEntityRepository <UserAddress>(dbContext);
var service = new AddressesService(repository);
var userManager = MockUserManager.GetUserManager();
var user = new ApplicationUser
{
Email = "*****@*****.**",
UserName = "******",
};
await userManager.CreateAsync(user);
var userAddress = new UserAddress()
{
UserId = user.Id,
};
await service.CreateAsync(userAddress);
var userAddressInvalid = new UserAddress()
{
UserId = "none",
};
await service.CreateAsync(userAddressInvalid);
var foundAddress =
await service.GetBaseByUserId(user.Id);
Assert.Equal(user.Id, foundAddress.UserId);
}
public async Task GetAddressOrCreateByCountryNameAndTownName_WhitNewTownName_ShouldReturnCorrectAddress()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <Address>(context);
var countryService = new Mock <ICountriesService>();
countryService.Setup(x => x.GetCountryByName("Bulgaria")).Returns(new Country()
{
Name = "Bulgaria"
});
var townService = new Mock <ITownsService>();
townService.Setup(x => x.GetOrCreateTownByName("Sofia")).Returns(new Town()
{
Name = "Sofia"
});
var service = new AddressesService(repository, countryService.Object, townService.Object);
var actualResult = service.GetAddressOrCreateByCoutryNameAndTownName("Bulgaria", "Sofia");
Assert.Equal("Bulgaria", actualResult.Country.Name);
Assert.Equal("Sofia", actualResult.Town.Name);
}
public async Task EditAsyncReturnsIfAddressDoesntExists()
{
var options = new DbContextOptionsBuilder<ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository<Address>(dbContext);
var address = new Address()
{
Id = 1,
};
var editedAddress = new AddressServiceModel()
{
Id = 2,
};
dbContext.Add(address);
await dbContext.SaveChangesAsync();
var service = new AddressesService(repository);
await service.EditAsync(editedAddress);
var addressesInDbCount = repository.All().ToList().Count();
Assert.Equal(1, addressesInDbCount);
}
public async Task EditAddressAsyncShouldThrowExceptionIfCityIsNull()
{
var option = new DbContextOptionsBuilder <MyCalisthenicAppDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new MyCalisthenicAppDbContext(option);
var addressService = new AddressesService(dbContext, null);
var city = new City
{
Id = Guid.NewGuid().ToString(),
Name = CityName,
PostCode = CityPostCode,
};
await dbContext.Cities.AddAsync(city);
await dbContext.SaveChangesAsync();
var addressViewModel = new AddressAdminEditViewModel
{
CityId = Guid.NewGuid().ToString(),
};
var exception = await Assert.ThrowsAsync <ArgumentNullException>(async() => await addressService.EditAddressAsync(addressViewModel));
Assert.IsType <ArgumentNullException>(exception);
}
public async Task DeleteAsyncShouldWorkCorrectlyUsingMoq()
{
var repository = new Mock <IDeletableEntityRepository <Address> >();
var addressesList = new List <Address>
{
new Address {
Id = "TestId1", CreatedOn = DateTime.UtcNow, Street = "Test Street 1"
},
new Address {
Id = "TestId2", CreatedOn = DateTime.UtcNow, Street = "Test Street 2"
},
};
repository.Setup(r => r.AllAsNoTracking()).Returns(addressesList.AsQueryable());
repository.Setup(r => r.Delete(It.IsAny <Address>())).Callback((Address item) => addressesList.Remove(item));
repository.Setup(r => r.SaveChangesAsync()).Verifiable();
var service = new AddressesService(repository.Object, null);
Assert.True(await service.DeleteAsync("TestId1"));
Assert.Single(addressesList);
repository.Verify(x => x.AllAsNoTracking(), Times.Once);
repository.Verify(x => x.Delete(It.IsAny <Address>()), Times.Once);
repository.Verify(x => x.SaveChangesAsync());
}
public async Task DeleteByCityIdWorksCorrectly()
{
var options = new DbContextOptionsBuilder<ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository<Address>(dbContext);
var address = new Address()
{
Id = 1,
CityId = 1,
};
var addressTwo = new Address()
{
Id = 2,
CityId = 1,
};
dbContext.Add(address);
dbContext.Add(addressTwo);
await dbContext.SaveChangesAsync();
var service = new AddressesService(repository);
await service.DeleteByCityIdAsync(1);
var addressesInDbCount = repository.All().ToList().Count();
Assert.Equal(0, addressesInDbCount);
}
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 UpdateAddressInfoWorksCorrectly()
{
// Give a Unique name to the DB
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "TestUpdateAddressDb")
.Options;
using var dbContext = new ApplicationDbContext(options);
// Initialize Testing Data
dbContext.Addresses.AddRange(
new Address()
{
City = "Burgas",
ZipCode = 9000,
Id = 1,
},
new Address()
{
City = "Sofia",
ZipCode = 5000,
Id = 2,
});
dbContext.Users.AddRange(
new ApplicationUser()
{
Id = "1",
UserName = "******",
AddressId = 1,
},
new ApplicationUser()
{
Id = "2",
UserName = "******",
AddressId = 2,
});
dbContext.SaveChanges();
using var usersRepository = new EfDeletableEntityRepository <ApplicationUser>(dbContext);
using var addressesRepository = new EfDeletableEntityRepository <Address>(dbContext);
var addressService = new AddressesService(addressesRepository, usersRepository);
var newAddressInfo = new AddressViewModel()
{
City = "MovedToBurgas",
ZipCode = "8000",
};
await addressService.UpdateAddressInfo("Sofianec", newAddressInfo);
var currentAddressOfSofianec = addressService.GetAddressInfoByUsername("Sofianec");
Assert.Equal("MovedToBurgas", currentAddressOfSofianec.City);
}
public void GetAddressInfoShouldWork()
{
AddressesService addressService = SetUpAddressService();
var result = addressService.GetAddressInfoByUsername("Sofianec");
Assert.Equal("Sofia", result.City);
Assert.True(result.GetType() == typeof(AddressViewModel));
}
public async Task EditAddressAsyncShouldThrowExceptionIfCityIdDoesNotExists()
{
var options = new DbContextOptionsBuilder <MyCalisthenicAppDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var dbContext = new MyCalisthenicAppDbContext(options);
var addressService = new AddressesService(dbContext, null);
var city = new City
{
Id = Guid.NewGuid().ToString(),
Name = CityName,
PostCode = CityPostCode,
};
await dbContext.Cities.AddAsync(city);
await dbContext.SaveChangesAsync();
var user = new ApplicationUser
{
FirstName = UserFirstName,
LastName = UserLastName,
};
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var address = new Address
{
Country = AddressCountryName,
Street = AddressStreet,
CityId = city.Id,
UserId = user.Id,
};
await dbContext.Addresses.AddAsync(address);
await dbContext.SaveChangesAsync();
var addressViewModel = new AddressAdminEditViewModel
{
Id = address.Id,
CityId = CityId,
Country = AddressEditCountryName,
UserId = user.Id,
};
var exception = await Assert.ThrowsAsync <ArgumentNullException>(async() => await addressService.EditAddressAsync(addressViewModel));
Assert.IsType <ArgumentNullException>(exception);
}
public async Task EditAddressAsyncShouldEditAddressSuccessfully()
{
var options = new DbContextOptionsBuilder <MyCalisthenicAppDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var dbContext = new MyCalisthenicAppDbContext(options);
var addressService = new AddressesService(dbContext, null);
var city = new City
{
Id = Guid.NewGuid().ToString(),
Name = CityName,
PostCode = CityPostCode,
};
await dbContext.Cities.AddAsync(city);
await dbContext.SaveChangesAsync();
var user = new ApplicationUser
{
FirstName = UserFirstName,
LastName = UserLastName,
};
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var address = new Address
{
Country = AddressCountryName,
Street = AddressStreet,
CityId = city.Id,
UserId = user.Id,
};
await dbContext.Addresses.AddAsync(address);
await dbContext.SaveChangesAsync();
var addressViewModel = new AddressAdminEditViewModel
{
Id = address.Id,
CityId = city.Id,
Country = AddressEditCountryName,
UserId = user.Id,
};
await addressService.EditAddressAsync(addressViewModel);
Assert.Equal(address.Country, addressViewModel.Country);
}
public void ShouldThrowArgumentNullException_WhenNullAddressIsPassed()
{
// Arrange
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedGenericRepository = new Mock <IGenericRepository <Address> >();
var addressesService = new AddressesService(mockedUnitOfWork.Object, mockedGenericRepository.Object);
// Act and Assert
Assert.Throws <ArgumentNullException>(() => addressesService.AddAddress(null));
}
public async Task UpdateAddressShouldUpdateAddress()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var repository = new EfDeletableEntityRepository <UserAddress>(dbContext);
var service = new AddressesService(repository);
var userManager = MockUserManager.GetUserManager();
// Create
var user = new ApplicationUser
{
Email = "*****@*****.**",
UserName = "******",
};
await userManager.CreateAsync(user);
var userAddress = new UserAddress()
{
UserId = user.Id,
PersonName = "User",
Area = "ValidArea",
Street = "ValidStreet",
Building = "ValidBuilding",
Floor = "ValidFloor",
Apartment = "ValidApartment",
PhoneNumber = "ValidNumber",
};
await service.CreateAsync(userAddress);
// Update
userAddress.PersonName = "UpdatedUser";
userAddress.Area = "UpdatedValidArea";
userAddress.Street = "UpdatedValidStreet";
userAddress.Building = "UpdatedValidBuilding";
userAddress.Floor = "UpdatedValidFloor";
userAddress.Apartment = "UpdatedValidApartment";
userAddress.PhoneNumber = "UpdatedValidNumber";
await service.UpdateAsync(userAddress);
var updatedAddress =
dbContext.Addresses.ToList().Find(x => x.Id == userAddress.Id);
Assert.Equal("UpdatedUser", updatedAddress.PersonName);
Assert.Equal("UpdatedValidArea", updatedAddress.Area);
Assert.Equal("UpdatedValidStreet", updatedAddress.Street);
Assert.Equal("UpdatedValidBuilding", updatedAddress.Building);
Assert.Equal("UpdatedValidFloor", updatedAddress.Floor);
Assert.Equal("UpdatedValidApartment", updatedAddress.Apartment);
Assert.Equal("UpdatedValidNumber", updatedAddress.PhoneNumber);
}
private static AddressesService SetUpAddressService()
{
var addressesList = new List <Address>
{
new Address()
{
City = "Burgas",
ZipCode = 9000,
Id = 1,
},
new Address()
{
City = "Sofia",
ZipCode = 5000,
Id = 2,
},
};
var usersList = new List <ApplicationUser>
{
new ApplicationUser()
{
Id = "1",
UserName = "******",
AddressId = 1,
Address = new Address(),
},
new ApplicationUser()
{
Id = "2",
UserName = "******",
AddressId = 2,
Address = new Address(),
},
};
var addressesMockRepo = new Mock <IDeletableEntityRepository <Address> >();
addressesMockRepo.Setup(x => x.All()).Returns(addressesList.AsQueryable());
var usersMockRepo = new Mock <IDeletableEntityRepository <ApplicationUser> >();
usersMockRepo.Setup(x => x.All()).Returns(usersList.AsQueryable());
var addressService = new AddressesService(addressesMockRepo.Object, usersMockRepo.Object);
return(addressService);
}
public void ShouldThrowArgumentNullExceptionWithCorrectMessage_WhenNullAddressIsPassed()
{
// Arrange
var expectedExMessage = "Address cannot be null.";
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedGenericRepository = new Mock <IGenericRepository <Address> >();
var addressesService = new AddressesService(mockedUnitOfWork.Object, mockedGenericRepository.Object);
// Act and Assert
var exception = Assert.Throws <ArgumentNullException>(() => addressesService.AddAddress(null));
StringAssert.Contains(expectedExMessage, exception.Message);
}
public async Task GetAddressOrCreateByCoutryNameAndTownName_WithNullTownTest_ShouldReturnArgumentNullException()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
await this.SeedData(context);
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <Address>(context);
var countryService = new Mock <ICountriesService>();
var townService = new Mock <ITownsService>();
var service = new AddressesService(repository, countryService.Object, townService.Object);
Assert.Throws <ArgumentNullException>(() => service.GetAddressOrCreateByCoutryNameAndTownName("Bulgaria", null));
}
public AddressesServiceTests()
{
this.addressList = new List <Address>();
this.addressesRepo = new Mock <IDeletableEntityRepository <Address> >();
this.addressesRepo.Setup(x => x.All()).Returns(this.addressList.AsQueryable());
this.addressesRepo.Setup(x => x.AddAsync(It.IsAny <Address>())).Callback((Address address) => this.addressList.Add(address));
this.citiesList = new List <City>();
this.citiesRepo = new Mock <IRepository <City> >();
this.citiesRepo.Setup(x => x.All()).Returns(this.citiesList.AsQueryable());
this.citiesRepo.Setup(x => x.AddAsync(It.IsAny <City>())).Callback((City city) => this.citiesList.Add(city));
this.citiesService = new CitiesService(this.citiesRepo.Object);
this.addressesService = new AddressesService(this.addressesRepo.Object, this.citiesService);
}
public async Task CreateAsyncWorksCorrectly()
{
var options = new DbContextOptionsBuilder<ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository<Address>(dbContext);
var service = new AddressesService(repository);
await service.CreateAsync(new AddressServiceModel());
var addressesInDbCount = repository.All().ToList().Count();
Assert.Equal(1, addressesInDbCount);
}
public void CreateAddressShouldCreateAddress()
{
var options = new DbContextOptionsBuilder <XeonDbContext>()
.UseInMemoryDatabase(databaseName: "Address_CreateAddress_Database")
.Options;
var dbContext = new XeonDbContext(options);
var addressService = new AddressesService(null, dbContext);
addressService.CreateAddress("Street", "Description", "Sofiya", "2000");
addressService.CreateAddress("Street", "Description", "Burgas", "8000");
var addressCount = dbContext.Addresses.ToArray().Count();
Assert.Equal(2, addressCount);
}
public void AddAddressToUserShouldAddAddressDataCorrectly()
{
var options = new DbContextOptionsBuilder <XeonDbContext>()
.UseInMemoryDatabase(databaseName: "Address_AddAddressToUser_Database")
.Options;
var dbContext = new XeonDbContext(options);
var username = "******";
var user = new XeonUser {
UserName = username
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
var userService = new Mock <IUsersService>();
userService.Setup(r => r.GetUserByUsername(username))
.Returns(dbContext.Users.FirstOrDefault(x => x.UserName == username));
var addressService = new AddressesService(userService.Object, dbContext);
var address = new Address
{
Street = "Ivan Vazov",
Description = "106",
BuildingNumber = "A",
City = new City {
Name = "Burgas", Postcode = "8000"
},
Country = "Bulgaria"
};
addressService.AddAddressToUser(username, address);
var userAddress = dbContext.Users
.FirstOrDefault(x => x.UserName == username)
.Addresses
.FirstOrDefault();
Assert.Equal(address.Street, userAddress.Street);
Assert.Equal(address.Description, userAddress.Description);
Assert.Equal(address.BuildingNumber, userAddress.BuildingNumber);
Assert.Equal(address.Country, userAddress.Country);
Assert.Equal(address.City.Name, userAddress.City.Name);
Assert.Equal(address.City.Postcode, userAddress.City.Postcode);
}
public void ShouldCallAddMethodOfAddressRepositoryOnce_WhenAAddressIsPassed()
{
// Arrange
var address = new Mock <Address>();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedGenericRepository = new Mock <IGenericRepository <Address> >();
mockedGenericRepository.Setup(gr => gr.Add(address.Object)).Verifiable();
var addressesService = new AddressesService(mockedUnitOfWork.Object, mockedGenericRepository.Object);
// Act
addressesService.AddAddress(address.Object);
// Assert
mockedGenericRepository.Verify(gr => gr.Add(address.Object), Times.Once);
}
public void ShouldCallCommitMethodOfUnitOfWorkOnce_WhenAAddressIsPassed()
{
// Arrange
var address = new Mock <Address>();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
mockedUnitOfWork.Setup(uow => uow.Commit()).Verifiable();
var mockedGenericRepository = new Mock <IGenericRepository <Address> >();
var addressesService = new AddressesService(mockedUnitOfWork.Object, mockedGenericRepository.Object);
// Act
addressesService.AddAddress(address.Object);
// Assert
mockedUnitOfWork.Verify(uow => uow.Commit(), Times.Once);
}
public async Task CreateAddressShouldCreateAddress()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var repository = new EfDeletableEntityRepository <UserAddress>(dbContext);
var service = new AddressesService(repository);
var userManager = MockUserManager.GetUserManager();
var user = new ApplicationUser
{
Email = "*****@*****.**",
UserName = "******",
};
await userManager.CreateAsync(user);
var userAddress = new UserAddress()
{
UserId = user.Id,
PersonName = "User",
Area = "ValidArea",
Street = "ValidStreet",
Building = "ValidBuilding",
Floor = "ValidFloor",
Apartment = "ValidApartment",
PhoneNumber = "ValidNumber",
};
var userAddress2 = new UserAddress()
{
UserId = user.Id,
PersonName = "",
Area = "",
Street = "",
Building = "",
Floor = "",
Apartment = "",
PhoneNumber = "",
};
await service.CreateAsync(userAddress);
await service.CreateAsync(userAddress2);
var addressCount = dbContext.Addresses.ToList().Count;
Assert.Equal(2, addressCount);
}
public async Task EditWorksCorrectly()
{
var options = new DbContextOptionsBuilder<ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository<Address>(dbContext);
var address = new Address()
{
Id = 1,
CityId = 1,
Appartment = "1",
BuildingNumber = "1",
Neighborhood = "1",
PostCode = "1",
StreetName = "1",
};
dbContext.Add(address);
await dbContext.SaveChangesAsync();
var service = new AddressesService(repository);
var editedAddress = new AddressServiceModel()
{
Id = 1,
CityId = 2,
Appartment = "2",
BuildingNumber = "2",
Neighborhood = "2",
PostCode = "2",
StreetName = "2",
};
await service.EditAsync(editedAddress);
var addressInDb = repository.All().FirstOrDefault();
Assert.Equal(editedAddress.CityId, addressInDb.CityId);
Assert.Equal(editedAddress.Appartment, addressInDb.Appartment);
Assert.Equal(editedAddress.BuildingNumber, addressInDb.BuildingNumber);
Assert.Equal(editedAddress.Neighborhood, addressInDb.Neighborhood);
Assert.Equal(editedAddress.PostCode, addressInDb.PostCode);
Assert.Equal(editedAddress.StreetName, addressInDb.StreetName);
}
public void GetAllGenericShouldMapCorrectlyUsingMoq()
{
AutoMapperConfig.RegisterMappings(typeof(ErrorViewModel).GetTypeInfo().Assembly);
var repository = new Mock <IDeletableEntityRepository <Address> >();
var country = new Country
{
Id = 1,
Name = "Bulgaria",
};
var city = new City
{
Id = 1,
Name = "Ruse",
ZIPCode = "7000",
Country = country,
};
var addressesList = new List <Address>
{
new Address {
Id = "TestId1", CreatedOn = DateTime.UtcNow, City = city, Street = "Test Street 1", UserId = "Test User 1", Description = "TestDescription"
},
new Address {
Id = "TestId1", CreatedOn = DateTime.UtcNow, City = city, Street = "Test Street 2", UserId = "Test User 2"
},
};
repository.Setup(r => r.AllAsNoTracking()).Returns(addressesList.AsQueryable());
var service = new AddressesService(repository.Object, null);
Assert.Equal("TestId1", service.GetAll <AddressViewModel>("Test User 1").FirstOrDefault().Id);
Assert.Equal("Test Street 1", service.GetAll <AddressViewModel>("Test User 1").FirstOrDefault().Street);
Assert.Equal("TestDescription", service.GetAll <AddressViewModel>("Test User 1").FirstOrDefault().Description);
Assert.Equal("Ruse", service.GetAll <AddressViewModel>("Test User 1").FirstOrDefault().CityName);
Assert.Equal("7000", service.GetAll <AddressViewModel>("Test User 1").FirstOrDefault().CityZIPCode);
Assert.Equal("Bulgaria", service.GetAll <AddressViewModel>("Test User 1").FirstOrDefault().CityCountryName);
repository.Verify(x => x.AllAsNoTracking(), Times.Exactly(6));
}
public async Task GetAddressByIdAsyncShouldReturnAddressByIdSuccessfully()
{
var option = new DbContextOptionsBuilder <MyCalisthenicAppDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new MyCalisthenicAppDbContext(option);
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new MyCalisthenicAppProfile());
});
var mapper = mockMapper.CreateMapper();
var addressService = new AddressesService(dbContext, mapper);
var city = new City
{
Id = Guid.NewGuid().ToString(),
Name = CityName,
PostCode = CityPostCode,
};
await dbContext.Cities.AddAsync(city);
await dbContext.SaveChangesAsync();
var address = new Address
{
Id = AddressId,
Country = AddressCountryName,
Street = AddressStreet,
CityId = city.Id,
};
await dbContext.Addresses.AddAsync(address);
await dbContext.SaveChangesAsync();
var expected = await addressService.GetAddressByIdAsync(AddressId);
Assert.Equal(expected.Id, address.Id);
}
public async Task DeleteAsyncShouldReturnFalseWhenIdIsInvalidUsingMoq()
{
var repository = new Mock <IDeletableEntityRepository <Address> >();
var addressesList = new List <Address>
{
new Address {
Id = "TestId1", CreatedOn = DateTime.UtcNow, Street = "Test Street 1",
},
};
repository.Setup(r => r.AllAsNoTracking()).Returns(addressesList.AsQueryable());
var service = new AddressesService(repository.Object, null);
Assert.False(await service.DeleteAsync("TestId"));
repository.Verify(x => x.AllAsNoTracking(), Times.Once);
}
public async Task GetAddressOrCreateByCoutryNameAndTownNameTest_WhitCorrectData_ShouldReturnAddress()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
await this.SeedData(context);
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <Address>(context);
var countryService = new Mock <ICountriesService>();
var townService = new Mock <ITownsService>();
var service = new AddressesService(repository, countryService.Object, townService.Object);
var actualResult = service.GetAddressOrCreateByCoutryNameAndTownName("Bulgaria", "Sofia");
var expectedResult = this.GetDummyData()[0];
Assert.Equal(expectedResult.Country.Name, actualResult.Country.Name);
Assert.Equal(expectedResult.Town.Name, actualResult.Town.Name);
}
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 void GetAllGenericShouldReturnEmptyCollectionIfUserIdIsNotFoundUsingMoq()
{
AutoMapperConfig.RegisterMappings(typeof(ErrorViewModel).GetTypeInfo().Assembly);
var repository = new Mock <IDeletableEntityRepository <Address> >();
var country = new Country
{
Id = 1,
Name = "Bulgaria",
};
var city = new City
{
Id = 1,
Name = "Ruse",
ZIPCode = "7000",
Country = country,
};
var addressesList = new List <Address>
{
new Address {
Id = "TestId1", CreatedOn = DateTime.UtcNow, City = city, Street = "Test Street 1", UserId = "Test User 1"
},
new Address {
Id = "TestId2", CreatedOn = DateTime.UtcNow, City = city, Street = "Test Street 2", UserId = "Test User 2"
},
new Address {
Id = "TestId3", CreatedOn = DateTime.UtcNow, City = city, Street = "Test Street 3", UserId = "Test User 1"
},
};
repository.Setup(r => r.AllAsNoTracking()).Returns(addressesList.AsQueryable());
var service = new AddressesService(repository.Object, null);
Assert.Empty(service.GetAll <AddressViewModel>("Test User 3"));
repository.Verify(x => x.AllAsNoTracking(), Times.Once);
}
