public void ReturnCorrectList_WhenDataIsPresent()
{
var options = Utils.GetOptions(nameof(ReturnCorrectList_WhenDataIsPresent));
var country = TestsModelsSeeder.SeedCountry();
var brewery1 = TestsModelsSeeder.SeedBrewery();
var brewery2 = TestsModelsSeeder.SeedBrewery2();
var brewery3 = TestsModelsSeeder.SeedBrewery3();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.Breweries.Add(brewery1);
arrangeContext.Breweries.Add(brewery2);
arrangeContext.Breweries.Add(brewery3);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
var result = sut.GetAllBreweries().ToList();
Assert.AreEqual(3, result.Count);
Assert.AreEqual(brewery1.Name, result[0].Name);
Assert.AreEqual(brewery2.Name, result[1].Name);
Assert.AreEqual(brewery3.Name, result[2].Name);
}
}
public async Task GetAllAsync_ShouldReturnNullBreweryIfModelHasNoNameAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAllAsync_ShouldReturnNullBreweryIfModelHasNoNameAsync");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria",
Breweries = new List <Brewery>()
{
new Brewery()
}
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BreweryServices(context);
var result = await sut.GetAllAsync();
//Assert
Assert.AreEqual(result, null);
}
}
public async Task CreateAsync_ShouldRecordBreweryIfNotOnRecordAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldRecordBreweryIfNotOnRecordAsync");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria"
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var breweryDTO = new BreweryDTO()
{
Name = "Brewery",
Country = "Bulgaria"
};
//Act
var sut = new BreweryServices(context);
await sut.CreateAsync(breweryDTO);
var dbresult = await context.Breweries.Include(b => b.Country).FirstOrDefaultAsync(c => c.Name == "Brewery");
//Assert
Assert.AreEqual(dbresult.Name, "Brewery");
}
}
public async Task GetAllAsync_ShouldReturnIEnumerableBreweryyDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAllAsync_ShouldReturnIEnumerableBreweryyDTOAsync");
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();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BreweryServices(context);
var result = await sut.GetAllAsync();
//Assert
Assert.IsInstanceOfType(result, typeof(IEnumerable <BreweryDTO>));
}
}
public async Task DeleteAsync_ShouldReturnTrueIfBrewerySucceded()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldReturnTrueIfBrewerySucceded");
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();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BreweryServices(context);
var result = await sut.DeleteAsync(1);
//Assert
Assert.AreEqual(result, true);
}
}
public void Throw_WhenIdIsInvalid()
{
var options = Utils.GetOptions(nameof(Throw_WhenIdIsInvalid));
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
Assert.ThrowsException <ArgumentNullException>(() => sut.GetBrewery(1));
}
}
public async Task UpdateAsync_ShouldChangeNameAndCountryOfBreweryAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldChangeNameOfBreweryAsync");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria",
Breweries = new List <Brewery>()
{
new Brewery()
{
Name = "Brewery"
}
}
};
var country2 = new Country()
{
Name = "Belgium"
};
context.Countries.Add(country);
context.Countries.Add(country2);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var breweryDTO = new BreweryDTO()
{
Name = "Brewery2",
Country = "Belgium"
};
//Act
var sut = new BreweryServices(context);
await sut.UpdateAsync(1, breweryDTO);
var dbresult = await context.Breweries.Include(b => b.Country).FirstOrDefaultAsync(b => b.ID == 1);
//Assert
Assert.AreEqual(dbresult.Name, "Brewery2");
Assert.AreEqual(dbresult.Country.Name, "Belgium");
}
}
public void ReturnFalse_WhenIdIsIncorrect()
{
var options = Utils.GetOptions(nameof(ReturnFalse_WhenIdIsIncorrect));
var brewery = TestsModelsSeeder.SeedBrewery();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Breweries.Add(brewery);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
var result = sut.DeleteBrewery(brewery.Id + 1);
Assert.IsFalse(result);
}
}
public async Task CreateAsync_ShouldUndeleteRecordBreweryIfExist()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldUndeleteRecordIfExist");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria"
};
context.Countries.Add(country);
await context.SaveChangesAsync();
var brewery = new Brewery()
{
Name = "Brewery",
Country = await context.Countries.FirstOrDefaultAsync(c => c.Name == "Bulgaria"),
DeletedOn = DateTime.UtcNow,
IsDeleted = true
};
context.Breweries.Add(brewery);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var breweryDTO = new BreweryDTO()
{
Name = "Brewery",
Country = "Bulgaria"
};
//Act
var sut = new BreweryServices(context);
await sut.CreateAsync(breweryDTO);
var dbresult = await context.Breweries.FirstOrDefaultAsync(c => c.Name == "Brewery");
//Assert
Assert.AreEqual(dbresult.Name, "Brewery");
Assert.AreEqual(dbresult.DeletedOn, null);
Assert.AreEqual(dbresult.IsDeleted, false);
}
}
public void Throw_WhenBreweryIdIsInvalid()
{
var options = Utils.GetOptions(nameof(Throw_WhenBreweryIdIsInvalid));
var brewery1 = TestsModelsSeeder.SeedBrewery();
var brewery2 = TestsModelsSeeder.SeedBrewery2();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Breweries.Add(brewery1);
arrangeContext.Breweries.Add(brewery2);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
Assert.ThrowsException <ArgumentNullException>(() => sut.UpdateBrewery(5, "NewBrewery", "Bulgaria"));
}
}
public async Task UpdateAsync_ShouldReturnNullIfBreweryDTONullAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldReturnNullIfBreweryDTONullAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
//Act
var sut = new BreweryServices(context);
var result = await sut.UpdateAsync(1, null);
//Assert
Assert.AreEqual(result, null);
}
}
public async Task GetAllAsync_ShouldReturnEmptyIfNoBreweriesAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAllAsync_ShouldReturnEmptyIfNoBreweriesAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
//Act
var sut = new BreweryServices(context);
var result = await sut.GetAllAsync();
//Assert
Assert.AreEqual(result.Count(), 0);
}
}
public async Task DeleteAsync_ShouldReturnFalseIfBreweryDoesntExistAsync()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldReturnFalseIfBreweryDoesntExistAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
//Act
var sut = new BreweryServices(context);
var result = await sut.DeleteAsync(1);
//Assert
Assert.AreEqual(result, false);
}
}
public void Throw_WhenBreweryAlreadyExists()
{
var options = Utils.GetOptions(nameof(Throw_WhenBreweryAlreadyExists));
var breweryDTO = TestsModelsSeeder.SeedBreweryDTO();
var brewery = TestsModelsSeeder.SeedBrewery();
var country = TestsModelsSeeder.SeedCountry();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.Breweries.Add(brewery);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
Assert.ThrowsException <ArgumentException>(() => sut.CreateBrewery(breweryDTO));
}
}
public void DeleteBrewery_WhenIdIsCorrect()
{
var options = Utils.GetOptions(nameof(DeleteBrewery_WhenIdIsCorrect));
var brewery = TestsModelsSeeder.SeedBrewery();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Breweries.Add(brewery);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
var act = sut.DeleteBrewery(brewery.Id);
var result = assertContext.Breweries.FirstOrDefault(b => b.Name == brewery.Name);
Assert.IsTrue(result.IsDeleted);
}
}
public async Task CreateAsync_ShouldReturnModifiedBreweryDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldReturnModifiedBreweryDTOAsync");
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();
}
using (var context = new BOContext(options))
{
var breweryDTO = new BreweryDTO()
{
Name = "Brewery",
Country = "Bulgaria"
};
//Act
var sut = new BreweryServices(context);
var result = await sut.CreateAsync(breweryDTO);
var dbresult = await context.Breweries.FirstOrDefaultAsync(c => c.Name == "Brewery");
//Assert
Assert.AreEqual(result.ID, dbresult.ID);
Assert.AreEqual(result.Name, dbresult.Name);
}
}
public void ReturnCorrectBrewery_WhenParamsAreValid()
{
var options = Utils.GetOptions(nameof(ReturnCorrectBrewery_WhenParamsAreValid));
var breweryDTO = TestsModelsSeeder.SeedBreweryDTO();
var country = TestsModelsSeeder.SeedCountry();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
var act = sut.CreateBrewery(breweryDTO);
var result = assertContext.Breweries.FirstOrDefault(brewery => brewery.Name == breweryDTO.Name);
Assert.AreEqual(breweryDTO.Id, result.Id);
Assert.AreEqual(breweryDTO.Name, result.Name);
Assert.AreEqual(breweryDTO.Country, result.Country.Name);
}
}
public async Task GetAsync_ShouldReturnNullIfBreweryModelConversionFailsAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAsync_ShouldReturnNullIfBreweryModelConversionFailsAsync");
using (var context = new BOContext(options))
{
var brewery = new Brewery();
context.Breweries.Add(brewery);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BreweryServices(context);
var result = await sut.GetAsync(1);
//Assert
Assert.AreEqual(result, null);
}
}
public void CorrectlyUpdate_WhenDataIsValid()
{
var options = Utils.GetOptions(nameof(CorrectlyUpdate_WhenDataIsValid));
var country = TestsModelsSeeder.SeedCountry();
var brewery1 = TestsModelsSeeder.SeedBrewery();
var brewery2 = TestsModelsSeeder.SeedBrewery2();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.Breweries.Add(brewery1);
arrangeContext.Breweries.Add(brewery2);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
var act = sut.UpdateBrewery(2, "NewBrewery", "Bulgaria");
var result = sut.GetBrewery(2);
Assert.AreEqual("NewBrewery", result.Name);
Assert.AreEqual("Bulgaria", result.Country);
}
}
public void ReturnCorrectBrewery_WhenIdIsValid()
{
var options = Utils.GetOptions(nameof(ReturnCorrectBrewery_WhenIdIsValid));
var country = TestsModelsSeeder.SeedCountry();
var brewery1 = TestsModelsSeeder.SeedBrewery();
var brewery2 = TestsModelsSeeder.SeedBrewery2();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.Breweries.Add(brewery1);
arrangeContext.Breweries.Add(brewery2);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
var result = sut.GetBrewery(2);
Assert.AreEqual(brewery2.Id, result.Id);
Assert.AreEqual(brewery2.Name, result.Name);
Assert.AreEqual(brewery2.Country.Name, result.Country);
}
}
public async Task UpdateAsync_ShouldReturnNullIfBreweryNonExistantAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldReturnNullIfBreweryNonExistantAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var breweryDTO = new BreweryDTO()
{
Name = "Brewery",
Country = "Bulgaria"
};
//Act
var sut = new BreweryServices(context);
var result = await sut.UpdateAsync(1, breweryDTO);
//Assert
Assert.AreEqual(result, null);
}
}
public async Task DeleteAsync_ShouldDeleteBreweryIfExist()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldDeleteBreweryIfExist");
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();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BreweryServices(context);
await sut.DeleteAsync(1);
var dbresult = await context.Breweries.FirstOrDefaultAsync(c => c.Name == "Brewery");
//Assert
Assert.AreEqual(dbresult.Name, "Brewery");
Assert.AreEqual(dbresult.DeletedOn, dbresult.ModifiedOn);
Assert.AreEqual(dbresult.IsDeleted, true);
}
}
public async Task DeleteAsync_ShouldDeleteRecordBeersIfExist()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldDeleteRecordBeersIfExist");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria",
DeletedOn = DateTime.UtcNow,
IsDeleted = true,
Breweries = new List <Brewery>()
{
new Brewery()
{
Name = "Brewery",
DeletedOn = DateTime.UtcNow,
IsDeleted = true,
}
}
};
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"
},
Rating = 5
};
context.Beers.Add(beer);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var breweryDTO = new BreweryDTO()
{
Name = "Brewery",
Country = "Bulgaria"
};
//Act
var sut = new BreweryServices(context);
await sut.DeleteAsync(1);
var dbresult = await context.Breweries.FirstOrDefaultAsync(c => c.Name == "Brewery");
var dbBeerResult = await context.Beers
.Include(b => b.Style)
.Include(b => b.Reviews)
.Include(b => b.Country)
.Include(b => b.WishLists)
.Include(b => b.DrankLists)
.FirstOrDefaultAsync(b => b.Name == "Carlsberg");
//Assert
Assert.AreEqual(dbresult.Name, "Brewery");
Assert.AreEqual(dbresult.DeletedOn, dbresult.ModifiedOn);
Assert.AreEqual(dbresult.IsDeleted, true);
Assert.AreEqual(dbBeerResult.Name, "Carlsberg");
Assert.AreEqual(dbBeerResult.DeletedOn, dbBeerResult.ModifiedOn);
Assert.AreEqual(dbBeerResult.IsDeleted, true);
}
}
