public async Task CreateUser_When_ParamsAreValid()
{
var options = TestUtils.GetOptions(nameof(CreateUser_When_ParamsAreValid));
var mockDateTime = new Mock <IDateTimeProvider>();
var userDTO = new UserDTO
{
Username = "******",
Country = "Bulgaria",
};
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new UserService(assertContext, mockDateTime.Object);
try
{
var result = await sut.CreateUserAsync(userDTO);
}
catch (Exception)
{
throw;
}
var comparison = assertContext.Users.Where(x => x.Id == 1).FirstOrDefault();
Assert.AreEqual("BoikoBorisov2", comparison.UserName);
Assert.AreEqual("Bulgaria", comparison.Country);
}
}
public async Task UpdateCountry_If_ItExists()
{
var options = TestUtils.GetOptions(nameof(UpdateCountry_If_ItExists));
var mockDateTime = new Mock <IDateTimeProvider>();
var style = new Style
{
Name = "Pale"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Styles.AddAsync(style);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new StyleService(assertContext, mockDateTime.Object);
var result = await sut.UpdateStyleAsync(1, "Dark Lagers");
Assert.AreEqual("Dark Lagers", result.Name);
}
}
public async Task DeleteUser_When_ParamsAreValid()
{
var options = TestUtils.GetOptions(nameof(DeleteUser_When_ParamsAreValid));
var mockDateTime = new Mock <IDateTimeProvider>();
var user = new User
{
UserName = "******"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new UserService(assertContext, mockDateTime.Object);
await sut.DeleteUserAsync(1);
var result = assertContext.Users.Where(x => x.Id == 1).FirstOrDefault();
Assert.IsTrue(result.isDeleted);
}
}
public async Task UpdateUser_If_BeerExist()
{
var options = TestUtils.GetOptions(nameof(UpdateUser_If_BeerExist));
var mockDateTime = new Mock <IDateTimeProvider>();
var user = new User
{
UserName = "******",
Country = "Canada"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new UserService(assertContext, mockDateTime.Object);
var result = await sut.UpdateUserAsync(1, "Dax");
Assert.AreEqual("Dax", result.Username);
}
}
public async Task ThrowNullExc_If_UserAlreadyExists()
{
var options = TestUtils.GetOptions(nameof(ThrowNullExc_If_UserAlreadyExists));
var mockDateTime = new Mock <IDateTimeProvider>();
var user = new User
{
UserName = "******"
};
var userDTO = new UserDTO
{
Username = "******"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new UserService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.CreateUserAsync(userDTO));
}
}
public async Task ReturnTrue_If_Succeds()
{
var options = TestUtils.GetOptions(nameof(ReturnTrue_If_Succeds));
var mockDateTime = new Mock <IDateTimeProvider>();
var review = new Review
{
isFlagged = false,
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Reviews.AddAsync(review);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new UserService(assertContext, mockDateTime.Object);
await sut.ReviewFlagAsync(1);
var result = assertContext.Reviews.Where(x => x.Id == 1).FirstOrDefault();
Assert.IsTrue(result.isFlagged);
}
}
public async Task RateBeer_When_ParamsAreValid()
{
var options = TestUtils.GetOptions(nameof(RateBeer_When_ParamsAreValid));
var mockDateTime = new Mock <IDateTimeProvider>();
var country = new Country
{
Name = "Romania"
};
var brewery = new Brewery
{
Name = "Ariana",
CountryId = 1
};
var style = new Style
{
Name = "Pale"
};
var beer = new Beer
{
Name = "Zagorka",
CountryId = 1,
BreweryId = 1,
StyleId = 1,
Abv = 3
};
var user = new User
{
UserName = "******",
Country = "Bulgaristan"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.Breweries.AddAsync(brewery);
await arrangeContext.Styles.AddAsync(style);
await arrangeContext.Beers.AddAsync(beer);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BeerService(assertContext, mockDateTime.Object);
await sut.RateAsync(1, 1, 4.5);
var check = await assertContext.Ratings.Where(x => x.BeerId == 1).ToListAsync();
Assert.AreEqual(4.5, check[0].RatingValue);
Assert.AreEqual(1, check.Count());
}
}
public async Task Return_OneUser_When_Exist()
{
var options = TestUtils.GetOptions(nameof(Return_OneUser_When_Exist));
var mockDateTime = new Mock <IDateTimeProvider>();
var user = new User
{
UserName = "******",
Country = "America",
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new UserService(assertContext, mockDateTime.Object);
var resultDTO = await sut.GetUserAsync(1);
Assert.AreEqual(1, resultDTO.Id);
Assert.AreEqual("Future", resultDTO.Username);
Assert.AreEqual("America", resultDTO.Country);
}
}
public async Task Succeed_If_NotNull()
{
var options = TestUtils.GetOptions(nameof(Succeed_If_NotNull));
var mockDateTime = new Mock <IDateTimeProvider>();
var country = new Country
{
Id = 1,
Name = "Bulgaria"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new CountryService(assertContext, mockDateTime.Object);
var result = await sut.GetCountryAsync(1);
Assert.AreEqual(country.Id, result.Id);
Assert.AreEqual(country.Name, result.Name);
}
}
public async Task ReturnTrue_When_ParamsAreValid()
{
var options = TestUtils.GetOptions(nameof(ReturnTrue_When_ParamsAreValid));
var mockDateTime = new Mock <IDateTimeProvider>();
var country = new Country
{
Id = 1,
Name = "Bulgaria"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new CountryService(assertContext, mockDateTime.Object);
await sut.DeleteCountryAsync(1);
var result = assertContext.Countries.Where(x => x.Id == 1).FirstOrDefault();
Assert.IsTrue(result.isDeleted);
}
}
public async Task Create_When_ParamsAreValid()
{
var options = TestUtils.GetOptions(nameof(Create_When_ParamsAreValid));
var mockDateTime = new Mock <IDateTimeProvider>();
var country = new Country
{
Name = "Romania"
};
var breweryDTO = new BreweryDTO
{
Name = "Ariana",
Country = "Romania"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BreweryService(assertContext, mockDateTime.Object);
var result = await sut.CreateBreweryAsync(breweryDTO);
var comparison = assertContext.Breweries.Where(x => x.Id == 1).FirstOrDefault();
Assert.AreEqual("Ariana", comparison.Name);
}
}
public async Task GetStyle_If_StyleExists()
{
var options = TestUtils.GetOptions(nameof(GetStyle_If_StyleExists));
var mockDateTime = new Mock <IDateTimeProvider>();
var style = new Style
{
Id = 1,
Name = "Pale"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Styles.AddAsync(style);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new StyleService(assertContext, mockDateTime.Object);
var result = await sut.GetStyleAsync(1);
Assert.AreEqual(style.Id, result.Id);
Assert.AreEqual(style.Name, result.Name);
}
}
public async Task Update_If_BreweryExist()
{
var options = TestUtils.GetOptions(nameof(Update_If_BreweryExist));
var mockDateTime = new Mock <IDateTimeProvider>();
var country = new Country
{
Name = "Bulgaria"
};
var brewery = new Brewery
{
Name = "Ariana",
CountryId = 1
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.Breweries.AddAsync(brewery);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BreweryService(assertContext, mockDateTime.Object);
var result = await sut.UpdateBreweryAsync(1, "Kamenitza");
Assert.AreEqual("Kamenitza", result.Name);
}
}
public async Task ThrowExc_If_StyleAlreadyExist()
{
var options = TestUtils.GetOptions(nameof(ThrowExc_If_StyleAlreadyExist));
var mockDateTime = new Mock <IDateTimeProvider>();
var style = new Style
{
Name = "Pale"
};
var styleDTO = new StyleDTO
{
Name = "Pale"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Styles.AddAsync(style);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new StyleService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.CreateStyleAsync(styleDTO));
}
}
public async Task UnBanUser_If_Successfull()
{
var options = TestUtils.GetOptions(nameof(UnBanUser_If_Successfull));
var mockDateTime = new Mock <IDateTimeProvider>();
var user = new User
{
isBanned = true,
LockoutEnabled = true
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new UserService(assertContext, mockDateTime.Object);
await sut.UnbanUserAsync(1);
var result = assertContext.Users.Where(x => x.Id == 1).FirstOrDefault();
Assert.IsFalse(result.isBanned);
}
}
public async Task CreateCountry_Fail_IfAlreadyExists()
{
var options = TestUtils.GetOptions(nameof(CreateCountry_Fail_IfAlreadyExists));
var mockDateTime = new Mock <IDateTimeProvider>();
var country = new Country
{
Name = "Bulgaria"
};
var countryDTO = new CountryDTO
{
Name = "Bulgaria"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new CountryService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.CreateCountryAsync(countryDTO));
}
}
public async Task RetrieveAllFlaggedReviews()
{
var options = TestUtils.GetOptions(nameof(RetrieveAllFlaggedReviews));
var mockDateTime = new Mock <IDateTimeProvider>();
var user = new User
{
UserName = "******",
};
var beer = new Beer
{
Name = "Zagorka",
};
var review = new Review
{
UserId = 1,
BeerId = 1,
isFlagged = true,
};
var review2 = new Review
{
UserId = 1,
BeerId = 1,
isFlagged = true,
};
var review3 = new Review
{
UserId = 1,
BeerId = 1,
isFlagged = true,
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Users.AddAsync(user);
await arrangeContext.Beers.AddAsync(beer);
await arrangeContext.Reviews.AddAsync(review);
await arrangeContext.Reviews.AddAsync(review2);
await arrangeContext.Reviews.AddAsync(review3);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new UserService(assertContext, mockDateTime.Object);
var resultDTOs = await sut.RetreiveAllFlaggedReviewsAsync();
var result = resultDTOs.Select(x => x.isFlagged).ToList();
var expected = 3;
Assert.AreEqual(expected, result.Count);
}
}
public async Task FailRate_If_BeerDoesNotExist()
{
var options = TestUtils.GetOptions(nameof(FailRate_If_BeerDoesNotExist));
var mockDateTime = new Mock <IDateTimeProvider>();
var country = new Country
{
Name = "Romania"
};
var brewery = new Brewery
{
Name = "Ariana",
CountryId = 1
};
var style = new Style
{
Name = "Pale"
};
var beer = new Beer
{
Name = "Zagorka",
CountryId = 1,
BreweryId = 1,
StyleId = 1,
Abv = 3
};
var user = new User
{
UserName = "******",
Country = "Bulgaristan"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.Breweries.AddAsync(brewery);
await arrangeContext.Styles.AddAsync(style);
await arrangeContext.Beers.AddAsync(beer);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BeerService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.RateAsync(2, 1, 4.5));
}
}
public async Task Throw_When_NoBreweryExist()
{
var options = TestUtils.GetOptions(nameof(Throw_When_NoBreweryExist));
var mockDateTime = new Mock <IDateTimeProvider>();
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BreweryService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.GetAllBreweriesAsync());
}
}
public async Task FailFilterByStyle_WhenNoBeerExist()
{
var options = TestUtils.GetOptions(nameof(FailFilterByStyle_WhenNoBeerExist));
var mockDateTime = new Mock <IDateTimeProvider>();
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BeerService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.FilterByStyleAsync("Romania"));
}
}
public async Task ReturnFalse_When_ParamsAreInValid()
{
var options = TestUtils.GetOptions(nameof(ReturnFalse_When_ParamsAreInValid));
var mockDateTime = new Mock <IDateTimeProvider>();
//Act and Assert
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new CountryService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.DeleteCountryAsync(1));
}
}
public async Task ThrowNullExc_If_Null()
{
var options = TestUtils.GetOptions(nameof(ThrowNullExc_If_Null));
var mockDateTime = new Mock <IDateTimeProvider>();
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new CountryService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.GetCountryAsync(3));
}
}
public async Task UpdateUserFail_If_NoUserExist()
{
var options = TestUtils.GetOptions(nameof(UpdateUserFail_If_NoUserExist));
var mockDateTime = new Mock <IDateTimeProvider>();
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new UserService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.UpdateUserAsync(1, "Asd"));
}
}
public async Task ThrowNullExcForUpdate_If_StyleDoesNotExist()
{
var options = TestUtils.GetOptions(nameof(ThrowNullExcForUpdate_If_StyleDoesNotExist));
var mockDateTime = new Mock <IDateTimeProvider>();
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new StyleService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.UpdateStyleAsync(1, "Asd"));
}
}
public async Task LikeTheReview_If_Successfull()
{
var options = TestUtils.GetOptions(nameof(LikeTheReview_If_Successfull));
var mockDateTime = new Mock <IDateTimeProvider>();
var user = new User
{
UserName = "******",
};
var beer = new Beer
{
Name = "Zagorka",
};
var review = new Review
{
UserId = 1,
BeerId = 1,
};
var like = new Like
{
ReviewId = 1,
UserId = 1,
isLiked = false,
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Users.AddAsync(user);
await arrangeContext.Beers.AddAsync(beer);
await arrangeContext.Reviews.AddAsync(review);
await arrangeContext.Likes.AddAsync(like);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new UserService(assertContext, mockDateTime.Object);
await sut.ReviewLikeAsync(1, 1, user);
var result = assertContext.Likes.Where(x => x.ReviewId == 1 || x.UserId == 1).FirstOrDefault();
Assert.IsTrue(result.isLiked);
}
}
public async Task UpdateBeer_If_BeerExist()
{
var options = TestUtils.GetOptions(nameof(UpdateBeer_If_BeerExist));
var mockDateTime = new Mock <IDateTimeProvider>();
var country = new Country
{
Name = "Romania"
};
var brewery = new Brewery
{
Name = "Kamenitza",
CountryId = 1
};
var style = new Style
{
Name = "Pale"
};
var beer = new Beer
{
Name = "Ariana",
Abv = 4,
CountryId = 1,
BreweryId = 1,
StyleId = 1,
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.Breweries.AddAsync(brewery);
await arrangeContext.Styles.AddAsync(style);
await arrangeContext.Beers.AddAsync(beer);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BeerService(assertContext, mockDateTime.Object);
var result = await sut.UpdateBeerAsync(1, "Kamenitza", 5.0);
Assert.AreEqual("Kamenitza", result.Name);
Assert.AreEqual(5.0, result.Abv);
}
}
public async Task Return_OneBeer_When_Exist()
{
var options = TestUtils.GetOptions(nameof(Return_OneBeer_When_Exist));
var mockDateTime = new Mock <IDateTimeProvider>();
var country = new Country
{
Name = "Romania"
};
var brewery = new Brewery
{
Name = "Kamenitza",
CountryId = 1
};
var style = new Style
{
Name = "Pale"
};
var beer = new Beer
{
Name = "Ariana",
CountryId = 1,
BreweryId = 1,
StyleId = 1,
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.Breweries.AddAsync(brewery);
await arrangeContext.Styles.AddAsync(style);
await arrangeContext.Beers.AddAsync(beer);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BeerService(assertContext, mockDateTime.Object);
var resultDTO = await sut.GetBeerAsync(1);
Assert.AreEqual(1, resultDTO.Id);
Assert.AreEqual("Ariana", resultDTO.Name);
}
}
public async Task ThrowNullExcFroBeer_If_StyleDoesNotExist()
{
var options = TestUtils.GetOptions(nameof(ThrowNullExcFroBeer_If_StyleDoesNotExist));
var mockDateTime = new Mock <IDateTimeProvider>();
var country = new Country
{
Name = "Romania"
};
var brewery = new Brewery
{
Name = "Ariana",
CountryId = 1
};
var style = new Style
{
Name = "Pale"
};
var beerDTO = new BeerDTO
{
Name = "Birichka",
Country = "Romania",
Brewery = "Ariana",
Style = "Dark Lager"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.Breweries.AddAsync(brewery);
await arrangeContext.Styles.AddAsync(style);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BeerService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.CreateBeerAsync(beerDTO));
}
}
public async Task ThrowNullExc_If_CountryDoesNotExist()
{
var options = TestUtils.GetOptions(nameof(ThrowNullExc_If_CountryDoesNotExist));
var mockDateTime = new Mock <IDateTimeProvider>();
var breweryDTO = new BreweryDTO
{
Name = "Ariana",
Country = "Romania"
};
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BreweryService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.CreateBreweryAsync(breweryDTO));
}
}
public async Task Return_When_Exist()
{
var options = TestUtils.GetOptions(nameof(Return_When_Exist));
var mockDateTime = new Mock <IDateTimeProvider>();
var country = new Country
{
Name = "Bulgaria"
};
var brewery = new Brewery
{
Name = "Ariana",
CountryId = 1
};
var brewery2 = new Brewery
{
Name = "Kamenitza",
CountryId = 1
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.Breweries.AddAsync(brewery);
await arrangeContext.Breweries.AddAsync(brewery2);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BreweryService(assertContext, mockDateTime.Object);
var resultDTOs = await sut.GetAllBreweriesAsync();
var result = resultDTOs.Select(x => x.Name).ToList();
Assert.IsTrue(result.Contains("Ariana"));
Assert.IsTrue(result.Contains("Kamenitza"));
Assert.AreEqual(2, result.Count);
}
}
