public async Task EditMovieShouldWorkCorrectly() { var repository = new EfDeletableEntityRepository <Movie>(new ApplicationDbContext(this.options.Options)); var service = new MoviesService(repository); var diffMovie = new AddMovieInputModel { Id = 1, Name = "Taxi 2", Year = 2000, Actors = "Samy Naceri, Frédéric Diefenthal, Marion Cotillard", AgeRestriction = 0, Description = "funny", Director = "Gérard Pirès", Duration = 86, Rating = 7.5, Price = 8, Genre = "Action, Comedy, Crime", TrailerUrl = "url", TrailerVideoUrl = "url", }; await service.AddAsync(this.movie); await service.EditAsync(diffMovie); Assert.Equal("Taxi 2", repository.All().FirstOrDefault().Name); Assert.Equal(2000, repository.All().FirstOrDefault().Year); Assert.Equal(7.5, repository.All().FirstOrDefault().Rating); }
public async Task GetAllShouldWorkCorrectlyWithAllParametersFilled() { var repository = new EfDeletableEntityRepository <Movie>(new ApplicationDbContext(this.options.Options)); var service = new MoviesService(repository); var diffMovie = new AddMovieInputModel { Name = "Taxi 2", Year = 1998, Actors = "Samy Naceri, Frédéric Diefenthal, Marion Cotillard", AgeRestriction = 0, Description = "funny", Director = "Gérard Pirès", Duration = 86, Rating = 7.1, Price = 8, Genre = "Action, Comedy, Crime", TrailerUrl = "url", TrailerVideoUrl = "url", }; await service.AddAsync(this.movie); await service.AddAsync(diffMovie); await service.AddAsync(this.movie); var result = service.GetAll <TestMovieViewModel>(1, 1); Assert.Single(result); Assert.Equal("Taxi 2", result.FirstOrDefault().Name); }
public async Task EditMovieShouldThrowIfIdIsNotFound() { var repository = new EfDeletableEntityRepository <Movie>(new ApplicationDbContext(this.options.Options)); var service = new MoviesService(repository); var diffMovie = new AddMovieInputModel { Id = 5, Name = "Taxi 2", Year = 2000, Actors = "Samy Naceri, Frédéric Diefenthal, Marion Cotillard", AgeRestriction = 0, Description = "funny", Director = "Gérard Pirès", Duration = 86, Rating = 7.5, Price = 8, Genre = "Action, Comedy, Crime", TrailerUrl = "url", TrailerVideoUrl = "url", }; await service.AddAsync(this.movie); Assert.Throws <ArgumentNullException>(() => service.EditAsync(diffMovie).GetAwaiter().GetResult()); }
public void GetIdByNameShouldReturn0(string name) { var repository = new EfDeletableEntityRepository <Movie>(new ApplicationDbContext(this.options.Options)); var service = new MoviesService(repository); Assert.Equal(0, service.GetIdByName(name)); }
public void InsertOkMovieTest() { // Arrange var mock = new Mock <IMoviesRepository>(); var moviesService = new MoviesService(mock.Object); var movie = new Movie { MovieId = "movie-id", Title = "movie-title" }; // Act // Fac mock la GetById cand verific de duplicates ca sa fiu sigur ca trece testul. mock.Setup(s => s.GetById(movie.MovieId)).Returns(new Error <Movie>(new DatabaseContextException("Database context error."))); mock.Setup(s => s.Insert(movie)).Returns(new OK <Movie>(movie)); var result = moviesService.Insert(movie); // Assert switch (result) { case OK <Movie> ok: Assert.AreEqual("movie-id", ok.Result.MovieId); Assert.AreEqual("movie-title", ok.Result.Title); break; case Error <Movie> error: Console.WriteLine(error.Message); break; default: throw new NotImplementedException(); } }
public void GetAllMoviesShouldReturnIEnurableOfMovies() { DbContextOptions <UltimateMoviesDbContext> options = new DbContextOptionsBuilder <UltimateMoviesDbContext>() .UseInMemoryDatabase(databaseName: "Movies_GetAllMovies_Database") .Options; UltimateMoviesDbContext db = new UltimateMoviesDbContext(options); IMoviesService moviesService = new MoviesService(db); db.Movies.Add(new Movie { Name = "Test 1" }); db.Movies.Add(new Movie { Name = "Test 2" }); db.Movies.Add(new Movie { Name = "Test 3" }); db.SaveChanges(); IEnumerable <Movie> movies = moviesService.GetAllMovies(); int moviesCount = movies.Count(); Assert.Equal(3, moviesCount); }
public void CreateShouldAddAndReturnTheFilmCreated() { var options = new DbContextOptionsBuilder <MoviesDbContext>() .UseInMemoryDatabase(databaseName: nameof(CreateShouldAddAndReturnTheFilmCreated)) .Options; using (var context = new MoviesDbContext(options)) { var movieService = new MoviesService(context); var addedMovie = movieService.Create(new ExamenNet.ViewModels.MoviePostModel { Title = "Create", Director = "dir1", DateAdded = new DateTime(), Duration = 100, Description = "asdvadfbdbsb", Genre = "Comedy", ReleaseYear = 2000, Rating = 3, Watched = 0 }, null); Assert.IsNotNull(addedMovie); Assert.AreEqual("Create", addedMovie.Title); } }
public void GetByIdShouldReturnFilmWithCorrectIdNumber() { var options = new DbContextOptionsBuilder <MoviesDbContext>() .UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnFilmWithCorrectIdNumber)) .Options; using (var context = new MoviesDbContext(options)) { var movieService = new MoviesService(context); var addedMovie = movieService.Create(new ExamenNet.ViewModels.MoviePostModel { Title = "Testare", Director = "dir1", DateAdded = new DateTime(), Duration = 100, Description = "asdvadfbdbsb", Genre = "Comedy", ReleaseYear = 2000, Rating = 3, Watched = 0 }, null); var theMovie = movieService.GetById(1); Assert.AreEqual("Testare", theMovie.Title); } }
async Task ExecuteSearchMoviesCommand(string text) { IsBusy = true; try { DiscoverMovies.Clear(); if (!string.IsNullOrEmpty(text)) { var searchResult = await MoviesService.DiscoverMovies(text); foreach (var movie in searchResult) { DiscoverMovies.Add(movie); } } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
public void GetAllMoviesEvenIfThereAreDeleted() { //Arrange var guid = Guid.NewGuid(); var testMovie = new Movies() { Id = Guid.NewGuid(), IsDeleted = true }; var testMovie2 = new Movies() { Id = Guid.NewGuid(), IsDeleted = false }; var moviesToReturn = new List <Movies>(); moviesToReturn.Add(testMovie); moviesToReturn.Add(testMovie2); movies.Setup(x => x.All()).Returns(moviesToReturn.AsQueryable()); var sut = new MoviesService(movies.Object, genresRepo.Object, commentsRepo.Object, userRepo.Object, likesRepo.Object, dislikesRepo.Object, saver.Object); //Act var result = sut.GetAllAndDeleted(); //Assert movies.Verify(x => x.All(), Times.Once()); Assert.IsTrue(result.Select(x => x.Id).Contains(testMovie.Id)); Assert.IsTrue(result.Select(x => x.Id).Contains(testMovie2.Id)); }
public async Task <List <MovieResponse> > FetchMovieList(int Page) { var Service = new MoviesService(); var Movies = await Service.FetchMovies(Page); return(Movies); }
public async Task <List <GenreResponse> > FetchGenres() { var Service = new MoviesService(); var Genres = await Service.FetchGenres(); return(Genres); }
public async Task ReturnsViewWithMovieViewModel() { //Arrange const string movieUrl = "https://test.test/api/film/1"; const string title = "Test movie title"; const string openingCrawl = "lorem ipsum"; var scores = new[] { 7, 4 }; var movie = new Movie { Url = movieUrl, OpeningCrawl = openingCrawl, Title = title }; var ratings = scores.Select(s => new Rating { Id = Guid.NewGuid(), MovieUrl = movieUrl, Score = s }).ToList(); RatingRepository.GetAll(movieUrl).Returns(ratings); MoviesService.GetMovie(movieUrl).Returns(movie); //Act var result = await HomeController.Details(movieUrl); //Assert var viewResult = Assert.IsType <ViewResult>(result); var model = Assert.IsAssignableFrom <MovieViewModel>(viewResult.ViewData.Model); Assert.Equal(movie.Title, model.Title); Assert.True(model.Scores.SequenceEqual(scores)); Assert.Equal(title, model.Title); }
protected async Task MovieDeleted() { _request = new GetMoviesRequest { PageSize = 8 }; _moviesResponse = await MoviesService.GetMultiple(_request); }
public void DeleteNotExistingMovieTest() { // Arrange var mock = new Mock <IMoviesRepository>(); var moviesService = new MoviesService(mock.Object); var movie = new Movie() { MovieId = "movie-id", Title = "movie-title" }; // Act mock.Setup(s => s.GetById(movie.MovieId)).Returns(new Error <Movie>(new DatabaseContextException())); var result = moviesService.Delete(movie.MovieId); // Assert switch (result) { case OK <Movie> ok: Assert.Fail(); break; case Error <Movie> error: Assert.AreEqual(typeof(IdNotFoundException), error.Exception.GetType()); Assert.AreEqual("Delete-method id not found exception.", error.Message); break; default: throw new NotImplementedException(); } }
public void DeleteMovieRepositoryExceptionTest() { // Arrange var mock = new Mock <IMoviesRepository>(); var moviesServices = new MoviesService(mock.Object); var movie = new Movie { MovieId = "movie-id", Title = "movie-title" }; // Act mock.Setup(s => s.GetById(movie.MovieId)).Returns(new OK <Movie>(movie)); mock.Setup(s => s.Delete(movie)).Throws(new NotImplementedException()); var result = moviesServices.Delete(movie.MovieId); // Assert switch (result) { case OK <Movie> ok: Assert.Fail(); break; case Error <Movie> error: Assert.AreEqual(typeof(RepositoryUnknownException), error.Exception.GetType()); Assert.AreEqual("Delete-method repository exception.", error.Message); break; default: throw new NotImplementedException(); } }
public async Task GetByIdExistingShouldReturnNotNullObject() { var options = new DbContextOptionsBuilder <NetPhlixDbContext>() .UseInMemoryDatabase("Test") .Options; var dbContext = new NetPhlixDbContext(options); await dbContext.Movies.AddAsync( new Movie() { Id = "first" } ); await dbContext.SaveChangesAsync(); var mappingConfig = new MapperConfiguration( mc => { mc.AddProfiles( typeof(MoviesProfile), typeof(UsersProfile), typeof(CompaniesProfile), typeof(ReviewsProfile), typeof(PeopleProfile), typeof(EventsProfile), typeof(AdminProfile) ); }); IMapper mapper = mappingConfig.CreateMapper(); var service = new MoviesService(mapper, dbContext); var movie = await service.GetById("first"); Assert.NotNull(movie); }
public async Task <IActionResult> Details(string movieUrl, int score) { if (!ModelState.IsValid) { return(View()); } RatingRepository.Add(new DTO.Rating { Id = Guid.NewGuid(), MovieUrl = movieUrl, Score = score }); await RatingRepository.SaveChanges(); var movie = await MoviesService.GetMovie(movieUrl); var ratings = await RatingRepository.GetAll(movieUrl); var viewModel = new MovieViewModel { Title = movie.Title, OpeningCrawl = movie.OpeningCrawl, Scores = ratings.Select(r => r.Score) }; return(View(viewModel)); }
public async Task GetAllCountShouldReturnCorrectNumberOfMovies() { var options = new DbContextOptionsBuilder <NetPhlixDbContext>() .UseInMemoryDatabase("Test") .Options; var dbContext = new NetPhlixDbContext(options); await dbContext.Movies.AddRangeAsync( new Movie(), new Movie(), new Movie() ); await dbContext.SaveChangesAsync(); var mappingConfig = new MapperConfiguration( mc => { mc.AddProfiles( typeof(MoviesProfile), typeof(UsersProfile), typeof(CompaniesProfile), typeof(ReviewsProfile), typeof(PeopleProfile), typeof(EventsProfile), typeof(AdminProfile) ); }); IMapper mapper = mappingConfig.CreateMapper(); var service = new MoviesService(mapper, dbContext); var allMovies = await service.GetAll(); Assert.Equal(3, allMovies.Count()); }
public async Task CreateMovieShouldAddMovieToRepository() { AutoMapperConfig.RegisterMappings(typeof(MovieTestModel).Assembly); var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()); var repository = new EfDeletableEntityRepository <Movie>(new ApplicationDbContext(options.Options)); await repository.AddAsync(new Movie { Id = 1, Name = "Movie1" }); await repository.AddAsync(new Movie { Id = 2, Name = "Movie2" }); await repository.SaveChangesAsync(); var service = new MoviesService(repository, null, null, null); var movie = new CreateMovieServiceInputModel { Name = "TestMovie", Length = 50, Directors = new[] { "Test" }, Genres = new[] { "1" }, Actors = new[] { "Test" }, }; await service.CreaterMovieAsync(movie); var genresCount = service.GetAll <MovieTestModel>().Count; Assert.Equal(3, genresCount); }
public void CreateReviewTestWithSapos() { var model = new Review(); model.Id = 0; model.Movie = new Movie() { Id = 0 , Title = "Test", Description = "test"}; model.Score = 5; model.Comment = "this is sapos movie"; var repository = Substitute.For<IMovieRepositorio>(); var grammar = Substitute.For<IGrammarService> (); var badwords = new List<String>(){ "sapos"}; grammar.GetBadWords().Returns(badwords); var service = new MoviesService(repository, grammar); try { service.CreateReview(model); Assert.Fail("the validation is not complete"); } catch (ApplicationException ex) { } //Assert repository.DidNotReceive().CreateReview(model); }
public void GetMovieByIdErrorTest() { // Arrange var mock = new Mock <IMoviesRepository>(); var moviesService = new MoviesService(mock.Object); // Act mock.Setup(s => s.GetById("movie-id")).Returns(new Error <Movie>(new DatabaseContextException("Database context error."))); var result = moviesService.GetById("movie-id"); // Assert switch (result) { case OK <Movie> ok: Assert.Fail(); break; case Error <Movie> error: Assert.AreEqual(typeof(DatabaseContextException), error.Exception.GetType()); Assert.AreEqual(error.Message, "GetById-method repository exception."); break; default: throw new NotImplementedException(); } }
public void DeleteShouldRemoveAndReturnFilm() { var options = new DbContextOptionsBuilder <MoviesDbContext>() .UseInMemoryDatabase(databaseName: nameof(DeleteShouldRemoveAndReturnFilm)) .EnableSensitiveDataLogging() .Options; using (var context = new MoviesDbContext(options)) { var filmService = new MoviesService(context); var toAdd = filmService.Create(new ExamenNet.ViewModels.MoviePostModel { Title = "DeSters", Director = "dir1", DateAdded = new DateTime(), Duration = 100, Description = "asdvadfbdbsb", Genre = "Comedy", ReleaseYear = 2000, Rating = 3, Watched = 0 }, null); Assert.IsNotNull(toAdd); Assert.AreEqual(1, filmService.GetAll(new DateTime(), new DateTime(), 1).Entries.Count); var deletedFilm = filmService.Delete(1); Assert.IsNotNull(deletedFilm); Assert.AreEqual(0, filmService.GetAll(new DateTime(), new DateTime(), 1).Entries.Count); } }
public void GetMovieByIdOkTest() { // Arrange var mock = new Mock <IMoviesRepository>(); var moviesService = new MoviesService(mock.Object); var movie = new Movie { MovieId = "movie-id", Title = "movie-title" }; // Act mock.Setup(s => s.GetById("movie-id")).Returns(new OK <Movie>(movie)); var result = moviesService.GetById("movie-id"); // Assert switch (result) { case OK <Movie> ok: Assert.AreEqual("movie-title", ok.Result.Title); break; case Error <Movie> error: Console.WriteLine(error.Message); break; default: throw new NotImplementedException(); } }
protected async override Task OnInitializedAsync() { ShowGrid = true; _request = new GetMoviesRequest { PageSize = 8 }; _moviesResponse = await MoviesService.GetMultiple(_request); }
public async Task OnSearch(GetMoviesRequest request) { _moviesResponse = null; _request.SortOrder = request.SortOrder; _request.OrderColumnName = request.OrderColumnName; _request.Title = request.Title; _moviesResponse = await MoviesService.GetMultiple(_request); }
public FormMovieInfo(int movieID) { InitializeComponent(); service = new MoviesService(); SetDesign(); this.movieID = movieID; LoadTables(); }
public MoviesServicesTest(MovieTestsFixture movieTestsFixture) { _moviesServiceMock = new Mock <IMoviesService>(); _moviesRepository = new Mock <IMoviesRepository>(); _service = new MoviesService(_moviesRepository.Object); _movieTestsFixture = movieTestsFixture; }
public void GetMoviesCountShouldReturn0() { var repository = new Mock <IDeletableEntityRepository <Movie> >(); var service = new MoviesService(repository.Object); Assert.Equal(0, service.GetMoviesCount()); repository.Verify(x => x.All(), Times.Once); }
public static MoviesService GetService() { if (moviesService == null) { moviesService = new MoviesServiceImpl(); } return(moviesService); }
private async Task LoadData() { IsBusy = true; await MoviesService.GetTopRated(); await MoviesService.GetUpComing(); await MoviesService.GetPopular(); }
public void CreateReviewTest() { var model = new Review(); model.Id = 0; model.Movie = new Movie() { Id = 0 , Title = "Test", Description = "test"}; model.Score = 5; model.Comment = "this is a great movie"; var repository = Substitute.For<IMovieRepositorio>(); var grammar = Substitute.For<IGrammarService> (); var badwords = new List<String>(){ "sapos"}; grammar.GetBadWords().Returns(badwords); var service = new MoviesService(repository, grammar); service.CreateReview(model); //Assert repository.Received().CreateReview(model); }