public async Task CreateGenre_ShouldReturn201AndAddEntryInDb()
{
// Arrange
var databaseName = Guid.NewGuid().ToString();
BuildGenreTestDatabase(databaseName);
var createDbContext = BuildContext(databaseName);
var verifyDbContext = BuildContext(databaseName);
var mapper = BuildMapper();
var expectedName = "Test Genre";
var expectedCount = createDbContext.Genres.Count() + 1;
var createGenreDTO = new CreateGenreDTO()
{
Name = expectedName
};
var controller = new GenresController(createDbContext, mapper);
// Act
var response = await controller.Post(createGenreDTO);
var result = response as CreatedAtRouteResult;
var actualName = verifyDbContext.Genres.Find(expectedCount).Name;
var actualCount = verifyDbContext.Genres.Count();
// Assert
Assert.AreEqual(StatusCodes.Status201Created, result.StatusCode);
Assert.AreEqual(expectedName, actualName);
Assert.AreEqual(expectedCount, actualCount);
}
public async Task ReplaceGenre_InvalidId_ShouldReturnNotFound()
{
// Arrange
var databaseName = Guid.NewGuid().ToString();
var dbContext = BuildContext(databaseName);
var mapper = BuildMapper();
var testGenresCount = dbContext.Genres.Count();
var expectedName = "New Genre Name";
var createGenreDTO = new CreateGenreDTO()
{
Name = expectedName
};
var controller = new GenresController(dbContext, mapper);
// Act
var response = await controller.Put(testGenresCount + 1, createGenreDTO);
var result = response as StatusCodeResult;
// Assert
Assert.AreEqual(StatusCodes.Status404NotFound, result.StatusCode);
}
public async Task ReplaceGenre_ValidId_ShouldReplaceGenre()
{
// Arrange
var databaseName = Guid.NewGuid().ToString();
BuildGenreTestDatabase(databaseName);
var testDbContext = BuildContext(databaseName);
var verifyDbContext = BuildContext(databaseName);
var mapper = BuildMapper();
var expectedGenresCount = verifyDbContext.Genres.Count();
var expectedName = "New Genre Name";
var createGenreDTO = new CreateGenreDTO()
{
Name = expectedName
};
var controller = new GenresController(testDbContext, mapper);
// Act
var response = await controller.Put(1, createGenreDTO);
var result = response as StatusCodeResult;
var actualName = verifyDbContext.Genres.Find(1).Name;
// Assert
Assert.AreEqual(StatusCodes.Status204NoContent, result.StatusCode);
Assert.AreEqual(expectedName, actualName);
}
public async Task Create(CreateGenreDTO dto)
{
await _context.Genres.AddAsync(new Domain.Genre
{
Name = dto.Name
});
await _context.SaveChangesAsync();
}
public ActionResult <GenreDTO> Post([FromBody] CreateGenreDTO createGenreDTO)
{
var genre = mapper.Map <Genre>(createGenreDTO);
context.Add(genre);
context.SaveChanges();
var genreDTO = mapper.Map <GenreDTO>(genre);
return(new CreatedAtRouteResult("getGenre", new { id = genreDTO.Id }, genreDTO));
}
public async Task <GenreDTO> CreateGenreAsync(CreateGenreDTO createGenreDTO)
{
var genre = new GenreEntity
{
Name = createGenreDTO.Name
};
await _DBContext.Genres.AddAsync(genre);
await _DBContext.SaveChangesAsync();
var genreDTO = _mapper.Map <GenreDTO>(genre);
return(genreDTO);
}
public IActionResult Post([FromBody] CreateGenreDTO request)
{
try
{
createGenre.Execute(request);
return(StatusCode(201));
}
catch (EntityAlreadyExist e)
{
return(StatusCode(409, e.Message));
}
catch (Exception e)
{
return(StatusCode(500, "Greska"));
}
}
public void Execute(CreateGenreDTO request)
{
if (context.Genres.Any(an => an.Name == request.Name))
{
throw new EntityAlreadyExist("Zanr vec postoji");
}
var genre = new Genre
{
CreatedAt = DateTime.Now,
Name = request.Name,
IsDeleted = false
};
context.Genres.Add(genre);
context.SaveChanges();
}
public async Task <IActionResult> Post([FromBody] CreateGenreDTO dto)
{
var validator = new GenreFluentValidator(_context);
var errors = await validator.ValidateAsync(dto);
if (!errors.IsValid)
{
return(UnprocessableEntity(ValidationFormatter.Format(errors)));
}
try {
await _genreService.Create(dto);
return(StatusCode(201));
} catch (Exception) {
return(StatusCode(500, new { ServerErrorResponse.Message }));
}
}
public async Task Update(int id, CreateGenreDTO dto)
{
var genre = await _context.Genres.FirstOrDefaultAsync(g => g.Id == id);
if (genre == null)
{
throw new EntityNotFoundException("Genre");
}
if (genre.Name != dto.Name)
{
genre.Name = dto.Name;
}
_context.Entry(genre).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Put(int id, [FromBody] CreateGenreDTO dto)
{
var validator = new GenreUpdateFluentValidator(_context, id);
var errors = await validator.ValidateAsync(dto);
if (!errors.IsValid)
{
return(UnprocessableEntity(ValidationFormatter.Format(errors)));
}
try {
await _genreService.Update(id, dto);
return(NoContent());
} catch (EntityNotFoundException e) {
return(NotFound(new { e.Message }));
} catch (Exception) {
return(StatusCode(500, new { ServerErrorResponse.Message }));
}
}
public ActionResult CreateGenres(CreateGenreDTO genre)
{
_logger.LogInformation(MyLogEvents.InsertItem, "Create Genres");
if (genre == null)
{
return(BadRequest());
}
var genreEntity = _mapper.Map <Genre>(genre);
_unitOfWork.Genres.Add(genreEntity);
_unitOfWork.Complete();
var genreToReturn = _mapper.Map <GenreDTO>(genreEntity);
return(CreatedAtRoute("GetGenresWithId", new { genreId = genreEntity.Id }, new ResponseDTO <GenreDTO>()
{
Code = ResponseCodes.Success, responseMessage = "list of genres successfully returned", returnObject = genreToReturn
}));
}
public async Task <ActionResult> Put(int id, [FromBody] CreateGenreDTO createGenreDTO)
{
return(await Put <CreateGenreDTO, Genre, GenreDTO>(id, createGenreDTO));
}
public async Task <ActionResult> Post([FromBody] CreateGenreDTO createGenreDTO)
{
return(await Post <CreateGenreDTO, Genre, GenreDTO>(createGenreDTO));
}