public async Task UpdateAsyncCorrectlyUpdatesEntity()
{
var options = new DbContextOptionsBuilder <NeedForCarsDbContext>()
.UseInMemoryDatabase("UpdateMakeDb")
.Options;
var context = new NeedForCarsDbContext(options);
var makesService = new MakesService(context);
await context.Makes.AddAsync(make1);
await context.SaveChangesAsync();
var make = make1;
make.Name = "newName";
await makesService.UpdateAsync(make);
await context.SaveChangesAsync();
var result = context.Makes
.FirstAsync().Result
.Name;
Assert.Equal("newName", result);
}
public async Task AddAsyncShouldCreateModel()
{
var options = new DbContextOptionsBuilder <NeedForCarsDbContext>()
.UseInMemoryDatabase("CreateModelDb")
.Options;
var context = new NeedForCarsDbContext(options);
var makesService = new MakesService(context);
var modelsService = new ModelsService(context, makesService);
var make = new Make
{
Name = "Make",
Description = "Desc"
};
await context.Makes.AddAsync(make);
await context.SaveChangesAsync();
var model = new Model
{
MakeId = make.Id,
Name = "Model"
};
await modelsService.AddAsync(model);
await context.SaveChangesAsync();
var result = context.Models.Count();
Assert.Equal(1, result);
}
public async Task GetAllForModelShouldReturnAllGenerationsForModel()
{
var options = new DbContextOptionsBuilder <NeedForCarsDbContext>()
.UseInMemoryDatabase("GetAllForModelGenerationDb")
.Options;
var context = new NeedForCarsDbContext(options);
var makesService = new MakesService(context);
var modelsService = new ModelsService(context, makesService);
var generationsService = new GenerationsService(context, modelsService);
var make = new Make
{
Name = "Make",
Description = "Desc"
};
await context.Makes.AddAsync(make);
await context.SaveChangesAsync();
var model = new Model
{
MakeId = make.Id,
Name = "Model"
};
await context.Models.AddAsync(model);
await context.SaveChangesAsync();
var generation1 = new Generation
{
ModelId = model.Id,
BodyType = Models.Enums.BodyType.Convertible,
Name = "Name",
Seats = 5,
Description = "Desc"
};
var generation2 = new Generation
{
ModelId = model.Id,
BodyType = Models.Enums.BodyType.Convertible,
Name = "Name2",
Seats = 5,
Description = "Desc"
};
await context.Generations.AddAsync(generation1);
await context.Generations.AddAsync(generation2);
await context.SaveChangesAsync();
var result = generationsService.GetAllForModel(model.Id).Count();
Assert.Equal(2, result);
}
public async Task AddImageToPostShouldWork()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "AddImageToPostShouldWork").Options;
var dbContext = new ApplicationDbContext(options);
var postsRepo = new EfDeletableEntityRepository <Post>(dbContext);
var makesRepo = new EfDeletableEntityRepository <Make>(dbContext);
var makesService = new MakesService(makesRepo);
var postsService = new PostsService(postsRepo, makesService);
var post = new Post()
{
Id = 1,
Name = "random name",
Price = 53222,
Currency = Currency.LV,
Mileage = 25123,
Color = new Color(),
EngineType = EngineType.Disel,
Horsepower = 255,
TransmissionType = TransmissionType.Automatic,
ManufactureDate = DateTime.Now,
Category = new Category(),
City = new City(),
User = new ApplicationUser(),
PhoneNumber = "0897456321",
Description = "random descr",
Eurostandard = Eurostandard.Five,
Condition = Condition.New,
VehicleCategory = new VehicleCategory(),
};
var image = new Image()
{
Url = "random",
};
await dbContext.Images.AddAsync(image);
await dbContext.Posts.AddAsync(post);
await dbContext.SaveChangesAsync();
var postImage = new PostImage()
{
Image = image,
ImageId = image.Id,
Post = post,
PostId = post.Id,
};
await postsService.AddImageToPost(1, postImage);
Assert.Single(post.Images);
}
private IMakesService GetMakesService()
{
var dbContext = this.GetUseInMemoryDbContext().GetAwaiter().GetResult();
IRepository <Make> repository = new EfRepository <Make>(dbContext);
IMakesService service = new MakesService(repository);
return(service);
}
public async Task AddAsyncShouldWork()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "AddAsyncShouldWork").Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Make>(dbContext);
var service = new MakesService(repository);
await service.AddAsync("BMW");
}
public async Task AddAsyncShouldThrowArgumentNull(string name)
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "AddAsyncShouldThrowArgumentNull").Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Make>(dbContext);
var service = new MakesService(repository);
await Assert.ThrowsAsync <ArgumentNullException>(() => service.AddAsync(name));
}
private async Task <IMakesService> GetMakesService()
{
var dbContext = await this.GetUseInMemoryDbContext();
var repository = new EfRepository <Make>(dbContext);
var service = new MakesService(repository);
return(service);
}
public MakesServiceTests()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
this.dbContext = new ApplicationDbContext(options);
this.makesRepository = new EfDeletableEntityRepository <Make>(this.dbContext);
this.service = new MakesService(this.makesRepository);
AutoMapperConfig.RegisterMappings(Assembly.Load("CarsVision.Web.ViewModels"));
}
public void GetMakeByNameShouldThrowErrorForNotExistingMake()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "GetMakeByIdShouldThrowErrorForNotExistingMake").Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Make>(dbContext);
var service = new MakesService(repository);
Assert.Throws <ArgumentNullException>(() => service.GetMakeByName("BMW"));
}
public void AddShould_NotThrow_WhenValuesAreCorrect()
{
// Arrange
var makeRepo = new Mock <IEfRepository <Make> >();
var uow = new Mock <IUnitOfWork>();
var make = new Mock <Make>();
// Act
var makesService = new MakesService(makeRepo.Object, uow.Object);
// Assert
makesService.Add(make.Object);
}
public void AddShould_ThrowException_WhenPassedNullAlbum()
{
// Arrange
var carRepo = new Mock <IEfRepository <Make> >();
var uow = new Mock <IUnitOfWork>();
// Act
var carsService = new MakesService(carRepo.Object, uow.Object);
// Assert
Assert.ThrowsException <ArgumentNullException>(() => carsService.Add(null));
}
public async Task UpdateAsyncShouldCorrectlyUpdateGeneration()
{
var options = new DbContextOptionsBuilder <NeedForCarsDbContext>()
.UseInMemoryDatabase("UpdateGenerationDb")
.Options;
var context = new NeedForCarsDbContext(options);
var makesService = new MakesService(context);
var modelsService = new ModelsService(context, makesService);
var generationsService = new GenerationsService(context, modelsService);
var make = new Make
{
Name = "Make",
Description = "Desc"
};
await context.Makes.AddAsync(make);
await context.SaveChangesAsync();
var model = new Model
{
MakeId = make.Id,
Name = "Model"
};
await context.Models.AddAsync(model);
await context.SaveChangesAsync();
var generation = new Generation
{
ModelId = model.Id,
BodyType = Models.Enums.BodyType.Convertible,
Name = "Name",
Seats = 5,
Description = "Desc"
};
await context.Generations.AddAsync(generation);
await context.SaveChangesAsync();
generation.Name = "updated";
await generationsService.UpdateAsync(generation);
var result = context.Generations.FirstAsync()
.Result;
Assert.Equal("updated", result.Name);
}
public async Task DeleteAsyncShouldThrowNullExceptionForNotFound()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "DeleteAsyncShouldThrowNullExceptionForNotFound").Options;
var dbContext = new ApplicationDbContext(options);
var postsRepo = new EfDeletableEntityRepository <Post>(dbContext);
var makesRepo = new EfDeletableEntityRepository <Make>(dbContext);
var makesService = new MakesService(makesRepo);
var postsService = new PostsService(postsRepo, makesService);
await Assert.ThrowsAsync <ArgumentNullException>(() => postsService.DeleteAsync(1));
}
public void GetLatestShouldThrowErrorForInvalidCount(int count)
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "GetLatestShouldThrowErrorForInvalidCount").Options;
var dbContext = new ApplicationDbContext(options);
var postsRepo = new EfDeletableEntityRepository <Post>(dbContext);
var makesRepo = new EfDeletableEntityRepository <Make>(dbContext);
var makesService = new MakesService(makesRepo);
var postsService = new PostsService(postsRepo, makesService);
Assert.Throws <ArgumentNullException>(() => postsService.GetLatest <PostDetailsViewModel>(count));
}
public async Task FilterShouldWork()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "FilterShouldWork").Options;
var dbContext = new ApplicationDbContext(options);
var postsRepo = new EfDeletableEntityRepository <Post>(dbContext);
var makesRepo = new EfDeletableEntityRepository <Make>(dbContext);
var makesService = new MakesService(makesRepo);
var postsService = new PostsService(postsRepo, makesService);
// BMW M5
var inputModel = new PostDetailsInputModel()
{
Make = 1,
Model = "M5",
MaxMileage = 15000,
};
var post1 = new Post()
{
Make = new Make()
{
Name = "BMW"
},
Model = new Model()
{
Name = "M5"
},
Mileage = 14000,
};
var post2 = new Post()
{
Make = new Make()
{
Name = "BMW"
},
Model = new Model()
{
Name = "M5"
},
Mileage = 22000,
};
await postsService.AddAsync(post1);
await postsService.AddAsync(post2);
Assert.Single(postsService.Filter(inputModel));
}
public async Task AddAsyncShouldThrowNullExceptionForInvalidPost()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "AddAsyncShouldThrowNullExceptionForInvalidPost").Options;
var dbContext = new ApplicationDbContext(options);
await dbContext.SaveChangesAsync();
var postsRepo = new EfDeletableEntityRepository <Post>(dbContext);
var makesRepo = new EfDeletableEntityRepository <Make>(dbContext);
var makesService = new MakesService(makesRepo);
var postsService = new PostsService(postsRepo, makesService);
await Assert.ThrowsAsync <ArgumentNullException>(() => postsService.AddAsync(null));
}
public async Task ExistsShouldReturnCorrectValue(string generationName, bool expected)
{
var options = new DbContextOptionsBuilder <NeedForCarsDbContext>()
.UseInMemoryDatabase("ExistsGenerationDb")
.Options;
var context = new NeedForCarsDbContext(options);
var makesService = new MakesService(context);
var modelsService = new ModelsService(context, makesService);
var generationsService = new GenerationsService(context, modelsService);
var make = new Make
{
Name = "Make",
Description = "Desc"
};
await context.Makes.AddAsync(make);
await context.SaveChangesAsync();
var model = new Model
{
MakeId = make.Id,
Name = "Model"
};
await context.Models.AddAsync(model);
await context.SaveChangesAsync();
var generation = new Generation
{
ModelId = model.Id,
BodyType = Models.Enums.BodyType.Convertible,
Name = "Generation",
Seats = 5,
Description = "Desc"
};
await context.Generations.AddAsync(generation);
await context.SaveChangesAsync();
var result = generationsService.Exists(model.Id, generationName);
Assert.Equal(expected, result);
}
public async Task GetDetailsShouldWork()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "GetDetailsShouldWork").Options;
var dbContext = new ApplicationDbContext(options);
var post = new Post()
{
Id = 1,
Name = "random name",
Price = 53222,
Currency = Currency.LV,
Mileage = 25123,
Color = new Color(),
EngineType = EngineType.Disel,
Horsepower = 255,
TransmissionType = TransmissionType.Automatic,
ManufactureDate = DateTime.Now,
Category = new Category(),
City = new City(),
User = new ApplicationUser(),
PhoneNumber = "0897456321",
Description = "random descr",
Eurostandard = Eurostandard.Five,
Condition = Condition.New,
VehicleCategory = new VehicleCategory(),
};
dbContext.Posts.Add(post);
await dbContext.SaveChangesAsync();
var postsRepo = new EfDeletableEntityRepository <Post>(dbContext);
var makesRepo = new EfDeletableEntityRepository <Make>(dbContext);
var makesService = new MakesService(makesRepo);
var postsService = new PostsService(postsRepo, makesService);
var expected = new List <Post>()
{
post
}.AsQueryable().To <PostDetailsViewModel>().FirstOrDefault();
var actual = postsService.GetDetails <PostDetailsViewModel>(1);
Assert.Equal(expected.Id, actual.Id);
Assert.Equal(expected.Name, actual.Name);
Assert.Equal(expected.PhoneNumber, actual.PhoneNumber);
Assert.Equal(expected.TransmissionType, actual.TransmissionType);
Assert.Equal(expected.Description, actual.Description);
}
public async Task GetAllGenericShouldWork()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "GetAllGenericShouldWork").Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Makes.Add(new Make());
dbContext.Makes.Add(new Make());
dbContext.Makes.Add(new Make());
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Make>(dbContext);
var service = new MakesService(repository);
Assert.Equal(3, service.GetAll <Make>().Count());
}
public async Task AddAsyncShouldWork()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "AddAsyncShouldWork").Options;
var dbContext = new ApplicationDbContext(options);
var postsRepo = new EfDeletableEntityRepository <Post>(dbContext);
var makesRepo = new EfDeletableEntityRepository <Make>(dbContext);
var makesService = new MakesService(makesRepo);
var postsService = new PostsService(postsRepo, makesService);
Assert.Empty(postsService.GetAll());
await postsService.AddAsync(new Post());
Assert.Single(postsService.GetAll());
}
public async Task AddAsyncShouldCreateMake()
{
var options = new DbContextOptionsBuilder <NeedForCarsDbContext>()
.UseInMemoryDatabase("createMakeDb")
.Options;
var context = new NeedForCarsDbContext(options);
var makesService = new MakesService(context);
await makesService.AddAsync(make1);
await context.SaveChangesAsync();
var makesCount = await context.Makes.CountAsync();
Assert.Equal(1, makesCount);
}
public async Task GetDetailsShouldThrowArgumentNullException()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "GetDetailsShouldThrowException").Options;
var dbContext = new ApplicationDbContext(options);
var post = new Post();
dbContext.Posts.Add(post);
await dbContext.SaveChangesAsync();
var postsRepo = new EfDeletableEntityRepository <Post>(dbContext);
var makesRepo = new EfDeletableEntityRepository <Make>(dbContext);
var makesService = new MakesService(makesRepo);
var postsService = new PostsService(postsRepo, makesService);
Assert.Throws <ArgumentNullException>(() => postsService.GetDetails <PostDetailsViewModel>(1));
}
public async Task TotalShouldWork()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "TotalShouldWork").Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Posts.Add(new Post());
dbContext.Posts.Add(new Post());
dbContext.Posts.Add(new Post());
await dbContext.SaveChangesAsync();
var postsRepo = new EfDeletableEntityRepository <Post>(dbContext);
var makesRepo = new EfDeletableEntityRepository <Make>(dbContext);
var makesService = new MakesService(makesRepo);
var postsService = new PostsService(postsRepo, makesService);
Assert.Equal(3, postsService.Total());
}
public async Task GetByIdShouldReturnCorrectMake()
{
var options = new DbContextOptionsBuilder <NeedForCarsDbContext>()
.UseInMemoryDatabase("GetByIdDb")
.Options;
var context = new NeedForCarsDbContext(options);
var makesService = new MakesService(context);
await context.Makes.AddAsync(make1);
await context.SaveChangesAsync();
var result = makesService.GetById(make1.Id);
Assert.Equal(make1.Name, result.Name);
}
public async Task GetAllForMakeShouldReturnAllModelsForMake()
{
var options = new DbContextOptionsBuilder <NeedForCarsDbContext>()
.UseInMemoryDatabase("ModelGetAllDb")
.Options;
var context = new NeedForCarsDbContext(options);
var makesService = new MakesService(context);
var modelsService = new ModelsService(context, makesService);
var make = new Make
{
Name = "Make",
Description = "Desc"
};
await context.Makes.AddAsync(make);
await context.SaveChangesAsync();
var model1 = new Model
{
Name = "Model1",
Description = "Desc",
MakeId = make.Id
};
var model2 = new Model
{
Name = "Model2",
Description = "Desc",
MakeId = make.Id
};
await context.Models.AddAsync(model1);
await context.Models.AddAsync(model2);
await context.SaveChangesAsync();
var result = modelsService.GetAllForMake(make.Id).Count();
Assert.Equal(2, result);
}
public async Task UpdateAsyncCorrectlyUpdatesEntity()
{
var options = new DbContextOptionsBuilder <NeedForCarsDbContext>()
.UseInMemoryDatabase("UpdateModelDb")
.Options;
var context = new NeedForCarsDbContext(options);
var makesService = new MakesService(context);
var modelsService = new ModelsService(context, makesService);
var make = new Make
{
Name = "Make",
Description = "Desc"
};
await context.Makes.AddAsync(make);
await context.SaveChangesAsync();
var model = new Model
{
Name = "Model1",
Description = "Desc",
MakeId = make.Id
};
await context.Models.AddAsync(model);
await context.SaveChangesAsync();
model.Name = "newName";
await modelsService.UpdateAsync(model);
await context.SaveChangesAsync();
var result = context.Models
.FirstAsync().Result
.Name;
Assert.Equal("newName", result);
}
public async Task GetAllShouldReturnAllMakes()
{
var options = new DbContextOptionsBuilder <NeedForCarsDbContext>()
.UseInMemoryDatabase("GetAllDb")
.Options;
var context = new NeedForCarsDbContext(options);
var makesService = new MakesService(context);
await context.Makes.AddAsync(make1);
await context.Makes.AddAsync(make2);
await context.SaveChangesAsync();
var result = await makesService.GetAll().CountAsync();
Assert.Equal(2, result);
}
public async Task ExistsShouldReturnCorrectValue(string makeName, bool expected)
{
var options = new DbContextOptionsBuilder <NeedForCarsDbContext>()
.UseInMemoryDatabase("ExistsDb")
.Options;
var context = new NeedForCarsDbContext(options);
var makesService = new MakesService(context);
await context.Makes.AddAsync(make1);
await context.Makes.AddAsync(make2);
await context.SaveChangesAsync();
var result = makesService.Exists(makeName);
Assert.Equal(expected, result);
}
public void Update_UpdatesMake_WhenValidMakeIsPassedAsParameter()
{
//Arrange
var makesRepo = new Mock <IEfRepository <Make> >();
var list = new List <Make>();
var uow = new Mock <IUnitOfWork>();
var car = new Make()
{
Name = "test"
};
var sut = new MakesService(makesRepo.Object, uow.Object);
// Act
var name = "test";
sut.Update(car);
//Assert
Assert.AreEqual(name, car.Name);
}
