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); }