Beispiel #1
0
        /// <summary>
        /// Returns movies that pass certain filter criteria provided by consumer.
        /// At least one filter criteria should be provided by the caller, else the api returns an Invalid status.
        /// </summary>
        public async Task <GetMoviesByCriteriaResponse> GetMoviesByCriteriaAsync(GetMoviesByCriteriaRequest request)
        {
            try
            {
                if (request == null || !request.Validate())
                {
                    return new GetMoviesByCriteriaResponse
                           {
                               Status = ResponseStatus.Invalid,
                               Movies = Enumerable.Empty <MoviesResponse>()
                           }
                }
                ;

                var movies = await this.moviesRepository.Movies
                             .Include(m => m.MovieGenre)
                             .ThenInclude(navigationPropertyPath: mg => mg.Genre)
                             .Include(m => m.MovieRating)
                             .Where(m => m.Title.Equals(request.Title, StringComparison.InvariantCultureIgnoreCase) ||
                                    m.YearOfRelease == (request.YearOfRelease.HasValue ? request.YearOfRelease.Value : 0) ||
                                    m.RunningTime == (request.RunningTime.HasValue ? request.RunningTime.Value : 0))
                             .Select(m =>
                                     new MoviesResponse
                {
                    Id            = m.Id,
                    Title         = m.Title,
                    YearOfRelease = m.YearOfRelease,
                    RunningTime   = m.RunningTime,
                    Genres        = string.Join(", ", m.MovieGenre.Select(mg => mg.Genre.Name).ToList()),
                    AverageRating = Average(m.MovieRating)
                }).ToListAsync();

                return(new GetMoviesByCriteriaResponse
                {
                    Status = ResponseStatus.Success,
                    Movies = movies
                });
            }
            catch (DbException dbException)
            {
                logger.LogError(dbException, $"Error occurred while retrieving movies for Title:{request.Title} RunningTime:{request.RunningTime.Value} YearOfRelease:{request.YearOfRelease.Value}");
            }
            catch (Exception ex)
            {
                logger.LogError(ex, $"GetMoviesByCriteriaAsync() : Error occurred while retrieving movies for Title:{ request.Title} RunningTime: { request.RunningTime.Value} YearOfRelease: { request.YearOfRelease.Value}");
            }

            return(new GetMoviesByCriteriaResponse
            {
                Status = ResponseStatus.Fail,
                Movies = Enumerable.Empty <MoviesResponse>()
            });
        }
Beispiel #2
0
        public async Task GetMoviesByCriteriaAsync_ForValidRequest_ReturnsMoviesList()
        {
            // 1. Arrange
            var options = new DbContextOptionsBuilder <WheelMoviesContext>()
                          .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
                          .Options;
            var moviesContext = new WheelMoviesContext(options);

            moviesContext.Movie.Add(new Movie
            {
                Id            = 1,
                Title         = "Movie1",
                YearOfRelease = 2000,
                RunningTime   = 120,
                MovieGenre    = new List <MovieGenre>
                {
                    new MovieGenre {
                        Id = 1, GenreId = 1, MovieId = 1
                    }
                }
            });
            moviesContext.Movie.Add(new Movie
            {
                Id            = 2,
                Title         = "Movie2",
                YearOfRelease = 2001,
                RunningTime   = 120,
                MovieGenre    = new List <MovieGenre>
                {
                    new MovieGenre {
                        Id = 2, GenreId = 1, MovieId = 2
                    }
                }
            });
            await moviesContext.SaveChangesAsync();

            var moviesRepository = new MoviesRepository(moviesContext);
            var loggerMock       = new Mock <ILogger <MovieService> >();
            var request          = new GetMoviesByCriteriaRequest
            {
                YearOfRelease = 2000
            };

            // 2. Act
            var movieService = new MovieService(moviesRepository, loggerMock.Object);
            var response     = await movieService.GetMoviesByCriteriaAsync(request);

            // 3. Assert
            Assert.NotEmpty(response.Movies);
            Assert.True(response.Movies.Count() == 1);
        }
        public async Task GetMoviesByCriteriaRequest_For_ValidRequest_Returns_MoviesList()
        {
            // 1. Arrange
            var client  = factory.CreateClient();
            var request = new GetMoviesByCriteriaRequest
            {
                RunningTime = 120
            };
            var json    = JsonConvert.SerializeObject(request);
            var payload = new StringContent(json, Encoding.UTF8, "application/json");

            // 2. Act
            var response = await client.PostAsync("/api/movies", payload);

            // 3. Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        }
Beispiel #4
0
        public async Task GetMoviesByCriteriaAsync_ForInvalidRequest_ReturnsInvalidResponseState()
        {
            // 1. Arrange
            var moviesRepositoryMock = new Mock <IMoviesRepository>();
            var loggerMock           = new Mock <ILogger <MovieService> >();
            var request = new GetMoviesByCriteriaRequest
            {
                Title = null
            };

            // 2. Act
            var movieService = new MovieService(moviesRepositoryMock.Object, loggerMock.Object);
            var response     = await movieService.GetMoviesByCriteriaAsync(request);

            // 3. Assert
            Assert.Equal(ResponseStatus.Invalid, response.Status);
            Assert.True(!response.Movies.Any());
        }
        public async Task <ActionResult <IEnumerable <MoviesResponse> > > Post([FromBody] GetMoviesByCriteriaRequest request)
        {
            var movies = await movieService.GetMoviesByCriteriaAsync(request);

            if (movies.Status == ResponseStatus.Invalid)
            {
                return(BadRequest("Invalid criteria"));
            }

            if (!movies.Movies.Any())
            {
                return(NotFound("No movies found"));
            }

            if (movies.Status == ResponseStatus.Fail)
            {
                return(new StatusCodeResult(500));
            }

            return(Ok(movies.Movies));
        }