public async Task UpdateAsync_ShouldChangeNameOfStyleAndDescriptionAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldChangeNameOfStyleAndDescriptionAsync");
using (var context = new BOContext(options))
{
var style = new BeerStyle()
{
Name = "Ale",
Description = "This description"
};
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var styleDTO = new BeerStyleDTO()
{
Name = "Ale2",
Description = "This description2"
};
//Act
var sut = new BeerStylesService(context);
await sut.UpdateAsync(1, styleDTO);
var dbresult = await context.BeerStyles.FindAsync(1);
//Assert
Assert.AreEqual(dbresult.Name, "Ale2");
Assert.AreEqual(dbresult.Description, "This description2");
}
}
/// <summary>
/// Updates the Style's Name and Description
/// </summary>
/// <param name="id">ID of the Style to be updated.</param>
/// <param name="model">Input object with update information.</param>
/// <returns>Returns the reevaluated input object</returns>
public async Task <BeerStyleDTO> UpdateAsync(int?id, BeerStyleDTO model)
{
var beerStyle = await this._context.BeerStyles.FindAsync(id);
if (beerStyle == null)
{
return(null);
}
beerStyle.Name = model.Name;
beerStyle.Description = model.Description;
beerStyle.ModifiedOn = DateTime.UtcNow;
model.ID = id;
this._context.Update(beerStyle);
try
{
await this._context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BeerStyleExists(id))
{
return(null);
}
}
return(model);
}
public async Task CreateAsync_ShouldReturnModifiedBeerStyleDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldReturnModifiedBeerStyleDTOAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var styleDTO = new BeerStyleDTO()
{
Name = "Ale",
Description = "This description"
};
//Act
var sut = new BeerStylesService(context);
var result = await sut.CreateAsync(styleDTO);
var dbresult = await context.BeerStyles.FirstOrDefaultAsync(c => c.Name == "Ale");
//Assert
Assert.AreEqual(result.ID, dbresult.ID);
Assert.AreEqual(result.Name, dbresult.Name);
}
}
public void MapDTOToStyle_ShouldReturnBeerStyle()
{
//Arrange
var cut = new BeerStyleDTO();
//Act
var sut = cut.MapDTOToStyle();
//Assert
Assert.IsInstanceOfType(sut, typeof(BeerStyle));
}
public void MapDTOToStyle_ShouldReturnCorrectID()
{
//Arrange
var cut = new BeerStyleDTO()
{
ID = 1
};
//Act
var sut = cut.MapDTOToStyle();
//Assert
Assert.AreEqual(sut.ID, 1);
}
public async Task <IActionResult> PostAsync([FromBody] BeerStyleDTO model)
{
if (model == null)
{
return(BadRequest());
}
var theNewStyle = await this._service.CreateAsync(model);
if (theNewStyle.ID == default)
{
return(BadRequest());
}
return(Created("Post", theNewStyle));
}
public async Task <IActionResult> PutAsync(int id, BeerStyleDTO model)
{
if (id <= 0 || model == null)
{
return(BadRequest());
}
var returnModel = await this._service.UpdateAsync(id, model);
if (returnModel == null)
{
return(NotFound());
}
return(Ok(returnModel));
}
public void MapDTOToStyle_ShouldReturnCorrectNameAndDescription()
{
//Arrange
var cut = new BeerStyleDTO()
{
Name = "Ale",
Description = "This Description"
};
//Act
var sut = cut.MapDTOToStyle();
//Assert
Assert.AreEqual(sut.Name, "Ale");
Assert.AreEqual(sut.Description, "This Description");
}
/// <summary>
/// Creates a style and writes it to the database.
/// </summary>
/// <param name="model">Input BeerStyleDTO object</param>
/// <returns>Returns the re-evaluated input object</returns>
public async Task <BeerStyleDTO> CreateAsync(BeerStyleDTO model)
{
var beerStyle = model.MapDTOToStyle();
if (beerStyle.Name == null)
{
return(null);
}
#region Check if exists
var theStyle = this._context.BeerStyles
.FirstOrDefault(b => b.Name == model.Name);
if (theStyle == null)
{
beerStyle.CreatedOn = DateTime.UtcNow;
await this._context.BeerStyles.AddAsync(beerStyle);
await this._context.SaveChangesAsync();
}
else
{
theStyle.IsDeleted = false;
theStyle.DeletedOn = null;
theStyle.ModifiedOn = DateTime.UtcNow;
_context.BeerStyles.Update(theStyle);
var beersOfBeerStyle = await _context.Beers
.Include(b => b.Country)
.Include(b => b.Brewery)
.Include(b => b.Style)
.Include(b => b.Reviews)
.Where(b => b.StyleID == theStyle.ID).
Where(b => b.Brewery.IsDeleted == false).ToListAsync();
foreach (var item in beersOfBeerStyle)
{
await new BeerService(_context).CreateAsync(item.MapBeerToDTO());
}
await this._context.SaveChangesAsync();
}
#endregion
var returnModel = await this._context.BeerStyles
.FirstOrDefaultAsync(b => b.Name == model.Name);
model.ID = returnModel.ID;
return(model);
}
public static BeerStyle MapDTOToStyle(this BeerStyleDTO dto)
{
try
{
var style = new BeerStyle()
{
ID = dto.ID,
Name = dto.Name,
Description = dto.Description
};
return(style);
}
catch (Exception)
{
return(new BeerStyle());
}
}
public static BeerStyleDTO MapViewToDTO(this BeerStyleViewModel style)
{
try
{
//TODO: Test with actual list of brewery
var styleDTO = new BeerStyleDTO()
{
ID = style.ID == 0? 0:style.ID,
Name = style.Name,
Description = style.Description
};
return(styleDTO);
}
catch (Exception)
{
return(new BeerStyleDTO());
}
}
public static BeerStyleViewModel MapDTOToView(this BeerStyleDTO styleDTO)
{
try
{
//TODO: Test with actual list of brewery
var style = new BeerStyleViewModel()
{
ID = styleDTO.ID,
Name = styleDTO.Name,
Description = styleDTO.Description
};
return(style);
}
catch (Exception)
{
return(new BeerStyleViewModel());
}
}
public async Task CreateAsync_ShouldUndeleteStyleRecordIfExist()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldUndeleteStyleRecordIfExist");
using (var context = new BOContext(options))
{
var style = new BeerStyle()
{
Name = "Ale",
Description = "This description",
DeletedOn = DateTime.UtcNow,
IsDeleted = true
};
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var styleDTO = new BeerStyleDTO()
{
Name = "Ale",
Description = "This description"
};
//Act
var sut = new BeerStylesService(context);
await sut.CreateAsync(styleDTO);
var dbresult = await context.BeerStyles.FirstOrDefaultAsync(c => c.Name == "Ale");
//Assert
Assert.AreEqual(dbresult.Name, "Ale");
Assert.AreEqual(dbresult.DeletedOn, null);
Assert.AreEqual(dbresult.IsDeleted, false);
}
}
public async Task UpdateAsync_ShouldReturnNullIfStyleNonExistantAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldReturnNullIfStyleNonExistantAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var styleDTO = new BeerStyleDTO()
{
Name = "Ale",
Description = "This description"
};
//Act
var sut = new BeerStylesService(context);
var result = await sut.UpdateAsync(1, styleDTO);
//Assert
Assert.AreEqual(result, null);
}
}
public async Task CreateAsync_ShouldReturnBeerStyleDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldReturnBeerStyleDTOAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var styleDTO = new BeerStyleDTO()
{
Name = "Ale",
Description = "This description"
};
//Act
var sut = new BeerStylesService(context);
var result = await sut.CreateAsync(styleDTO);
//Assert
Assert.IsInstanceOfType(result, typeof(BeerStyleDTO));
}
}
public async Task CreateAsync_ShouldUndeleteBeerRecordIfExist()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldUndeleteBeerRecordIfExist");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria",
Breweries = new List <Brewery>()
{
new Brewery()
{
Name = "Brewery",
}
}
};
context.Countries.Add(country);
await context.SaveChangesAsync();
var beer = new Beer()
{
Name = "Carlsberg",
ABV = 5,
Country = await context.Countries.FirstOrDefaultAsync(c => c.Name == "Bulgaria"),
Brewery = await context.Breweries.FirstOrDefaultAsync(b => b.Name == "Brewery"),
DeletedOn = DateTime.UtcNow,
IsDeleted = true,
Style = new BeerStyle()
{
Name = "Ale",
Description = "Some description",
DeletedOn = DateTime.UtcNow,
IsDeleted = true
},
Rating = 5
};
context.Beers.Add(beer);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var styleDTO = new BeerStyleDTO()
{
Name = "Ale",
Description = "This description"
};
//Act
var sut = new BeerStylesService(context);
await sut.CreateAsync(styleDTO);
var dbresult = await context.BeerStyles.FirstOrDefaultAsync(c => c.Name == "Ale");
var dbBeerResult = await context.Beers.FirstOrDefaultAsync(b => b.StyleID == dbresult.ID);
//Assert
Assert.AreEqual(dbresult.Name, "Ale");
Assert.AreEqual(dbresult.DeletedOn, null);
Assert.AreEqual(dbresult.IsDeleted, false);
Assert.AreEqual(dbBeerResult.Name, "Carlsberg");
Assert.AreEqual(dbBeerResult.DeletedOn, null);
Assert.AreEqual(dbBeerResult.IsDeleted, false);
}
}
