public void DoesNotReturnsBands_WithoutIncludingGenre()
{
var contextMock = new Mock <IMusicLibraryContext>();
var contextBaseMock = new Mock <IMusicLibraryBaseContext>();
var countryServiceMock = new Mock <ICountryService>();
var genreServiceMock = new Mock <IGenreService>();
var userServiceMock = new Mock <IUserService>();
var bandFactoryMock = new Mock <IBandFactory>();
var bands = GetBands();
var expectedResult = bands.Where(x => x.Genre.GenreName.Contains("Metal")).AsQueryable();
var bandsSetMock = QueryableDbSetMock.GetQueryableMockDbSet(bands);
contextMock.Setup(x => x.Bands).Returns(bandsSetMock);
var bandService = new BandService(
contextMock.Object,
contextBaseMock.Object,
countryServiceMock.Object,
genreServiceMock.Object,
userServiceMock.Object,
bandFactoryMock.Object);
var bandResultSet = bandService.GetAllBands();
CollectionAssert.AreNotEquivalent(expectedResult, bandResultSet.ToList());
}
public void Delete_ShouldThrowArgumentNullException_WhenPassedEntityIsNull()
{
//Arrange
var posts = new List <Post>
{
new Post()
{
Id = 1, Title = "post", Content = "content"
},
new Post()
{
Id = 2, Title = "post", Content = "content"
}
};
var mockedDbContext = new Mock <MsSqlDbContext>();
var mockedPostSet = QueryableDbSetMock.GetQueryableMockDbSet <Post>(posts);
mockedDbContext.Setup(c => c.Set <Post>()).Returns(mockedPostSet);
mockedDbContext.Setup(c => c.Posts).Returns(mockedPostSet);
string expectedExceptionMessage = "entity";
var repositoryUnderTest = new EfRepository <Post>(mockedDbContext.Object);
//Act & Assert
var exc = Assert.Throws <ArgumentNullException>(() => repositoryUnderTest.Delete(null));
//Assert
StringAssert.Contains(expectedExceptionMessage, exc.Message);
}
public void RerurnCorrectResults_WhenDescriptionMatches()
{
// Arrange
var contextMock = new Mock <IPickAndBookDbContext>();
Guid[] categoryIds = new Guid[2];
Guid testCategoryId = Guid.NewGuid();
categoryIds[0] = testCategoryId;
categoryIds[1] = Guid.NewGuid();
IEnumerable <Company> companies = GetCompanies(categoryIds);
string searchTerm = "desCription 1";
var expectedCompanyResultSet = companies.Where(c => c.CategoryId.Equals(testCategoryId) &&
c.CompanyDescription.ToLower().Contains(searchTerm)).AsQueryable();
var companySetMock = QueryableDbSetMock.GetQueryableMockDbSet(companies);
contextMock.Setup(c => c.Set <Company>()).Returns(companySetMock);
CompanyRepository companyRepository = new CompanyRepository(contextMock.Object);
// Act
var companyResultSet = companyRepository.GetCompaniesByCategoryIdNameOrDescription(testCategoryId, searchTerm);
// Assert
CollectionAssert.AreEquivalent(expectedCompanyResultSet, companyResultSet);
}
public void Return_AllPosts_SortedByDate()
{
// Arrange
var mockedDbContext = new Mock <ICreatorsDbContext>();
var mockedDbSaveChangesContext = new Mock <ICreatorsDbSaveChangesContext>();
var mockedPostFactory = new Mock <IPostFactory>();
var mockedCategoryService = new Mock <ICategoryService>();
var mockedUserService = new Mock <IUserService>();
var posts = GetAllPost();
var expectedResult = posts.OrderByDescending(x => x.PostedOn);
var mockedPost = QueryableDbSetMock.GetQueryableMockDbSet(posts);
mockedDbContext.Setup(x => x.Posts).Returns(mockedPost);
var postService = new PostService(
mockedDbContext.Object,
mockedDbSaveChangesContext.Object,
mockedPostFactory.Object,
mockedCategoryService.Object,
mockedUserService.Object);
// Act
var actualResult = postService.GetAllPost();
// Assert
CollectionAssert.AreEqual(expectedResult, actualResult);
}
public void Delete_ShouldSet_DeletedOn()
{
//Arrange
var posts = new List <Post>
{
new Post()
{
Id = 1, Title = "post", Content = "content"
},
new Post()
{
Id = 2, Title = "post", Content = "content"
}
};
var mockedDbContext = new Mock <MsSqlDbContext>();
var mockedPostSet = QueryableDbSetMock.GetQueryableMockDbSet(posts);
mockedDbContext.Setup(c => c.Set <Post>()).Returns(mockedPostSet);
mockedDbContext.Setup(c => c.Posts).Returns(mockedPostSet);
var repositoryUnderTest = new EfRepository <Post>(mockedDbContext.Object);
//Act
repositoryUnderTest.Delete(posts[0]);
//Assert
Assert.IsAssignableFrom(typeof(DateTime), posts[0].DeletedOn);
}
public void ReturnExpectedResult_WhenCorrectParametersArePassed(int page, int pageSize, int count)
{
// Arrange
var contextMock = new Mock <IPickAndBookDbContext>();
var categorySetMock = new Mock <IDbSet <Category> >();
contextMock.Setup(c => c.Set <Category>()).Returns(categorySetMock.Object);
IEnumerable <Category> categories = GetCategories(count);
var categoryDbSetMock = QueryableDbSetMock.GetQueryableMockDbSet(categories);
contextMock.Setup(c => c.Set <Category>()).Returns(categoryDbSetMock);
CategoryRepository categoryRepository = new CategoryRepository(contextMock.Object);
int toSkip = page * pageSize;
var expectedCategories = categoryDbSetMock
.OrderBy(c => c.CategoryName)
.Skip(toSkip)
.Take(pageSize);
// Act
var resultCategries = categoryRepository.GetAll(page, pageSize);
// Assert
CollectionAssert.AreEqual(expectedCategories, resultCategries);
}
public void ThrowArgumentNullExceptionWhenPassedEntityIsNull()
{
//Arrange
var pages = new List <Page>
{
new Page()
{
Id = Guid.NewGuid(), Title = "page", Content = "cntnt"
},
new Page()
{
Id = Guid.NewGuid(), Title = "page", Content = "cntnt"
}
};
var mockedDbContext = new Mock <ISotnWikiDbContext>();
var mockedPageSet = QueryableDbSetMock.GetQueryableMockDbSet <Page>(pages);
mockedDbContext.Setup(c => c.Set <Page>()).Returns(mockedPageSet);
mockedDbContext.Setup(c => c.Pages).Returns(mockedPageSet);
string expectedExceptionMessage = "entity";
var repositoryUnderTest = new EfGenericRepository <Page>(mockedDbContext.Object);
//Act & Assert
var exc = Assert.Throws <ArgumentNullException>(() => repositoryUnderTest.Add(null));
//Assert
StringAssert.Contains(expectedExceptionMessage, exc.Message);
}
public void ReturnCorrectResults_WhenUserIdMatches()
{
// Arange
var contextMock = new Mock <IPickAndBookDbContext>();
String[] userIds = new string[2];
String testUserId = Guid.NewGuid().ToString();
userIds[0] = testUserId;
userIds[1] = Guid.NewGuid().ToString();
IEnumerable <Booking> bookings = GetBookings(userIds);
var expectedBookingResultSet = bookings.Where(b => b.UserId.Equals(testUserId)).AsQueryable();
var bookingSetMock = QueryableDbSetMock.GetQueryableMockDbSet(bookings);
contextMock.Setup(c => c.Set <Booking>()).Returns(bookingSetMock);
BookingRepository bookingRepository = new BookingRepository(contextMock.Object);
// Act
IQueryable <Booking> resultSet = bookingRepository.GetBookingByUserId(testUserId);
// Assert
CollectionAssert.AreEqual(expectedBookingResultSet, resultSet);
}
public void ReturnNull_WhenDivisionTypeWithIdIsNotFound()
{
//Arrange
Guid id = Guid.NewGuid();
DivisionType divisionType = new DivisionType()
{
Id = id, Name = "Test", Description = "Test"
};
var divisionTypeDbSetMock = QueryableDbSetMock.GetQueryableMockDbSet(new List <DivisionType>()
{
divisionType
});
divisionTypeDbSetMock.Setup(x => x.Find(Guid.NewGuid())).Returns((DivisionType)null);
var yoyoTournamentsDbContextMock = new Mock <IYoyoTournamentsDbContext>();
yoyoTournamentsDbContextMock.Setup(x => x.DivisionTypes).Returns(divisionTypeDbSetMock.Object);
var divisionTypeService = new DivisionTypeService(yoyoTournamentsDbContextMock.Object);
//Act
var actualDivisionType = divisionTypeService.GetDivisionTypeById(id);
//Assert
Assert.IsNull(actualDivisionType);
}
public void ReturnDivisionTypeWithProvidedId()
{
//Arrange
Guid id = Guid.NewGuid();
Guid divisionTypeId = Guid.NewGuid();
Guid tournamentId = Guid.NewGuid();
Division expectedDivision = new Division
{
Id = id,
DivisionTypeId = divisionTypeId,
TournamentId = tournamentId
};
var divisionDbSetMock = QueryableDbSetMock.GetQueryableMockDbSet(new List <Division>()
{
expectedDivision
});
divisionDbSetMock.Setup(x => x.Find(expectedDivision.Id)).Returns(expectedDivision);
var yoyoTournamentsDbContextMock = new Mock <IYoyoTournamentsDbContext>();
yoyoTournamentsDbContextMock.Setup(x => x.Divisions).Returns(divisionDbSetMock.Object);
var divisionService = new DivisionService(yoyoTournamentsDbContextMock.Object);
//Act
var actualDivision = divisionService.GetDivisionById(id);
//Assert
Assert.AreSame(expectedDivision, actualDivision);
}
public void ReturnDifferentBills_WhenIdUserIsNotValid()
{
// Arrange
var contextMock = this.ContextMock;
var companyServiceMock = this.CompanyServiceMocked;
var idUser = "******";
var bills = this.Bills;
var billSetMock = QueryableDbSetMock.GetQueryableMockDbSet(bills);
var expectedResult = bills.Where(b => b.IdUser == "idUser03");
contextMock.Setup(c => c.Bills).Returns(billSetMock.Object);
Bills.Services.BillService billService = new Bills.Services.BillService(contextMock.Object, companyServiceMock.Object);
// Act
var result = billService.GetBillsByIdUser(idUser);
// Assert
contextMock.Verify(b => b.Bills, Times.Once);
CollectionAssert.IsNotEmpty(expectedResult);
CollectionAssert.IsEmpty(result);
CollectionAssert.AreNotEquivalent(expectedResult, result);
}
public void DoesNotReturnBands_WithNonExistingGenre()
{
var contextMock = new Mock <IMusicLibraryContext>();
var contextBaseMock = new Mock <IMusicLibraryBaseContext>();
var countryServiceMock = new Mock <ICountryService>();
var genreServiceMock = new Mock <IGenreService>();
var userServiceMock = new Mock <IUserService>();
var bandFactoryMock = new Mock <IBandFactory>();
var bands = GetBands();
string expectedGenre = "Hop";
var expectedResult = bands.Where(x => x.Genre.GenreName == expectedGenre);
var bandsSetMock = QueryableDbSetMock.GetQueryableMockDbSet(bands);
bandsSetMock.Include("Country");
bandsSetMock.Include("Genre");
contextMock.Setup(x => x.Bands).Returns(bandsSetMock);
var bandService = new BandService(
contextMock.Object,
contextBaseMock.Object,
countryServiceMock.Object,
genreServiceMock.Object,
userServiceMock.Object,
bandFactoryMock.Object);
var actualResult = bandService.GetBandsByGenre(expectedGenre);
CollectionAssert.IsEmpty(actualResult);
}
public void ReturnTheRightCount_OfFoundBands_WithGivenGenre()
{
var contextMock = new Mock <IMusicLibraryContext>();
var contextBaseMock = new Mock <IMusicLibraryBaseContext>();
var countryServiceMock = new Mock <ICountryService>();
var genreServiceMock = new Mock <IGenreService>();
var userServiceMock = new Mock <IUserService>();
var bandFactoryMock = new Mock <IBandFactory>();
var bands = GetBands();
string expectedGenre = "Metal";
var expectedResult = bands.Where(x => x.Genre.GenreName == expectedGenre).ToList();
var bandsSetMock = QueryableDbSetMock.GetQueryableMockDbSet(bands);
bandsSetMock.Include("Country");
bandsSetMock.Include("Genre");
contextMock.Setup(x => x.Bands).Returns(bandsSetMock);
var bandService = new BandService(
contextMock.Object,
contextBaseMock.Object,
countryServiceMock.Object,
genreServiceMock.Object,
userServiceMock.Object,
bandFactoryMock.Object);
var actualResult = bandService.GetBandsByGenre(expectedGenre).ToList();
Assert.That(expectedResult.Count == actualResult.Count);
}
public void ReturnBands_WithInstanceOfBand()
{
var contextMock = new Mock <IMusicLibraryContext>();
var contextBaseMock = new Mock <IMusicLibraryBaseContext>();
var countryServiceMock = new Mock <ICountryService>();
var genreServiceMock = new Mock <IGenreService>();
var userServiceMock = new Mock <IUserService>();
var bandFactoryMock = new Mock <IBandFactory>();
var bands = GetBands();
string expectedGenre = "Metal";
var expectedResult = bands.Where(x => x.Genre.GenreName == expectedGenre);
var bandsSetMock = QueryableDbSetMock.GetQueryableMockDbSet(bands);
bandsSetMock.Include("Country");
bandsSetMock.Include("Genre");
contextMock.Setup(x => x.Bands).Returns(bandsSetMock);
var bandService = new BandService(
contextMock.Object,
contextBaseMock.Object,
countryServiceMock.Object,
genreServiceMock.Object,
userServiceMock.Object,
bandFactoryMock.Object);
var actualResult = bandService.GetBandsByGenre(expectedGenre);
CollectionAssert.AllItemsAreInstancesOfType(actualResult, typeof(Band));
}
public void RemoveSpecificBill_WhenBillExist()
{
// Arrange
var contextMock = this.ContextMock;
var companyServiceMock = this.CompanyServiceMocked;
var expectedId = 2;
var bills = this.Bills;
var billSetMock = QueryableDbSetMock.GetQueryableMockDbSetFromArray(bills);
contextMock.Setup(c => c.Bills).Returns(billSetMock.Object);
billSetMock.Setup(b => b.Remove(It.IsAny <Bill>())).Callback <Bill>((entity) => bills.Remove(entity));
//contextMock.Setup(c => c.Bills.Remove(It.IsAny<Bill>())).Callback<Bill>((entity) => bills.Remove(entity));
Bills.Services.BillService billService = new Bills.Services.BillService(contextMock.Object, companyServiceMock.Object);
Bill bill = billSetMock.Object.First();
// Act
billService.RemoveBill(bill);
// Assert
Assert.AreEqual(billSetMock.Object.First().Id, expectedId);
}
public void ReturnCorrectResults_WhenCategoryIdMatches()
{
// Arange
var contextMock = new Mock <IBookingSystemContext>();
Guid[] categoryIds = new Guid[2];
Guid testCategoryId = Guid.NewGuid();
categoryIds[0] = testCategoryId;
categoryIds[1] = Guid.NewGuid();
IEnumerable <Company> companies = GetCompanies(categoryIds);
var expectedCompanyResultSet = companies.Where(c => c.CategoryId.Equals(testCategoryId)).AsQueryable();
var companySetMock = QueryableDbSetMock.GetQueryableMockDbSet(companies);
contextMock.Setup(c => c.Companies).Returns(companySetMock);
CompanyService companyService = new CompanyService(contextMock.Object);
// Act
IQueryable <Company> resultSet = companyService.GetCompaniesByCategoryId(testCategoryId);
// Assert
CollectionAssert.AreEqual(expectedCompanyResultSet, resultSet);
}
public void AllWithDeleted_ShouldReturn_DbSet()
{
//Arrange
var posts = new List <Post>
{
new Post()
{
Id = 1, Title = "post", Content = "content"
},
new Post()
{
Id = 2, Title = "post", Content = "content"
}
};
var mockedDbContext = new Mock <MsSqlDbContext>();
var mockedPostSet = QueryableDbSetMock.GetQueryableMockDbSet <Post>(posts);
mockedDbContext.Setup(c => c.Set <Post>()).Returns(mockedPostSet);
mockedDbContext.Setup(c => c.Posts).Returns(mockedPostSet);
var repositoryUnderTest = new EfRepository <Post>(mockedDbContext.Object);
//Act
var result = repositoryUnderTest.AllWithDeleted();
//Assert
Assert.AreEqual(result, mockedPostSet);
}
public void ReturnCountryWithProvidedId()
{
//Arrange
Guid id = Guid.NewGuid();
Country expectedCountry = new Country()
{
Id = id, Name = "Bulgaria"
};
var countryDbSetMock = QueryableDbSetMock.GetQueryableMockDbSet(new List <Country>()
{
expectedCountry
});
countryDbSetMock.Setup(x => x.Find(expectedCountry.Id)).Returns(expectedCountry);
var yoyoTournamentsDbContextMock = new Mock <IYoyoTournamentsDbContext>();
yoyoTournamentsDbContextMock.Setup(x => x.Countries).Returns(countryDbSetMock.Object);
var countryService = new CountryService(yoyoTournamentsDbContextMock.Object);
//Act
var actualCountry = countryService.GetCountryById(id);
//Assert
Assert.AreSame(expectedCountry, actualCountry);
}
public void All_ShouldReturn_InstanceOfIQueryable()
{
//Arrange
var posts = new List <Post>
{
new Post()
{
Id = 1, Title = "post", Content = "content"
},
new Post()
{
Id = 2, Title = "post", Content = "content"
}
};
var mockedDbContext = new Mock <MsSqlDbContext>();
var mockedPostSet = QueryableDbSetMock.GetQueryableMockDbSet <Post>(posts);
mockedDbContext.Setup(c => c.Set <Post>()).Returns(mockedPostSet);
mockedDbContext.Setup(c => c.Posts).Returns(mockedPostSet);
var repositoryUnderTest = new EfRepository <Post>(mockedDbContext.Object);
//Act
var result = repositoryUnderTest.All();
//Assert
Assert.IsInstanceOf(typeof(IQueryable <Post>), result);
}
public void ReturnAllBand_WithTheGivenLetter()
{
const string letter = "A";
var contextMock = new Mock <IMusicLibraryContext>();
var contextBaseMock = new Mock <IMusicLibraryBaseContext>();
var countryServiceMock = new Mock <ICountryService>();
var genreServiceMock = new Mock <IGenreService>();
var userServiceMock = new Mock <IUserService>();
var bandFactoryMock = new Mock <IBandFactory>();
var bands = GetBands();
var bandsSetMock = QueryableDbSetMock.GetQueryableMockDbSet(bands);
var expectedResult = bands.Where(x => x.BandName.Substring(0, 1) == letter).ToList();
contextMock.Setup(x => x.Bands).Returns(bandsSetMock);
var bandService = new BandService(
contextMock.Object,
contextBaseMock.Object,
countryServiceMock.Object,
genreServiceMock.Object,
userServiceMock.Object,
bandFactoryMock.Object);
var actualResult = bandService.GetBands(letter);
CollectionAssert.AreEquivalent(actualResult.ToList(), expectedResult);
}
public void ReturnExpectedResult_WhenCompaniesAreLessMoreEqualThan_LastRegisteredCompaniesCount(int count)
{
// Arrange
var contextMock = new Mock <IPickAndBookDbContext>();
var companySetMock = new Mock <IDbSet <Company> >();
contextMock.Setup(c => c.Set <Company>()).Returns(companySetMock.Object);
IEnumerable <Company> companies = GetCompanies(count);
var companyDbSetMock = QueryableDbSetMock.GetQueryableMockDbSet(companies);
contextMock.Setup(c => c.Set <Company>()).Returns(companyDbSetMock);
CompanyRepository companyRepository = new CompanyRepository(contextMock.Object);
var expectedCompanies = companyDbSetMock
.OrderByDescending(c => c.CompanyId)
.Take(DataConstants.LastRegisteredCompaniesCount);
// Act
var resultCompanies = companyRepository.GetLastAddedCompanies();
// Assert
CollectionAssert.AreEqual(expectedCompanies, resultCompanies);
}
public void DoesNotReturnABand_WithDifferentStartingLetter()
{
const string letter = "A";
var contextMock = new Mock <IMusicLibraryContext>();
var contextBaseMock = new Mock <IMusicLibraryBaseContext>();
var countryServiceMock = new Mock <ICountryService>();
var genreServiceMock = new Mock <IGenreService>();
var userServiceMock = new Mock <IUserService>();
var bandFactoryMock = new Mock <IBandFactory>();
var bands = GetBands();
var expectedResult = bands.AsQueryable();
var bandsSetMock = QueryableDbSetMock.GetQueryableMockDbSet(bands);
contextMock.Setup(x => x.Bands).Returns(bandsSetMock);
var bandService = new BandService(
contextMock.Object,
contextBaseMock.Object,
countryServiceMock.Object,
genreServiceMock.Object,
userServiceMock.Object,
bandFactoryMock.Object);
var actualResult = bandService.GetBands(letter);
CollectionAssert.DoesNotContain(actualResult.ToList(), expectedResult.Where(x => x.BandName == "Behemoth"));
}
public void ReturnDivisionTypeWithProvidedId()
{
//Arrange
Guid id = Guid.NewGuid();
DivisionType expectedDivisionType = new DivisionType()
{
Id = id, Name = "Test", Description = "Test"
};
var divisionTypeDbSetMock = QueryableDbSetMock.GetQueryableMockDbSet(new List <DivisionType>()
{
expectedDivisionType
});
divisionTypeDbSetMock.Setup(x => x.Find(expectedDivisionType.Id)).Returns(expectedDivisionType);
var yoyoTournamentsDbContextMock = new Mock <IYoyoTournamentsDbContext>();
yoyoTournamentsDbContextMock.Setup(x => x.DivisionTypes).Returns(divisionTypeDbSetMock.Object);
var divisionTypeService = new DivisionTypeService(yoyoTournamentsDbContextMock.Object);
//Act
var actualDivisionType = divisionTypeService.GetDivisionTypeById(id);
//Assert
Assert.AreSame(expectedDivisionType, actualDivisionType);
}
public void GetById_ShouldReturnInstanceOfCorrectType_WhenIdIsValid()
{
// Arrange
var posts = new List <Post>
{
new Post()
{
Id = 1, Title = "post", Content = "content"
},
new Post()
{
Id = 2, Title = "post", Content = "content"
}
};
var mockedDbContext = new Mock <MsSqlDbContext>();
var mockedPostSet = QueryableDbSetMock.GetQueryableMockDbSet(posts);
mockedDbContext.Setup(c => c.Set <Post>()).Returns(mockedPostSet);
mockedDbContext.Setup(c => c.Posts).Returns(mockedPostSet);
mockedDbContext.SetupSet(c => c.Posts = mockedPostSet);
var repositoryUnderTest = new EfRepository <Post>(mockedDbContext.Object);
// Act
var result = repositoryUnderTest.GetById(1);
// Assert
Assert.IsInstanceOf(typeof(Post), result);
}
public void ThrowArgumentException_WhenTheListWIthDivisionTypesIsNullOrEmpty()
{
// Arrange
var expectedTournament = new Tournament
{
Name = "Test name",
Place = "Test place",
StartDate = DateTime.Now.Add(new TimeSpan(1, 0, 0, 0, 0)),
EndDate = DateTime.Now.Add(new TimeSpan(2, 0, 0, 0, 0)),
CountryId = Guid.NewGuid()
};
var divisionTypeDbSetMock = QueryableDbSetMock.GetQueryableMockDbSet(new List <DivisionType>());
var yoyoTournamentsDbContextMock = new Mock <IYoyoTournamentsDbContext>();
yoyoTournamentsDbContextMock.Setup(x => x.DivisionTypes).Returns(divisionTypeDbSetMock.Object);
var divisionTypeServiceMock = new Mock <IDivisionTypeService>();
divisionTypeServiceMock.Setup(x => x.GetAllDivisionTypes()).Returns(new List <DivisionType>());
var tournamentService = new TournamentService(yoyoTournamentsDbContextMock.Object, divisionTypeServiceMock.Object);
// Act & Assert
ThrowsAssert.Throws <NullReferenceException>(
() => tournamentService.CreateTournament(expectedTournament.Name,
expectedTournament.Place,
expectedTournament.StartDate,
expectedTournament.EndDate,
expectedTournament.CountryId)
);
}
public void ReturnAllBands_WithIncludedCountryAndGenre()
{
var contextMock = new Mock <IMusicLibraryContext>();
var contextBaseMock = new Mock <IMusicLibraryBaseContext>();
var countryServiceMock = new Mock <ICountryService>();
var genreServiceMock = new Mock <IGenreService>();
var userServiceMock = new Mock <IUserService>();
var bandFactoryMock = new Mock <IBandFactory>();
var bands = GetBands();
var expectedResult = bands.AsQueryable();
var bandsSetMock = QueryableDbSetMock.GetQueryableMockDbSet(bands);
bandsSetMock.Include("Country");
bandsSetMock.Include("Genre");
contextMock.Setup(x => x.Bands).Returns(bandsSetMock);
var bandService = new BandService(
contextMock.Object,
contextBaseMock.Object,
countryServiceMock.Object,
genreServiceMock.Object,
userServiceMock.Object,
bandFactoryMock.Object);
var bandResultSet = bandService.GetAllBands();
CollectionAssert.AreEquivalent(expectedResult, bandResultSet.ToList());
}
public void Add_CategoryToDbSetCategories_When_Valid()
{
// Arrange
var fakeDrumsAcademyContext = new Mock <IDrumsAcademyContext>();
var fakeCategoriesDbSet = QueryableDbSetMock.GetQueryableMockDbSetFromList(this.GetCategories());
fakeDrumsAcademyContext.Setup(f => f.Categories).Returns(fakeCategoriesDbSet);
var sut = new Services.Data.CategoryService(fakeDrumsAcademyContext.Object);
var category = new Category()
{
Id = Guid.NewGuid(), Type = CategoryType.Theory
};
var categoriesCount = fakeCategoriesDbSet.Count();
// Act
sut.AddCategory(category);
categoriesCount += 1;
// Assert
Assert.AreEqual(categoriesCount, fakeCategoriesDbSet.Count());
}
public void Delete_ShouldSetIsDeleted_ToTrue()
{
//Arrange
var posts = new List <Post>
{
new Post()
{
Id = 1, Title = "post", Content = "content"
},
new Post()
{
Id = 2, Title = "post", Content = "content"
}
};
var mockedDbContext = new Mock <MsSqlDbContext>();
var mockedPostSet = QueryableDbSetMock.GetQueryableMockDbSet(posts);
mockedDbContext.Setup(c => c.Set <Post>()).Returns(mockedPostSet);
mockedDbContext.Setup(c => c.Posts).Returns(mockedPostSet);
var repositoryUnderTest = new EfRepository <Post>(mockedDbContext.Object);
//Act
repositoryUnderTest.Delete(posts[0]);
//Assert
Assert.AreEqual(posts[0].IsDeleted, true);
}
public void ReturnedBands_AreAllInstancesOfBand()
{
var contextMock = new Mock <IMusicLibraryContext>();
var contextBaseMock = new Mock <IMusicLibraryBaseContext>();
var countryServiceMock = new Mock <ICountryService>();
var genreServiceMock = new Mock <IGenreService>();
var userServiceMock = new Mock <IUserService>();
var bandFactoryMock = new Mock <IBandFactory>();
var bands = GetBands();
var expectedResult = bands.AsQueryable();
var bandsSetMock = QueryableDbSetMock.GetQueryableMockDbSet(bands);
bandsSetMock.Include("Country");
bandsSetMock.Include("Genre");
contextMock.Setup(x => x.Bands).Returns(bandsSetMock);
var bandService = new BandService(
contextMock.Object,
contextBaseMock.Object,
countryServiceMock.Object,
genreServiceMock.Object,
userServiceMock.Object,
bandFactoryMock.Object);
var bandResultSet = bandService.GetAllBands().ToList();
CollectionAssert.AllItemsAreInstancesOfType(bandResultSet, typeof(Band));
}
public void ReturnPositiveNumber_IfPizzaWasFoundAndSuccessfullyRemoved_WhenCalled()
{
// Arrange
Guid userId = Guid.NewGuid();
Guid pizzaId = Guid.NewGuid();
var user = new ApplicationUser()
{
Cart = new List <BasePizza>()
{
new BasePizza()
{
Id = pizzaId
}
}
};
IEnumerable <ApplicationUser> users = new List <ApplicationUser>()
{
user
};
IEnumerable <Pizza> pizzas = Helper.GetPizzas();
IEnumerable <CustomPizza> customPizzas = Helper.GetCustomPizzas();
var pizzaContextMock = new Mock <IPizzaFactoryDbContext>();
var orderContextMock = new Mock <IOrderDbContext>();
var userContextMock = new Mock <IIdentityDbContext>()
{
CallBase = true
};
var mapperMock = new Mock <IMapper>();
var validatorMock = new Mock <IValidator>();
var pizzaDbSetMock = QueryableDbSetMock.GetQueryableMockDbSet(pizzas);
var customPizzaDbSetMock = QueryableDbSetMock.GetQueryableMockDbSet(customPizzas);
var userDbSetMock = QueryableDbSetMock.GetQueryableMockDbSet(users);
userDbSetMock.Setup(u => u.Find(userId.ToString())).Returns(user);
userContextMock.Setup(ctx => ctx.Users).Returns(userDbSetMock.Object);
userContextMock.Setup(ctx => ctx.SaveChanges()).Returns(() => user.Cart.Count == 1 ? 0 : 1);
pizzaContextMock.Setup(ctx => ctx.Pizzas).Returns(pizzaDbSetMock.Object);
pizzaContextMock.Setup(ctx => ctx.CustomPizzas).Returns(customPizzaDbSetMock.Object);
IApplicationUserService userService =
new ApplicationUserService(userContextMock.Object,
pizzaContextMock.Object,
orderContextMock.Object,
mapperMock.Object,
validatorMock.Object);
// Act
int result = userService.RemoveFromCart(userId.ToString(), pizzaId);
// Assert
Assert.IsTrue(result > 0);
}
