public void ReturnResultFromSaveChanges()
{
// Arrange
var expectedResult = new Mock <IDataModifiedResult>();
var id = this.Fixture.Create <int>();
var name = this.Fixture.Create <string>();
var descr = this.Fixture.Create <string>();
var country = this.Fixture.Create <string>();
var brewery = new Brewery();
var beerRepo = new Mock <IEfRepository <Beer> >();
var repository = new Mock <IEfRepository <Brewery> >();
repository.Setup(r => r.GetById(id))
.Returns(brewery);
repository.Setup(r => r.SaveChanges())
.Returns(expectedResult.Object);
var service = new BreweryService(repository.Object, beerRepo.Object);
// Act
var result = service.UpdateBrewery(id, name, country, descr);
// Assert
Assert.AreSame(expectedResult.Object, result);
}
public async Task ReturnTrue_When_ParamsAreValid()
{
var options = TestUtils.GetOptions(nameof(ReturnTrue_When_ParamsAreValid));
var mockDateTime = new Mock <IDateTimeProvider>();
var brewery = new Brewery
{
Name = "Zagorka"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Breweries.AddAsync(brewery);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BreweryService(assertContext, mockDateTime.Object);
await sut.DeleteBreweryAsync(1);
var result = assertContext.Breweries.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 ThrowNullExc_If_BreweryAlreadyExists()
{
var options = TestUtils.GetOptions(nameof(ThrowNullExc_If_BreweryAlreadyExists));
var mockDateTime = new Mock <IDateTimeProvider>();
var brewery = new Brewery
{
Name = "Ariana"
};
var breweryDTO = new BreweryDTO
{
Name = "Ariana"
};
using (var arrangeContext = new BeeroverflowContext(options))
{
await arrangeContext.Breweries.AddAsync(brewery);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new BeeroverflowContext(options))
{
var sut = new BreweryService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.CreateBreweryAsync(breweryDTO));
}
}
public void ReturnCorrectResult_WhenPaginated(int currentPage,
int expectedPageSize,
int expectedTotalCount)
{
var breweryComparer =
Comparer <IBrewery> .Create(((a, b) => string.Compare(a.Name, b.Name, StringComparison.Ordinal)));
var breweries = new List <Brewery>();
for (var i = 0; i < expectedTotalCount; i++)
{
breweries.Add(new Brewery()
{
Name = this.Fixture.Create <string>()
});
}
var queryableBreweries = breweries.AsQueryable();
var repository = new Mock <IRepository <Brewery> >();
repository.Setup(r => r.All)
.Returns(queryableBreweries);
var beerRepo = new Mock <IRepository <Beer> >();
var service = new BreweryService(repository.Object, beerRepo.Object);
var result = service.GetAll(currentPage, expectedPageSize, (a) => a.Name);
var actualUsers = result as IBrewery[] ?? result.ToArray();
var actualCount = actualUsers.Count();
Assert.GreaterOrEqual(expectedPageSize, actualCount);
CollectionAssert.IsOrdered(actualUsers, breweryComparer);
}
public void ReturnTrue_When_TypeIsDeleted()
{
var options = Utils.GetOptions(nameof(ReturnTrue_When_TypeIsDeleted));
var brewery = new Brewery
{
Id = 1,
Name = "Diamond Knot Brewery",
Description = "America",
CountryId = 1
};
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Breweries.Add(brewery);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryService(assertContext);
var result = sut.DeleteBrewery(1);
Assert.IsTrue(result);
}
}
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 void Return_Correct_Edited_Brewery()
{
var options = Utils.GetOptions(nameof(Return_Correct_Edited_Brewery));
var brewery = new Brewery
{
Id = 1,
Name = "Diamond Knot Brewery",
Description = "America",
CountryId = 1
};
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Breweries.Add(brewery);
arrangeContext.SaveChanges();
}
var newName = "DKB";
var newDescr = "USA";
var newCountryId = 2;
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryService(assertContext);
var result = sut.UpdateBrewery(brewery.Id, newName, newDescr, newCountryId);
Assert.AreEqual(brewery.Id, result.Id);
Assert.AreEqual(newName, result.Name);
Assert.AreEqual(newDescr, result.Description);
Assert.AreEqual(newCountryId, result.CountryId);
}
}
public void CallRepositoryUpdateMethodOnceWithCorrectParams()
{
// Arrange
var id = this.Fixture.Create <int>();
var name = this.Fixture.Create <string>();
var descr = this.Fixture.Create <string>();
var country = this.Fixture.Create <string>();
var brewery = new Brewery();
var repository = new Mock <IEfRepository <Brewery> >();
repository.Setup(r => r.GetById(id))
.Returns(brewery);
var beerRepo = new Mock <IEfRepository <Beer> >();
var service = new BreweryService(repository.Object, beerRepo.Object);
// Act
var result = service.UpdateBrewery(id, name, country, descr);
// Assert
repository.Verify(r => r.Update(brewery), Times.Once);
Assert.AreSame(name, brewery.Name);
Assert.AreSame(descr, brewery.Description);
Assert.AreSame(country, brewery.Country);
}
public void ReturnFilteredSetOfBreweries(int expectedTotalCount)
{
// Arrange
var pattern = this.Fixture.Create <string>();
var expectedFoundCount = expectedTotalCount / 5;
var countryCount = expectedFoundCount / 2;
var nameCount = countryCount;
var breweries = new List <Brewery>();
for (var i = 0; i < expectedTotalCount - expectedFoundCount; i++)
{
breweries.Add(new Brewery()
{
Name = this.Fixture.Create <string>(),
Country = this.Fixture.Create <string>()
});
}
for (int i = 0; i < countryCount; i++)
{
breweries.Add(new Brewery()
{
Name = this.Fixture.Create <string>(),
Country = this.Fixture.Create <string>() + pattern + this.Fixture.Create <string>()
});
}
for (int i = 0; i < nameCount; i++)
{
breweries.Add(new Brewery()
{
Country = this.Fixture.Create <string>(),
Name = this.Fixture.Create <string>() + pattern + this.Fixture.Create <string>()
});
}
var queryableBreweries = breweries.AsQueryable();
var repository = new Mock <IEfRepository <Brewery> >();
repository.Setup(r => r.All)
.Returns(queryableBreweries);
var beerRepo = new Mock <IEfRepository <Beer> >();
var service = new BreweryService(repository.Object, beerRepo.Object);
// Act
var result = service.Search(pattern);
// Assert
var actualBreweries = result as IBrewery[] ?? result.ToArray();
var actualCount = actualBreweries.Count();
Assert.GreaterOrEqual(expectedFoundCount, actualCount);
foreach (var actualBrewery in actualBreweries)
{
Assert.IsTrue(actualBrewery.Name.Contains(pattern) || actualBrewery.Country.Contains(pattern));
}
}
public void CallRepositoryGetAllMethodOnce()
{
var repository = new Mock <IRepository <Brewery> >();
var beerRepo = new Mock <IRepository <Beer> >();
var service = new BreweryService(repository.Object, beerRepo.Object);
service.GetAll();
repository.Verify(r => r.GetAll(), Times.Once);
}
public void Throw_When_BreweryNotFound()
{
var options = Utils.GetOptions(nameof(Throw_When_BreweryNotFound));
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryService(assertContext);
Assert.ThrowsException <ArgumentNullException>(() => sut.DeleteBrewery(1));
}
}
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 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 BreweryService(assertContext, mockDateTime.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.DeleteBreweryAsync(1));
}
}
public void ReturnCorrectResult_WhenSearching(int foundPerCriteria,
string search)
{
// Arrange
var breweries = new List <Brewery>();
breweries.Add(new Brewery()
{
Name = "", Country = ""
});
breweries.Add(new Brewery()
{
Name = "", Country = ""
});
for (var i = 0; i < foundPerCriteria; i++)
{
breweries.Add(new Brewery()
{
Name = this.Fixture.Create <string>() + search + this.Fixture.Create <string>(),
Country = this.Fixture.Create <string>()
});
}
for (var i = 0; i < foundPerCriteria; i++)
{
breweries.Add(new Brewery()
{
Country = this.Fixture.Create <string>() + search + this.Fixture.Create <string>(),
Name = this.Fixture.Create <string>()
});
}
var queryableBreweries = breweries.AsQueryable();
var repository = new Mock <IEfRepository <Brewery> >();
repository.Setup(r => r.All)
.Returns(queryableBreweries);
var beerRepo = new Mock <IEfRepository <Beer> >();
var service = new BreweryService(repository.Object, beerRepo.Object);
// Act
var result = service.GetAll(0, int.MaxValue, (a) => a.Name, search);
// Assert
var actual = result as IList <IBrewery> ?? result.ToList();
Assert.AreEqual(foundPerCriteria * 2, actual.Count);
CollectionAssert.IsSubsetOf(actual, breweries);
}
public void Throw_When_BreweryNotFound()
{
var options = Utils.GetOptions(nameof(Throw_When_BreweryNotFound));
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryService(assertContext);
var newName = "DKB";
var newDescr = "USA";
var newCountryId = 2;
Assert.ThrowsException <ArgumentNullException>(() => sut.UpdateBrewery(1, newName, newDescr, newCountryId));
}
}
public void ReturnResultFromRepositoryGetAllMethod()
{
var expected = new List <Brewery>();
var repository = new Mock <IRepository <Brewery> >();
repository.Setup(r => r.GetAll())
.Returns(expected);
var beerRepo = new Mock <IRepository <Beer> >();
var service = new BreweryService(repository.Object, beerRepo.Object);
var actual = service.GetAll();
Assert.AreSame(expected, actual);
}
public void Return_Correct_Breweries()
{
var options = Utils.GetOptions(nameof(Return_Correct_Breweries));
var country = new Country
{
Id = 1,
Name = "America"
};
var brewery = new Brewery
{
Id = 1,
Name = "Diamond Knot Brewery",
Description = "America",
CountryId = 1,
Country = country
};
var brewery2 = new Brewery
{
Id = 2,
Name = "Anheuser-Busch",
Description = "American brewery",
CountryId = 1,
Country = country
};
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Breweries.Add(brewery);
arrangeContext.Breweries.Add(brewery2);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryService(assertContext);
var result = sut.GetAllBreweries().First();
Assert.AreEqual(brewery.Id, result.Id);
Assert.AreEqual(brewery.Name, result.Name);
Assert.AreEqual(brewery.Description, result.Description);
Assert.AreEqual(brewery.CountryId, result.CountryId);
Assert.AreEqual(brewery.Country.Name, result.Country);
}
}
public void ReturnResultFromRepository()
{
var id = this.Fixture.Create <string>();
var expected = new Brewery();
var repository = new Mock <IRepository <Brewery> >();
repository.Setup(r => r.GetById(id))
.Returns(expected);
var beerRepo = new Mock <IRepository <Beer> >();
var service = new BreweryService(repository.Object, beerRepo.Object);
var result = service.GetById(id);
Assert.AreSame(expected, result);
}
public void Set_FoundBeerIsDeletedPropertyToTrue()
{
var id = this.Fixture.Create <int>();
var expected = new Beer()
{
IsDeleted = false
};
var repository = new Mock <IRepository <Brewery> >();
var beerRepo = new Mock <IRepository <Beer> >();
beerRepo.Setup(r => r.GetById(id))
.Returns(expected);
var service = new BreweryService(repository.Object, beerRepo.Object);
service.DeleteBeer(id);
Assert.IsTrue(expected.IsDeleted);
}
public void Call_BeerRepositoryGetByIdMethodOnceWithCorrectParams()
{
var id = this.Fixture.Create <int>();
var expected = new Beer()
{
IsDeleted = false
};
var repository = new Mock <IRepository <Brewery> >();
var beerRepo = new Mock <IRepository <Beer> >();
beerRepo.Setup(r => r.GetById(id))
.Returns(expected);
var service = new BreweryService(repository.Object, beerRepo.Object);
service.DeleteBeer(id);
beerRepo.Verify(r => r.GetById(id), Times.Once);
}
public void CallAndReturnValueFromBeerRepositorySaveChangesMethodOnce()
{
var expectedBreweryId = this.Fixture.Create <int>();
var expectedTypeId = this.Fixture.Create <int>();
var expectedName = this.Fixture.Create <string>();
var expectedResult = new Mock <IDataModifiedResult>();
var beerRepository = new Mock <IRepository <Beer> >();
beerRepository.Setup(x => x.SaveChanges())
.Returns(expectedResult.Object);
var breweryRepository = new Mock <IRepository <Brewery> >();
var service = new BreweryService(breweryRepository.Object, beerRepository.Object);
var result = service.AddNewBeer(expectedBreweryId, expectedTypeId, expectedName);
beerRepository.Verify(r => r.SaveChanges(), Times.Once);
Assert.AreSame(expectedResult.Object, result);
}
public void CallBeerRepositoryAddMethodWithCorrectParametersOnce()
{
var expectedBreweryId = this.Fixture.Create <int>();
var expectedTypeId = this.Fixture.Create <int>();
var expectedName = this.Fixture.Create <string>();
var beerRepository = new Mock <IRepository <Beer> >();
var breweryRepository = new Mock <IRepository <Brewery> >();
var service = new BreweryService(breweryRepository.Object, beerRepository.Object);
service.AddNewBeer(expectedBreweryId, expectedTypeId, expectedName);
beerRepository
.Verify(x => x.Add(
It.Is <Beer>(a => a.BreweryId == expectedBreweryId &&
a.BeerTypeId == expectedTypeId &&
a.Name == expectedName)),
Times.Once);
}
public void ReturnResultFromRepositorySaveChangesMethod()
{
var id = this.Fixture.Create <int>();
var beer = new Beer();
var expected = new Mock <IDataModifiedResult>();
var repository = new Mock <IRepository <Brewery> >();
var beerRepo = new Mock <IRepository <Beer> >();
beerRepo.Setup(r => r.GetById(id))
.Returns(beer);
beerRepo.Setup(r => r.SaveChanges())
.Returns(expected.Object);
var service = new BreweryService(repository.Object, beerRepo.Object);
var result = service.DeleteBeer(id);
Assert.AreSame(expected.Object, result);
}
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);
}
}
public void CallRepositoryGetByIdMethodOnceWithCorrectParams()
{
var id = this.Fixture.Create <int>();
var name = this.Fixture.Create <string>();
var descr = this.Fixture.Create <string>();
var country = this.Fixture.Create <string>();
var expected = new Brewery();
var repository = new Mock <IRepository <Brewery> >();
repository.Setup(r => r.GetById(id))
.Returns(expected);
var beerRepo = new Mock <IRepository <Beer> >();
var service = new BreweryService(repository.Object, beerRepo.Object);
var result = service.UpdateBrewery(id, name, country, descr);
repository.Verify(r => r.GetById(id), Times.Once);
}
public void ReturnCorrectCountOfItems()
{
// Arrange
var expectedBeers = new List <Brewery>()
{
new Brewery(), new Brewery()
};
var breweryRepository = new Mock <IEfRepository <Brewery> >();
breweryRepository.Setup(r => r.All)
.Returns(expectedBeers.AsQueryable());
var beerRepository = new Mock <IEfRepository <Beer> >();
var sut = new BreweryService(breweryRepository.Object, beerRepository.Object);
// Act
var result = sut.CountAll();
// Assert
Assert.AreEqual(2, result);
}
public void ReturnCorrectCountOfItems_WhenSearchIsSpecified()
{
// Arrange
var searchPattern = Guid.NewGuid().ToString();
var allBeers = new List <Brewery>()
{
new Brewery {
Name = ""
},
new Brewery {
Name = ""
},
new Brewery {
Name = this.Fixture.Create <string>() + searchPattern
},
new Brewery {
Name = searchPattern
},
new Brewery {
Name = this.Fixture.Create <string>() + searchPattern + this.Fixture.Create <string>()
},
new Brewery {
Name = searchPattern + this.Fixture.Create <string>()
},
};
var breweryRepository = new Mock <IEfRepository <Brewery> >();
breweryRepository.Setup(r => r.All)
.Returns(allBeers.AsQueryable());
var beerRepository = new Mock <IEfRepository <Beer> >();
var sut = new BreweryService(breweryRepository.Object, beerRepository.Object);
// Act
var result = sut.CountAll(searchPattern);
// Assert
Assert.AreEqual(4, result);
}
public void Create_Correct_Brewery()
{
var options = Utils.GetOptions(nameof(Create_Correct_Brewery));
var brewery = new Brewery
{
Id = 1,
Name = "Diamond Knot Brewery",
Description = "America",
CountryId = 1
};
using (var arrangeContext = new BeerOverflowContext(options))
{
var sut = new BreweryService(arrangeContext);
var breweryDTO = new BreweryDTO(brewery.Id, brewery.Name, brewery.Description, brewery.CountryId);
var result = sut.CreateBrewery(breweryDTO);
Assert.AreEqual(brewery.Id, result.Id);
Assert.AreEqual(brewery.Name, result.Name);
Assert.AreEqual(brewery.Description, result.Description);
Assert.AreEqual(brewery.CountryId, result.CountryId);
}
}
