public async Task UpdateAsync_WithNonExistentId_ReturnsFalse()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
context.CarModels.AddRange(
new CarModel
{
Model = "OtherModel1"
},
new CarModel
{
Model = "OtherModel2"
});
context.SaveChanges();
var modelsService = new ModelsService(new EfRepository <CarModel>(context));
var serviceModel = new CarModelServiceModel
{
Id = Guid.NewGuid().ToString(),
Model = "TestName"
};
// Act
var result = await modelsService.UpdateAsync(serviceModel);
// Assert
Assert.False(result);
}
public async Task CreateAsync_WithValidModel_WorksCorrectly()
{
// Arrange
const string testName = "TestName";
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var modelsService = new ModelsService(new EfRepository <CarModel>(context));
var serviceModel = new CarModelServiceModel
{
Model = testName
};
// Act
var result = await modelsService.CreateAsync(serviceModel);
// Assert
Assert.True(result);
var addedToDb = await context.CarModels.AnyAsync(m => m.Model == testName);
Assert.True(addedToDb);
}
public async Task <bool> CreateAsync(CarModelServiceModel serviceModel)
{
if (!this.IsEntityStateValid(serviceModel))
{
return(false);
}
var model = Mapper.Map <CarModel>(serviceModel);
await this.carModelsRepository.AddAsync(model);
await this.carModelsRepository.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> Create(CarModelCreateBindingModel model, string returnUrl)
{
if (!this.ModelState.IsValid)
{
model.Manufacturers = await this.GetAllManufacturers();
return(this.View(model));
}
var manufacturer = await this.manufacturersService.GetByNameAsync(model.Manufacturer)
?? new CarManufacturerServiceModel
{
Name = model.Manufacturer
};
var carModel = new CarModelServiceModel
{
ManufacturerId = manufacturer.Id,
Manufacturer = manufacturer,
Model = model.CarModel
};
returnUrl = returnUrl ?? "/";
if (await this.modelsService.ExistsAsync(carModel))
{
this.Success(NotificationMessages.ModelExistsNotCreated);
return(this.LocalRedirect(returnUrl));
}
var result = await this.modelsService.CreateAsync(carModel);
if (result)
{
this.Success(NotificationMessages.ModelCreated);
}
else
{
this.Error(NotificationMessages.ModelCreateError);
model.Manufacturers = await this.GetAllManufacturers();
return(this.View(model));
}
return(this.LocalRedirect(returnUrl));
}
public async Task ExistsAsync_WithDifferentManufacturer_ReturnsFalse()
{
// Arrange
const string testName = "TestName";
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var manufacturer = new CarManufacturer
{
Name = "TestManufacturer"
};
context.CarModels.AddRange(
new CarModel
{
Model = testName,
Manufacturer = new CarManufacturer
{
Name = "OtherManufacturer"
}
},
new CarModel
{
Model = "OtherModel",
Manufacturer = manufacturer
});
context.SaveChanges();
var modelsService = new ModelsService(new EfRepository <CarModel>(context));
var serviceModel = new CarModelServiceModel
{
Model = testName,
ManufacturerId = manufacturer.Id
};
// Act
var result = await modelsService.ExistsAsync(serviceModel);
// Assert
Assert.False(result);
}
public async Task UpdateAsync_WithInvalidModel_DoesNotChange()
{
// Arrange
const string expectedResult = "InitialName";
var model = new CarModel
{
Model = expectedResult
};
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
context.CarModels.AddRange(
model,
new CarModel
{
Model = "OtherModel1"
},
new CarModel
{
Model = "OtherModel2"
});
context.SaveChanges();
var modelsService = new ModelsService(new EfRepository <CarModel>(context));
var serviceModel = new CarModelServiceModel
{
Id = model.Id,
Model = "a"
};
// Act
var result = await modelsService.UpdateAsync(serviceModel);
// Assert
Assert.False(result);
var actualResult = (await context.CarModels.SingleAsync(m => m.Id == model.Id)).Model;
Assert.Equal(expectedResult, actualResult);
}
public async Task CreateAsync_WithInvalidModel_ReturnsFalse()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var modelsService = new ModelsService(new EfRepository <CarModel>(context));
var serviceModel = new CarModelServiceModel();
// Act
var result = await modelsService.CreateAsync(serviceModel);
// Assert
Assert.False(result);
var dbCount = await context.CarModels.CountAsync();
Assert.Equal(0, dbCount);
}
public async Task <bool> UpdateAsync(CarModelServiceModel model)
{
if (!this.IsEntityStateValid(model) || model.Id == null)
{
return(false);
}
var carManufacturer =
await this.carModelsRepository.All().SingleOrDefaultAsync(c => c.Id == model.Id);
if (carManufacturer == null)
{
return(false);
}
carManufacturer.Model = model.Model;
this.carModelsRepository.Update(carManufacturer);
await this.carModelsRepository.SaveChangesAsync();
return(true);
}
public async Task <bool> ExistsAsync(CarModelServiceModel serviceModel)
=> await this.carModelsRepository.All().AnyAsync(m =>
m.ManufacturerId == serviceModel.ManufacturerId &&
string.Equals(m.Model, serviceModel.Model, StringComparison.InvariantCultureIgnoreCase));