public async Task GetRandomGenresShouldNotReturnDeletedGenres()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
await db.Genres.AddRangeAsync(
new Genre
{
Name = "test1",
Description = "description1",
IsDeleted = true,
},
new Genre
{
Name = "test2",
Description = "description2",
IsDeleted = true,
},
new Genre
{
Name = "test3",
Description = "description3",
});
await db.SaveChangesAsync();
var genresService = new GenresService(db);
var result = await genresService.GetRandomGenresAsync <GenreTestModel>(2);
Assert.Single(result);
}
public void GetAllReturnsGenreModels()
{
var genres = new List <Genre>();
var mockGenreRepo = new Mock <IGenresRepository>();
mockGenreRepo.Setup(x => x.All()).Returns(genres.AsQueryable());
genres.Add(new Genre()
{
Id = "test",
Name = "123"
});
genres.Add(new Genre()
{
Id = "123",
Name = "test"
});
var service = new GenresService(mockGenreRepo.Object);
var result = service.AllGenres();
var secondGenre = result.ToArray()[1];
Assert.Equal(2, result.Count());
Assert.Equal("test", result.First().Id);
Assert.Equal("123", result.First().Name);
Assert.Equal("123", secondGenre.Id);
Assert.Equal("test", secondGenre.Name);
}
public async Task GetGenreShouldReturnCorrectGenre()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
await db.Genres.AddRangeAsync(
new Genre
{
Name = "test1",
Description = "description1",
},
new Genre
{
Name = "test2",
Description = "description2",
},
new Genre
{
Name = "test3",
Description = "description3",
IsDeleted = true,
});
await db.SaveChangesAsync();
var genresService = new GenresService(db);
var result = await genresService.GetGenreByIdAsync <GenreTestModel>(1);
Assert.Equal("test1", result.Name);
Assert.Equal("description1", result.Description);
}
public async Task GetGenresCountShouldReturnCorrectCount()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
await db.Genres.AddRangeAsync(
new Genre
{
Name = "test1",
Description = "description1",
},
new Genre
{
Name = "test2",
Description = "description2",
},
new Genre
{
Name = "test3",
Description = "description3",
});
await db.SaveChangesAsync();
var genresService = new GenresService(db);
var result = await genresService.GetGenresCountAsync();
Assert.Equal(3, result);
}
public async Task EditGenreShouldWorkCorrectly(string name, string description)
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
await db.Genres.AddAsync(
new Genre
{
Name = "test",
Description = "description",
});
await db.SaveChangesAsync();
var genresService = new GenresService(db);
await genresService.EditGenreAsync(1, name, description);
var result = await db.Genres.FirstOrDefaultAsync();
Assert.Equal(name, result.Name);
Assert.Equal(description, result.Description);
Assert.NotNull(result.ModifiedOn);
}
public async Task DeleteGenreShouldSetIsDeletedAndDeletedOn()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
await db.Genres.AddAsync(
new Genre
{
Name = "test",
Description = "description",
});
await db.SaveChangesAsync();
var genresService = new GenresService(db);
await genresService.DeleteGenreByIdAsync(1);
var result = await db.Genres.FirstOrDefaultAsync();
Assert.True(result.IsDeleted);
Assert.NotNull(result.DeletedOn);
}
public GenresServiceTest()
{
AddGenreCommandMock = new Mock <IAddGenreCommand>();
UpdateGenreCommandMock = new Mock <IUpdateGenreCommand>();
ListAllGenresQueryMock = new Mock <IListAllGenresQuery>();
ServiceUnderTest = new GenresService(AddGenreCommandMock.Object,
UpdateGenreCommandMock.Object,
ListAllGenresQueryMock.Object);
}
public void Create_ExistsGenre_ShouldThrownGenreDublicateException()
{
var dto = new GenreDto()
{
Name = DefaultData.Genres.CSharp.Name
};
Assert.Throws <GenreDublicateException>(async() => await GenresService.Create(dto));
}
public async Task GetTree_ShouldReturnRootNodeAndChildren()
{
var genres = await GenresService.GetTree();
foreach (var genre in genres)
{
Assert.That(genre.Parent, Is.Null);
}
}
public void DeleteGenreAsyncThrowsArgumentExceptionWhenGivenInvalidId()
{
var genres = new List <Genre>();
var mockGenreRepo = new Mock <IGenresRepository>();
mockGenreRepo.Setup(x => x.All()).Returns(genres.AsQueryable());
var service = new GenresService(mockGenreRepo.Object);
Assert.ThrowsAsync <ArgumentException>(() => service.DeleteGenre("ivan"));
}
public async Task Delete_NodeWithNestedNodesRecurcivelly_ShouldDeleteNodeWithNestedNodes()
{
var genre = Genres.Single(x => x.Id == DefaultData.Genres.Programming.Id);
await GenresService.Delete(genre.Id, true);
var genres = Genres.Where(x => x.Parent?.Id == genre.Id);
Assert.That(genres.Where(x => x.Id == genre.Id), Is.Empty);
Assert.That(genres, Is.Empty);
}
public async Task Delete_RootNodes_ShouldDeleteAllGenres()
{
var rootGenres = Genres.Where(x => x.Parent == null).ToList();
for (int i = 0, len = rootGenres.Count(); i < len; i++)
{
await GenresService.Delete(rootGenres[i].Id, true);
}
Assert.That(Genres, Is.Empty);
}
public async Task Update_ShouldUpdated()
{
var genre = Genres.First();
var dto = new GenreDto()
{
Id = genre.Id,
Name = "very updated genre name"
};
await GenresService.Update(dto.Id, dto);
Assert.That(Genres.SingleOrDefault(x => string.Equals(x.Name, dto.Name, StringComparison.CurrentCultureIgnoreCase)), Is.Not.Null);
}
public void Update_NameIncorrect_ShouldThrownGenreIncorrectException()
{
var dto = new GenreDto()
{
Id = DefaultData.Genres.DotNet.Id
};
Assert.Throws <GenreIncorrectException>(async() =>
{
await GenresService.Update(dto.Id, dto);
});
}
public GenresServiceTest()
{
this.genresRepo = new Mock <IDeletableEntityRepository <Genre> >();
this.genresList = new List <Genre>();
this.service = new GenresService(this.genresRepo.Object);
this.genresRepo.Setup(x => x.All()).Returns(this.genresList.AsQueryable());
this.genresRepo.Setup(x => x.AllAsNoTracking()).Returns(this.genresList.AsQueryable());
this.genresRepo.Setup(x => x.AddAsync(It.IsAny <Genre>())).Callback(
(Genre item) => this.genresList.Add(item));
}
public void Update_ExistingName_ShouldThrownGenresDublicateException()
{
var dto = new GenreDto()
{
Id = DefaultData.Genres.CSharp.Id,
Name = DefaultData.Genres.LanguageAndTools.Name,
};
Assert.Throws <GenreDublicateException>(async() =>
{
await GenresService.Update(dto.Id, dto);
});
}
public async Task RemoveGenreAsyncWithInCorrectDataShoulThrowNullReferenceException(int groupId, int genreId)
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var genresRepository = new EfDeletableEntityRepository <Genre>(dbContext);
var groupGenresRepository = new EfRepository <GroupGenre>(dbContext);
var genresService = new GenresService(groupGenresRepository, genresRepository);
await Assert.ThrowsAsync <NullReferenceException>(async() =>
{
await genresService.RemoveGenreAsync(groupId, genreId);
});
}
public async Task CreateGenreAsyncThrowsArgumentExceptionWhenGivenAExistingGenreName()
{
var genres = new List <Genre>();
var mockGenreRepo = new Mock <IGenresRepository>();
mockGenreRepo.Setup(x => x.GenreExist("gosho")).Returns(true);
var service = new GenresService(mockGenreRepo.Object);
await Assert.ThrowsAsync <ArgumentException>(() => service.CreateGenreAsync(new Web.ViewModels.Genres.CreateGenreInputModel()
{
Name = "gosho"
}));
}
public async Task CreateGenreShouldAddToDatabase()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
var genresService = new GenresService(db);
await genresService.CreateGenreAsync("test", "test description");
Assert.Equal(1, await db.Genres.CountAsync());
}
public void EditGenreAsyncThrowsArgumentExceptionWhenGivenInvalidId()
{
var genres = new List <Genre>();
var mockGenreRepo = new Mock <IGenresRepository>();
mockGenreRepo.Setup(x => x.All()).Returns(genres.AsQueryable());
var service = new GenresService(mockGenreRepo.Object);
Assert.ThrowsAsync <ArgumentException>(() => service.EditGenre(new Web.ViewModels.Genres.EditGenreInputModel()
{
Id = "Ivan"
}));
}
public async Task GetGenreShouldReturnNullWhenNotFound()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
var genresService = new GenresService(db);
var result = await genresService.GetGenreByIdAsync <GenreTestModel>(1);
Assert.Null(result);
}
public async Task AddGenreAsyncWithCorrectDataShouldReturnCorrectResult()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var genresRepository = new EfDeletableEntityRepository <Genre>(dbContext);
var groupGenresRepository = new EfRepository <GroupGenre>(dbContext);
var genresService = new GenresService(groupGenresRepository, genresRepository);
var actual = await genresService.AddGenreAsync(5, 1);
var expected = 5;
Assert.Equal(expected, actual);
}
public async Task EditGenreMustReturnFalseWithIncorrectNames(string name)
{
AutoMapperConfig.RegisterMappings(typeof(GenreTestModel).Assembly);
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository = new EfDeletableEntityRepository <Genre>(new ApplicationDbContext(options.Options));
await repository.AddAsync(new Genre { Id = 1, Name = "Action" });
await repository.SaveChangesAsync();
var service = new GenresService(repository, null);
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(() => service.EditGenreAsync(1, name));
}
public async Task Create_RootGenre_ShouldValid()
{
var oldCount = Genres.Count;
var dto = new GenreDto()
{
Name = nameof(Create_RootGenre_ShouldValid)
};
await GenresService.Create(dto);
Assert.That(Genres.Count, Is.EqualTo(oldCount + 1));
var createdGenre = Genres.SingleOrDefault(x => string.Equals(x.Name, nameof(Create_RootGenre_ShouldValid), StringComparison.CurrentCultureIgnoreCase));
Assert.That(createdGenre, Is.Not.Null);
Assert.That(createdGenre.Parent, Is.Null);
Assert.That(createdGenre.Children, Is.Empty);
}
public async Task CreateGenreShouldReturnCorrectId()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
var genresService = new GenresService(db);
var id = await genresService.CreateGenreAsync("test", "test description");
var result = await db.Genres.FirstOrDefaultAsync();
Assert.Equal(id, result.Id);
}
public void GetGenreNameWorksCorrectly()
{
var genres = new List <Genre>();
var mockGenreRepo = new Mock <IGenresRepository>();
mockGenreRepo.Setup(x => x.All()).Returns(genres.AsQueryable());
genres.Add(new Genre()
{
Id = "test123",
Name = "ivan"
});
var service = new GenresService(mockGenreRepo.Object);
var result = service.GetGenreName("test123");
Assert.Equal("ivan", result);
}
public async Task AddGenreAsyncWithDublicateNameShouldThrowArgumentException()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var genresRepository = new EfDeletableEntityRepository <Genre>(dbContext);
var groupGenresRepository = new EfRepository <GroupGenre>(dbContext);
var genresService = new GenresService(groupGenresRepository, genresRepository);
await groupGenresRepository.AddAsync(new GroupGenre { GroupId = 2, GenreId = 1 });
await groupGenresRepository.SaveChangesAsync();
await Assert.ThrowsAsync <ArgumentException>(async() =>
{
await genresService.AddGenreAsync(2, 1);
});
}
public MoviesListViewModel()
{
genreService = new GenresService();
movieService = new MovieService();
Genres = new ObservableCollection <Genre>(genreService.GetAllGenres());
Movies = new ObservableCollection <Movie>();
ShowSearchItemsCommand = new Command(ShowSearchItems);
SearchCommand = new Command(RePopulateCollection);
ResetCommand = new Command(
() => {
selectedGenre = null;
RePopulateCollection();
});
RePopulateCollection();
}
public async Task CreateGenreAsyncCreatesNewGenreWhenNameIsNotTaken()
{
var genres = new List <Genre>();
var mockGenreRepo = new Mock <IGenresRepository>();
mockGenreRepo.Setup(x => x.GenreExist("gosho")).Returns(false);
mockGenreRepo.Setup(x => x.AddAsync(It.IsAny <Genre>())).Callback((Genre genre) => genres.Add(genre));
var service = new GenresService(mockGenreRepo.Object);
await service.CreateGenreAsync(new Web.ViewModels.Genres.CreateGenreInputModel()
{
Name = "gosho"
});
Assert.Single(genres);
Assert.Equal("gosho", genres.First().Name);
}
public async Task DeleteGenreAsyncWorksCorrectly()
{
var genres = new List <Genre>();
var mockGenreRepo = new Mock <IGenresRepository>();
mockGenreRepo.Setup(x => x.All()).Returns(genres.AsQueryable());
mockGenreRepo.Setup(x => x.Delete(It.IsAny <Genre>())).Callback((Genre genre) => genres.Remove(genre));
genres.Add(new Genre()
{
Id = "test123",
Name = "ivan"
});
var service = new GenresService(mockGenreRepo.Object);
await service.DeleteGenre("test123");
Assert.Empty(genres);
}