public async Task GetByIdAsync_WithValidId_ShouldReturnCorrectly()
{
var categoryName = "test";
var category = new Category
{
Name = categoryName
};
await context.Categories.AddAsync(category);
await context.SaveChangesAsync();
var categoryFromDb = await context.Categories.FirstOrDefaultAsync(c => c.Name == categoryName);
var actualCategory = await service.GetByIdAsync(categoryFromDb.Id.ToString());
var expectedCategory = new CategoryServiceModel
{
Name = categoryFromDb.Name,
CssIconClass = categoryFromDb.CssIconClass,
Id = categoryFromDb.Id,
};
AssertEx.PropertyValuesAreEquals(actualCategory, expectedCategory);
}
public async Task <bool> CreateAllAsync(IList <string> names, IList <string> cssIcons = null)
{
if (names == null)
{
throw new ArgumentNullException(NullCategoryNamesListErrorMessage);
}
if (cssIcons != null && cssIcons.Count != 0 && cssIcons.Count != names.Count)
{
throw new ArgumentNullException(InvalidCategoryIconList);
}
for (int i = 0; i < names.Count; i++)
{
var categoryServiceModel = new CategoryServiceModel
{
Name = names[i],
CssIconClass = null
};
if (cssIcons != null)
{
categoryServiceModel.CssIconClass = cssIcons[i];
}
await CreateAsync(categoryServiceModel);
}
var result = await context.SaveChangesAsync();
return(result > 0);
}
private async Task <CategoryServiceModel> Update(CategoryServiceModel model)
{
var category = await _appDbContext.Categories.FindAsync(model.Id);
category.Name = model.Name.Trim();
await _appDbContext.SaveChangesAsync();
return(Mapper.Map <CategoryServiceModel>(category));
}
private LeafSelectorItemViewModel MapFrom(CategoryServiceModel m)
{
return(m == null ? null : new LeafSelectorItemViewModel()
{
Id = m.Id,
Text = m.Text,
IsLeaf = m.IsLeaf
});
}
public async Task <CategoryServiceModel> CreateCategoryAsync(CategoryServiceModel categoryServiceModel)
{
Category category = categoryServiceModel.To <Category>();
await this.context.Categories.AddAsync(category);
await this.context.SaveChangesAsync();
return(categoryServiceModel);
}
public async Task CreateAsync_WithInvalidName_ShouldThrowArgumentNullException()
{
var category = new CategoryServiceModel
{
Name = null,
CssIconClass = null
};
Assert.ThrowsAsync <ArgumentNullException>(async() => await service.CreateAsync(category));
}
public async Task <int> CreateAsync(CategoryServiceModel input)
{
var category = input.To <Category>();
await this.categoryRepository.AddAsync(category);
await this.categoryRepository.SaveChangesAsync();
return(category.Id);
}
public IActionResult CreateCategory(CategoryCreateBindingModel categoryCreateBindingModel)
{
CategoryServiceModel categoryServiceModel = new CategoryServiceModel
{
Name = categoryCreateBindingModel.Name
};
productService.CreateCategory(categoryServiceModel);
return(Redirect("/"));
}
public async Task <IActionResult> Create([FromBody] CategoryServiceModel model)
{
var exists = await this.categories.CategoryExistsAsync(model.Name);
if (exists)
{
return(BadRequest("Category already exists."));
}
return(Ok(await this.categories.CreateAsync(model.Name)));
}
public bool CreateCategory(CategoryServiceModel categoryServiceModel)
{
Category category = new Category()
{
Name = categoryServiceModel.Name
};
shopDbContext.Categories.Add(category);
var result = shopDbContext.SaveChanges();
return(result > 0);
}
public async Task UpdateAsync(CategoryServiceModel input)
{
var category = await this.categoryRepository
.GetByIdAsync(input.Id);
category.Name = input.Name;
category.ParentCategoryId = input.ParentCategoryId;
category.Description = input.Description;
category.ImageUrl = input.ImageUrl;
this.categoryRepository.Update(category);
await this.categoryRepository.SaveChangesAsync();
}
public async Task <Option <CategoryServiceModel, Error> > UpdateByModel(CategoryServiceModel model)
{
if (await Exists(model.Id))
{
if (await Exists(model.Name))
{
return(Option.None <CategoryServiceModel, Error>($"Category '{model.Name}' already exists.".ToError()));
}
return((await Update(model)).Some <CategoryServiceModel, Error>());
}
return(Option.None <CategoryServiceModel, Error>($"Category with ID: {model.Id} does not exists.".ToError()));
}
public async Task CreateAsync_WithValidData_ShouldCreateSuccessfully()
{
var category = new CategoryServiceModel
{
Name = "Test",
CssIconClass = "test"
};
var result = await service.CreateAsync(category);
var actualCategoryCount = context.Categories.Count();
var expectedCategoryCount = 1;
Assert.True(result);
Assert.AreEqual(expectedCategoryCount, actualCategoryCount);
}
public async Task <CategoryServiceModel> GetByIdAsync(string id)
{
if (!await ContainsByIdAsync(id))
{
throw new ArgumentException(InvalidIdErrorMessage);
}
var category = await context.Categories.SingleOrDefaultAsync(c => c.Id == id);
var categoryServiceModel = new CategoryServiceModel
{
Id = category.Id,
Name = category.Name,
CssIconClass = category.CssIconClass
};
return(categoryServiceModel);
}
public void Remove(CategoryServiceModel category)
{
if (String.IsNullOrWhiteSpace(category.Name))
{
throw new ArgumentException("Category name cannot be null!");
}
var categoryToRemove = context.Categories
.FirstOrDefault(c => c.Name == category.Name);
if (categoryToRemove == null)
{
throw new InvalidOperationException("No such category exists!");
}
context.Categories.Remove(categoryToRemove);
context.SaveChanges();
}
public async Task <CategoryServiceModel> GetByNameAsync(string name)
{
var category = await context.Categories.SingleOrDefaultAsync(c => c.Name == name);
if (category == null)
{
throw new ArgumentException(InvalidNameErrorMessage);
}
var categoryServiceModel = new CategoryServiceModel
{
Id = category.Id,
Name = category.Name,
CssIconClass = category.CssIconClass
};
return(categoryServiceModel);
}
public async Task GetAll_ShouldReturnCorrectly()
{
var categoryName = "test";
var categoryName2 = "test2";
var category = new Category
{
Name = categoryName
};
var category2 = new Category
{
Name = categoryName2
};
await context.Categories.AddAsync(category);
await context.Categories.AddAsync(category2);
await context.SaveChangesAsync();
var categories = service.GetAll().ToList();
var expectedCategory = new CategoryServiceModel
{
Name = category.Name,
CssIconClass = category.CssIconClass,
Id = category.Id,
};
var expectedCategory2 = new CategoryServiceModel
{
Name = category2.Name,
CssIconClass = category2.CssIconClass,
Id = category2.Id,
};
var expectedCategoriesCount = 2;
var actualCategoriesCount = categories.Count;
Assert.AreEqual(expectedCategoriesCount, actualCategoriesCount);
AssertEx.PropertyValuesAreEquals(categories[0], expectedCategory);
AssertEx.PropertyValuesAreEquals(categories[1], expectedCategory2);
}
public async Task <CategoryServiceModel> EditCategoryAsync(CategoryServiceModel categoryServiceModel)
{
var category = this.context.Categories
.FirstOrDefault(x => x.Id == categoryServiceModel.Id);
if (category == null)
{
throw new ArgumentNullException(nameof(category));
}
category.Name = categoryServiceModel.Name;
category.MainCategoryId = categoryServiceModel.MainCategoryId;
this.context.Categories.Update(category);
await this.context.SaveChangesAsync();
return(categoryServiceModel);
}
public async Task EditAsync_WithNonExistentId_ShouldThrowArgumentNullException()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var categoryRepository = new EfDeletableEntityRepository <Category>(context);
var categoryService = new CategoryService(categoryRepository);
var categoryServiceModel = new CategoryServiceModel
{
Id = 10000,
Title = "NonExistent",
};
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await categoryService.EditAsync(categoryServiceModel);
});
}
public async Task <bool> CreateAsync(CategoryServiceModel categoryServiceModel)
{
var category = new Category
{
Name = categoryServiceModel.Name,
CssIconClass = categoryServiceModel.CssIconClass
};
if (string.IsNullOrEmpty(category.Name) ||
string.IsNullOrWhiteSpace(category.Name))
{
throw new ArgumentNullException(NullOrEmptyNameErrorMessage);
}
await context.Categories.AddAsync(category);
var result = await context.SaveChangesAsync();
var categories = context.Categories.ToList();
return(result > 0);
}
public async Task UpdateAsyncWorksCorrectly()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Category>(dbContext);
var service = new CategoriesService(repository);
var category = new Category()
{
Id = 1,
Name = "1",
ParentCategoryId = null,
Description = "1",
ImageUrl = "1",
};
dbContext.Add(category);
await dbContext.SaveChangesAsync();
var editedCategory = new CategoryServiceModel()
{
Id = 1,
Name = "2",
ParentCategoryId = 1,
Description = "2",
ImageUrl = "2",
};
await service.UpdateAsync(editedCategory);
var result = dbContext.Categories.Find(1);
Assert.Equal(editedCategory.Name, result.Name);
Assert.Equal(editedCategory.ParentCategoryId, result.ParentCategoryId);
Assert.Equal(editedCategory.Description, result.Description);
Assert.Equal(editedCategory.ImageUrl, result.ImageUrl);
}
public async Task GetByNameAsync_WithValidName_ShouldReturnCorrectly()
{
var categoryName = "test";
var category = new Category
{
Name = categoryName
};
await context.Categories.AddAsync(category);
await context.SaveChangesAsync();
var actualCategory = await service.GetByNameAsync(category.Name);
var expectedCategory = new CategoryServiceModel
{
Name = category.Name,
CssIconClass = category.CssIconClass,
Id = category.Id,
};
AssertEx.PropertyValuesAreEquals(actualCategory, expectedCategory);
}
public async Task <IActionResult> Put([FromBody] CategoryServiceModel model) => (await _categoryService.UpdateByModel(model)) .Match(Ok, Error);
