public async Task GetAllTest()
{
var genres = new List <Genre>
{
new Genre()
{
Name = "Genre One"
},
new Genre()
{
Name = "Genre Two"
}
};
var fakeRepositoryMock = new Mock <IGenreRepository>();
fakeRepositoryMock.Setup(x => x.GetAll()).ReturnsAsync(genres);
var genreService = new GenreService(fakeRepositoryMock.Object);
var resultGenres = await genreService.GetGenres();
Assert.Collection(resultGenres, genre =>
{
Assert.Equal("Genre One", genre.Name);
},
genre =>
{
Assert.Equal("Genre Two", genre.Name);
});
}
public void GetByBook_GoodArgument_Success()
{
_genres.Add(new Genre
{
Id = Guid.NewGuid().ToString(),
Name = "SomeGenreName",
ImageUrl = "SomeImageUrl",
Books = new List <GenreBook>
{
new GenreBook
{
Book = new Book(),
Id = Guid.NewGuid().ToString(),
Genre = new Genre(),
BookId = "123",
GenreId = Guid.NewGuid().ToString()
}
},
Likes = new List <GenreLike>()
});
_mockGenreRepository.Setup(w => w.GetAll()).ReturnsAsync(_genres);
_mockGenreRepository.Setup(w => w.GetById(It.IsAny <string>())).ReturnsAsync(_genre);
using var genreService = new GenreService(_mockGenreRepository.Object, _mapper);
Assert.That(genreService.GetByBook("123", It.IsAny <string>()).Result, Is.TypeOf(typeof(List <GenreListingModel>)));
}
public void CallsAllNotDeletedReturnsNotDeletedOnly()
{
//Arrange
List <Genres> genres = new List <Genres>();
var genre = new Genres
{
Name = "name1",
IsDeleted = true
};
var genre2 = new Genres
{
Name = "name2",
IsDeleted = false
};
genres.Add(genre);
genres.Add(genre2);
genresRepo.Setup(x => x.AllNotDeleted()).Returns(genres.AsQueryable());
var sut = new GenreService(movies.Object, genresRepo.Object, commentsRepo.Object, userRepo.Object, likesRepo.Object, dislikesRepo.Object, saver.Object);
//Act
var result = sut.GetAllNotExpired();
//Assert
Assert.IsTrue(result.Select(x => x.Name).Contains("name2"));
Assert.IsFalse(result.Select(x => x.Name).Contains("hey1"));
genresRepo.Verify(x => x.AllNotDeleted(), Times.Once);
}
public BookController()
{
var connectionString = ConfigurationManager.ConnectionStrings["MyDBConnection"].ToString();
bookService = new BookService(connectionString);
genreService = new GenreService(connectionString);
}
public void GetAll_Success()
{
_mockGenreRepository.Setup(w => w.GetAll()).ReturnsAsync(_genres);
_mockGenreRepository.Setup(w => w.GetById(It.IsAny <string>())).ReturnsAsync(_genre);
using var genreService = new GenreService(_mockGenreRepository.Object, _mapper);
Assert.That(genreService.GetAll(It.IsAny <string>()).Result, Is.TypeOf(typeof(List <GenreListingModel>)));
}
public BookController(BookService bookService, IRepositoryWrapper repositoryWrapper, AuthorService authorService, GenreService genreService)
{
_bookService = bookService;
_repositoryWrapper = repositoryWrapper;
_authorService = authorService;
_genreService = genreService;
}
public IHttpActionResult Get(int id)
{
GenreService genreService = CreateGenreService();
var genre = genreService.GetGenreById(id);
return(Ok(genre));
}
public ActionResult EditGenre(String genreID, String newName)
{
GenreService generService = new GenreService();
generService.editGenre(Int32.Parse(genreID), newName);
return(RedirectToAction("Index"));
}
public ActionResult DeleteGenre(String genreID)
{
GenreService generService = new GenreService();
generService.deleteGenre(Int32.Parse(genreID));
return(RedirectToAction("Index"));
}
public ControlPanelController(AlbumService albumService, GenreService genreService, ArtistService artistService, OrderService orderService)
{
this.albumService = albumService;
this.genreService = genreService;
this.artistService = artistService;
this.orderService = orderService;
}
public GenreServiceTest()
{
_uow = new Mock <IUnitOfWork>();
var log = new Mock <ILog>();
_mapper = MapperConfigUi.GetMapper().CreateMapper();
_sut = new GenreService(_uow.Object, _mapper, log.Object);
_fakeGenreName = "genre1";
_fakeGenreId = Guid.NewGuid();
_fakeGenre = new Genre
{
Id = _fakeGenreId,
NameEn = _fakeGenreName
};
_fakeGenres = new List <Genre>()
{
_fakeGenre,
new Genre()
{
Id = new Guid(),
NameEn = "genre2"
}
};
}
public async Task GetGenresTest()
{
var groups = new List <Genre>
{
new Genre()
{
Genre_name = " 1"
},
new Genre()
{
Genre_name = " 2"
},
};
var fakeRepositoryMock = new Mock <IGenresRepository>();
fakeRepositoryMock.Setup(x => x.GetAll()).ReturnsAsync(groups);
var genreService = new GenreService(fakeRepositoryMock.Object);
var resultGenres = await genreService.GetGenres();
Assert.Collection(resultGenres, genre =>
{
Assert.Equal(" 1", genre.Genre_name);
},
genre =>
{
Assert.Equal(" 2", genre.Genre_name);
});
}
public void CallGetAllAndReturnExistResultIfAlreadyExists()
{
//Arrange
List <Genres> genres = new List <Genres>();
var genre = new Genres
{
Name = "name1"
};
var genre2 = new Genres
{
Name = "name2"
};
genres.Add(genre);
genres.Add(genre2);
genresRepo.Setup(x => x.All()).Returns(genres.AsQueryable());
var sut = new GenreService(movies.Object, genresRepo.Object, commentsRepo.Object, userRepo.Object, likesRepo.Object, dislikesRepo.Object, saver.Object);
//Act
var result = sut.AddGenre(genre);
//Assert
Assert.AreEqual(result.ErrorMsg, "Already Exists");
Assert.AreEqual(result.ResulType, ResultType.AlreadyExists);
}
public IHttpActionResult Get(int id)
{
GenreService GenreService = CreateGenreService();
var Genres = GenreService.GetGenreById(id);
return(Ok(Genres));
}
public void AllShouldReturnCollectionOfGenres()
{
var options = new DbContextOptionsBuilder <BookStoreDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
//
var dbContext = new BookStoreDbContext(options);
var genreServices = new GenreService(dbContext);
var history = new Genre
{
Name = "History"
};
dbContext.Genres.Add(history);
var music = new Genre
{
Name = "Music"
};
dbContext.Genres.Add(music);
dbContext.SaveChanges();
var genreCollection = genreServices.All().ToList();
Assert.True(genreCollection.Count == 2);
Assert.True(genreCollection[0].Name == "History");
Assert.True(genreCollection[1].Name == "Music");
}
public MoviesController()
{
var context = new MoviesContext();
this.movieService = new MovieService(context);
this.genreService = new GenreService(context);
}
public void DeleteShouldRemoveGenreFromDb()
{
var options = new DbContextOptionsBuilder <BookStoreDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
//
var dbContext = new BookStoreDbContext(options);
var genreServices = new GenreService(dbContext);
var history = new Genre
{
Name = "History"
};
dbContext.Genres.Add(history);
var music = new Genre
{
Name = "Music"
};
dbContext.Genres.Add(music);
dbContext.SaveChanges();
var genreRemove1 = genreServices.Delete(history.Id);
var genreRemove2 = genreServices.Delete(music.Id);
Assert.True(genreRemove1);
Assert.True(genreRemove2);
}
public ActionResult Genre(int value)
{
ViewBag.DefaultGenreValue = value;
GenreService genre = new GenreService();
return(View(genre.getAllGener()));
}
public IHttpActionResult GetAll()
{
GenreService genreService = CreateGenreService();
var moods = genreService.GetGenre();
return(Ok(moods));
}
public void AddGenreInDatabase()
{
var data = new List <Genre>
{
new Genre {
Name = "Pop"
},
new Genre {
Name = "Rock"
},
new Genre {
Name = "Rap"
}
}.AsQueryable();
var mockSet = new Mock <DbSet <Genre> >();
mockSet.As <IQueryable <Genre> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <Genre> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <Genre> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <Genre> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var optionsBuilder = new DbContextOptionsBuilder <AlbumRatingDbContext>();
var mockContext = new Mock <AlbumRatingDbContext>(optionsBuilder.Options);
mockContext.Setup(x => x.Genres).Returns(mockSet.Object); //Setting it up to return Genres
var service = new GenreService(mockContext.Object);
var genres = service.GetAll();
Assert.AreEqual(3, genres.Count);
Assert.AreEqual("Pop", genres[0].Name);
Assert.AreEqual("Rock", genres[1].Name);
Assert.AreEqual("Rap", genres[2].Name);
}
private GenreService CreateGenreService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var _service = new GenreService(userId);
return(_service);
}
public MoviesController(MovieService movieService, GenreService genreService, SignInManager <User> signInManager, UserManager <User> userManager)
{
_movieService = movieService;
_genreService = genreService;
_signInManager = signInManager;
_userManager = userManager;
}
public AdminViewModel(MainViewModel _ViewModel)
{
ViewModel = _ViewModel;
FilmService = new FilmService();
GenreService = new GenreService();
ComboBoxGenre = new ObservableCollection <string>();
}
public IHttpActionResult Get()
{
GenreService genreService = CreateGenreService();
var genres = genreService.GetAllGenres();
return(Ok(genres));
}
public void GetAll_ReturnThreeObjects_Success()
{
_mockGenreRepository.Setup(w => w.GetAll()).ReturnsAsync(_genres);
_mockGenreRepository.Setup(w => w.GetById(It.IsAny <string>())).ReturnsAsync(_genre);
using var genreService = new GenreService(_mockGenreRepository.Object, _mapper);
Assert.AreEqual(genreService.GetAll(It.IsAny <string>()).Result.Count, 3);
}
public void EditShouldChangeGenreName()
{
var options = new DbContextOptionsBuilder <BookStoreDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
//
var dbContext = new BookStoreDbContext(options);
var genreServices = new GenreService(dbContext);
var history = new Genre
{
Name = "History"
};
dbContext.Genres.Add(history);
var music = new Genre
{
Name = "Music"
};
dbContext.Genres.Add(music);
dbContext.SaveChanges();
genreServices.Edit(history.Id, "History and politic");
genreServices.Edit(music.Id, "Music hard rock :)");
Assert.True(history.Name == "History and politic");
Assert.True(music.Name == "Music hard rock :)");
}
public static void Delete(byte[] frame)
{
IMovieDataAccess movieDataAccess = new MovieDataAccess();
IMovieService movieService = new MovieService(movieDataAccess);
IGenreDataAccess genreData = new GenreDataAccess();
IGenreService genreService = new GenreService(genreData);
IAsociationHandler asociationHandler = new AssociationHandler();
IAsociationService asociationService = new AsociationService(asociationHandler);
IParser parser = new Parser();
var data = parser.GetDataObject(frame);
var name = data[0];
var movieToDelete = movieService.GetMovie(name);
foreach (var genreName in movieToDelete.Genres)
{
var genreToDesaciate = genreService.GetGenre(genreName);
asociationService.DeAsociateGenreMovie(movieToDelete, genreToDesaciate);
}
movieService.Delete(movieToDelete);
}
public void GetGenreByNameShouldReturnCurrentGenre()
{
var options = new DbContextOptionsBuilder <BookStoreDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
//
var dbContext = new BookStoreDbContext(options);
var genreServices = new GenreService(dbContext);
var history = new Genre
{
Name = "History"
};
dbContext.Genres.Add(history);
var music = new Genre
{
Name = "Music"
};
dbContext.Genres.Add(music);
dbContext.SaveChanges();
var getHistoryFromDbbyId = genreServices.GetGenreByName(history.Name);
Assert.True(getHistoryFromDbbyId.Name == "History" && getHistoryFromDbbyId.Id == 1);
}
public async Task Succeed_ReturnCollection()
{
var options = TestUtils.GetOptions(nameof(Succeed_ReturnCollection));
using (var arrangeContext = new MoviesCatalogContext(options))
{
await arrangeContext.Genres.AddAsync(TestHelper.TestGenre1());
await arrangeContext.Movies.AddAsync(TestHelper.TestMovie100());
await arrangeContext.Movies.AddAsync(TestHelper.TestMovie200());
await arrangeContext.MoviesGenres.AddAsync(TestHelper.MoviesGenres1());
await arrangeContext.MoviesGenres.AddAsync(TestHelper.MoviesGenres2());
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new MoviesCatalogContext(options))
{
var sut = new GenreService(assertContext);
var moviesByGenre = await sut.ShowMoviesByGenreAsync("Drama");
Assert.AreEqual(moviesByGenre.Count, 2);
}
}
public void UpdateTest()
{
// Arrange
var expected = new GenreDTO
{
Id = "1",
Name = "Adventure"
};
var repository = new Mock <IRepository <Genre> >();
repository.Setup(r => r.Get(expected.Id)).Returns(new Genre
{
Id = "1",
Name = "Adventure"
});
var mapper = new Mock <IMapper>();
mapper.Setup(m => m.Map <Genre, GenreDTO>(It.IsAny <Genre>())).Returns(expected);
var svc = new GenreService(repository.Object, mapper.Object);
// Act
svc.Update(expected);
// Assert
mapper.Verify(m => m.Map <GenreDTO, Genre>(It.IsAny <GenreDTO>()), Times.Once());
repository.Verify(r => r.Update(It.IsAny <Genre>()), Times.Once());
repository.Verify(r => r.Save(), Times.Once());
}
