예제 #1
0
        public void IndexShouldReturnViewWithOneMovie()
        {
            // arrange
            var mockRepo = new Mock <IMovieRepo>();

            mockRepo.Setup(x => x.GetMovies()).Returns(new List <Movie> {
                new Movie {
                    Id = 1, Title = ""
                }
            });
            //mockRepo.Setup(x => x.GetMovie(It.IsAny<int>())).Returns(null);

            //var controller = new MovieController(new FakeMovieRepo());
            var controller = new MovieController(mockRepo.Object);

            // act
            IActionResult result = controller.Index();

            // assert
            ViewResult viewResult = Assert.IsAssignableFrom <ViewResult>(result);

            //Assert.Equal("Movie/Home", viewResult.ViewName);

            var movies = Assert.IsAssignableFrom <IEnumerable <MovieViewModel> >(viewResult.Model);

            Assert.Single(movies);
            MovieViewModel theMovie = movies.First();

            Assert.NotNull(theMovie);
            Assert.Equal(1, theMovie.Id);
        }
예제 #2
0
 public MoviePage(Movie movie, MovieController movieController)
 {
     this._movieController = movieController;
     viewModel             = new MovieViewModel(this.Navigation, movie, _movieController);
     this.BindingContext   = viewModel;
     InitializeComponent();
 }
        public void GetTagsTest()
        {
            MovieDTO      inputMovie = TestingHelper.GetRandomMovie(0, 0, 0, 0, 3);
            List <string> results;

            // Seed the test database
            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                TestingHelper.AddMovieDTOToDatabase(context, inputMovie);
            }

            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                RepoLogic       repoLogic       = new RepoLogic(context);
                IMovieLogic     movieLogic      = new MovieLogic(repoLogic);
                MovieController movieController = new MovieController(movieLogic);

                // Test GetAllTags()
                results = movieController.GetAllTags().Value;
            }

            Assert.Contains(inputMovie.MovieTags[0], results);
            Assert.Contains(inputMovie.MovieTags[1], results);
            Assert.Contains(inputMovie.MovieTags[2], results);
        }
예제 #4
0
        public MovieModule(OrmLiteConnectionFactory db)
            : base("/movies")
        {
            Get["/"] = _ =>
            {
                var movies = new MovieController(db);
                return movies.ListAll();
            };

            Get["/{movie}"] = req =>
            {
                var movies = new MovieController(db);
                var movie = movies.Lookup(req.movie);
                if (movie == null)
                    return 404;
                return View["MovieDetail", movie];
            };

            Get["/create"] = _ => { return View["NewMovie"]; };

            Post["/create"] = _ =>
            {
                var movie = this.Bind<Movie>(); // Binds the POST result to movie variable (as a movie object)
                var movieController = new MovieController(db);
                movieController.Add(movie);
                return Response.AsRedirect(ModulePath + "/" + movie.GetPrettyTitleLink());
            };

            Post["/update/{id}"] = _ => { return 500; };
        }
예제 #5
0
 public ViewMovie()
 {
     InitializeComponent();
     movieController = new MovieController();
     DataContext     = App.MovieViewModel;
     this.Loaded    += new RoutedEventHandler(ViewMovie_Loaded);
 }
        public void Setup()
        {
            var client          = new MongoClient(Constants.MongoDbConnectionUri());
            var movieRepository = new MoviesRepository(client);

            _movieController = new MovieController(movieRepository);
        }
예제 #7
0
        public async Task CallMovieServiceOnce_OnGet()
        {
            // Arrange
            var movieServiceMock = new Mock <IMovieService>();
            var genreServiceMock = new Mock <IGenreService>();

            string movieName = "Spiderman";
            int    rating    = 10;

            var rateModel = new RateMovieViewModel()
            {
                Name   = movieName,
                Rating = rating
            };

            movieServiceMock
            .Setup(g => g.RateMovieAsync(movieName, rating))
            .ReturnsAsync(new MovieViewModel());

            var sut = new MovieController(movieServiceMock.Object, genreServiceMock.Object);

            // Act
            await sut.Rate(rateModel);

            // Assert
            movieServiceMock.Verify(m => m.RateMovieAsync(movieName, rating), Times.Once);
        }
예제 #8
0
        public void TestGet()
        {
            var controller = new MovieController(new TestMovieModelContext());
            var result     = controller.Get();

            Assert.AreEqual(1, 1);
        }
예제 #9
0
        public void GetAllTest()
        {
            var controller = new MovieController();
            var result     = controller.Get();

            Assert.Equal(3, result.Count());
        }
예제 #10
0
        public void TestPostMovieOk()
        {
            MovieModel movieModel = new MovieModel()
            {
                Name        = "Enola Holmes",
                AgeAllowed  = 12,
                CategoryId  = 1,
                Description = "La herama de Sherlock y Mycroft Holmes",
                Duration    = 2.1,
                Image       = "Mi directorio",
            };
            Movie movieToReturn = new Movie()
            {
                Id          = 1,
                Name        = "Enola Holmes",
                AgeAllowed  = 12,
                CategoryId  = 1,
                Description = "La herama de Sherlock y Mycroft Holmes",
                Duration    = 2.1,
                Image       = "Mi directorio",
                Rank        = 0
            };
            var mock = new Mock <IMovieLogic>();

            mock.Setup(m => m.Add(It.IsAny <Movie>())).Returns(movieToReturn);
            var controller = new MovieController(mock.Object);

            var result  = controller.Post(movieModel);
            var status  = result as CreatedAtRouteResult;
            var content = status.Value as MovieDetailInfoModel;

            mock.VerifyAll();
            Assert.AreEqual(content, new MovieDetailInfoModel(movieToReturn));
        }
        public void view_details_OK()
        {
            //Arrange
            var controller      = new MovieController(new MovieBLL(new MovieRepositoryStub()));
            var expected_result = new Movie()
            {
                Id           = 1,
                ImageAddress = "movieImageAddress.jpg",
                Title        = "Title",
                Description  = "Blockbaster",
                Price        = 12,
                Genre        = "Fantasy"
            };

            //Act
            var actionResult = (ViewResult)controller.Details(1);
            var result       = (Movie)actionResult.Model;

            //Assert
            Assert.AreEqual(actionResult.ViewName, "");
            Assert.AreEqual(expected_result.Id, result.Id);
            Assert.AreEqual(expected_result.ImageAddress, result.ImageAddress);
            Assert.AreEqual(expected_result.Title, result.Title);
            Assert.AreEqual(expected_result.Description, result.Description);
            Assert.AreEqual(expected_result.Price, result.Price);
            Assert.AreEqual(expected_result.Genre, result.Genre);
        }
        public async Task GetMovieTest()
        {
            MovieDTO inputMovie = TestingHelper.GetRandomMovie();
            MovieDTO outputMovie;

            // Seed the test database
            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                TestingHelper.AddMovieDTOToDatabase(context, inputMovie);
            }

            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                RepoLogic repoLogic = new RepoLogic(context);

                IMovieLogic     movieLogic      = new MovieLogic(repoLogic);
                MovieController movieController = new MovieController(movieLogic);
                // Test GetMovie()
                outputMovie = (await movieController.GetMovie(inputMovie.ImdbId)).Value;
            }

            Assert.Equal(inputMovie.ImdbId, outputMovie.ImdbId);
        }
        public void SearchRatingTest()
        {
            MovieDTO      inputMovie = TestingHelper.GetRandomMovie(0, 0, 0, 0, 0);
            List <string> searchResults;

            var filters = new Dictionary <string, string[]>();

            Console.WriteLine(inputMovie);
            filters.Add("Rating", new string[] { inputMovie.RatingName });

            // Seed the test database
            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                TestingHelper.AddMovieDTOToDatabase(context, inputMovie);
                TestingHelper.AddMovieDTOToDatabase(context, TestingHelper.GetRandomMovie(0, 0, 0, 0, 0));
            }

            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                RepoLogic       repoLogic       = new RepoLogic(context);
                IMovieLogic     movieLogic      = new MovieLogic(repoLogic);
                MovieController movieController = new MovieController(movieLogic);
                // Test SearchMovies()
                searchResults = movieController.SearchMovies(filters).Value;
            }

            Assert.Equal(inputMovie.ImdbId, searchResults[0]);
        }
예제 #14
0
        public async Task GetMoviesTest()
        {
            List <MovieDetail> movies = new List <MovieDetail>()
            {
                new MovieDetail()
                {
                    Title = "test_1", Id = "cm1"
                },
                new MovieDetail()
                {
                    Title = "test_2", Id = "cm1"
                },
                new MovieDetail()
                {
                    Title = "test_1", Id = "fm1"
                },
                new MovieDetail()
                {
                    Title = "test_2", Id = "fm1"
                },
            };
            var movieService = new Mock <IMovieService>();

            movieService.Setup(s => s.GetMoviesByComparingPrice()).Returns(() => Task.FromResult(movies));
            MovieController movieController = new MovieController(movieService.Object);
            IActionResult   actionResult    = await movieController.GetMoviesAsync();

            OkObjectResult okResult = actionResult as OkObjectResult;

            Assert.IsNotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
            Assert.IsInstanceOfType(actionResult, typeof(OkObjectResult));
        }
        public void DeleteMovieTest()
        {
            MovieDTO inputMovie = TestingHelper.GetRandomMovie();
            Movie    outputMovie;

            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                TestingHelper.AddMovieDTOToDatabase(context, inputMovie);

                RepoLogic       repoLogic       = new RepoLogic(context);
                IMovieLogic     movieLogic      = new MovieLogic(repoLogic);
                MovieController movieController = new MovieController(movieLogic);
                // Test DeleteMovie()
                movieController.DeleteMovie(inputMovie.ImdbId);
            }

            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                outputMovie = context.Movies.FirstOrDefault(m => m.ImdbId == inputMovie.ImdbId);
            }

            Assert.Null(outputMovie);
        }
예제 #16
0
        public void Get_toplist_returns_expected_error()
        {
            var controller = new MovieController(new ListSourceMock(null));
            var actual     = controller.Toplist();

            Assert.AreEqual("Could not retrieve movies from source", actual.First());
        }
예제 #17
0
        public async Task GetMovies_CorrectViewReturned()
        {
            var pagedMovies = new PagedResult <MovieDto>
            {
                AllRows    = 24,
                PageNumber = 1,
                PagesCount = 2,
                PageSize   = 20,
                Results    = new List <MovieDto>()
            };
            var fakeMovieService = new Mock <IMovieService>();

            fakeMovieService.Setup(
                s => s.ListMoviesAsync(It.IsAny <MovieCriteria>(),
                                       It.IsAny <string>(),
                                       It.IsAny <int>(),
                                       It.IsAny <int>()))
            .ReturnsAsync(pagedMovies);

            var controller = new MovieController(fakeMovieService.Object, Mapper);

            var res = (PartialViewResult)await controller.GetMovies(new MovieCriteria());

            var model = (MovieListPagedViewModel)res.Model;

            Assert.Equal(1, model.PageNumber);
            Assert.Equal(2, model.PagesCount);
            Assert.Equal(24, model.RowsCount);
            Assert.Equal(20, model.PageSize);
            Assert.NotNull(model.Movies);
        }
예제 #18
0
        public async Task ReturnCorrectViewModel_OnGet()
        {
            // Arrange
            var movieServiceMock = new Mock <IMovieService>();
            var genreServiceMock = new Mock <IGenreService>();

            string movieName = "Spiderman";
            int    rating    = 10;

            var rateModel = new RateMovieViewModel()
            {
                Name   = movieName,
                Rating = rating
            };

            movieServiceMock
            .Setup(g => g.RateMovieAsync(movieName, rating))
            .ReturnsAsync(new MovieViewModel());

            var sut = new MovieController(movieServiceMock.Object, genreServiceMock.Object);

            // Act
            var result = await sut.Rate(rateModel) as JsonResult;

            // Assert
            Assert.IsInstanceOfType(result.Value, typeof(MovieViewModel));
        }
 public MovieControllerTests()
 {
     _movieApi             = new Mock <IMovieApi>();
     _movieMetaData        = new Mock <IMovieMetaData>();
     _logger               = new Mock <ILogger <MovieController> >();
     _movieControllerTests = new MovieController(_logger.Object, _movieApi.Object, _movieMetaData.Object);
 }
        public void SearchActorTagTest()
        {
            MovieDTO inputMovie     = TestingHelper.GetRandomMovie(1, 1, 1, 1, 1);
            MovieDTO unmatchedMovie = TestingHelper.GetRandomMovie(1, 1, 1, 1, 1);

            unmatchedMovie.MovieActors[0] = inputMovie.MovieActors[0];
            List <string> searchResults;

            var filters = new Dictionary <string, string[]>();

            filters.Add("Actor", new string[] { inputMovie.MovieActors[0] });
            filters.Add("Tag", new string[] { inputMovie.MovieTags[0] });

            // Seed the test database
            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                TestingHelper.AddMovieDTOToDatabase(context, inputMovie);
                TestingHelper.AddMovieDTOToDatabase(context, unmatchedMovie);
            }

            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                RepoLogic       repoLogic       = new RepoLogic(context);
                IMovieLogic     movieLogic      = new MovieLogic(repoLogic);
                MovieController movieController = new MovieController(movieLogic);
                // Test SearchMovies()
                searchResults = movieController.SearchMovies(filters).Value;
            }

            Assert.Equal(inputMovie.ImdbId, searchResults[0]);
        }
예제 #21
0
        public void TestGetAllMoviesOk()
        {
            List <Movie> moviesToReturn = new List <Movie>()
            {
                new Movie()
                {
                    Id          = 1,
                    Name        = "Iron man 3",
                    Description = "I'm Iron man",
                    AgeAllowed  = 16,
                    Duration    = 1.5
                },
                new Movie()
                {
                    Id          = 2,
                    Name        = "Iron man 2",
                    Description = "I'm Iron man",
                    AgeAllowed  = 16,
                    Duration    = 1.5
                }
            };
            var mock = new Mock <IMovieLogic>(MockBehavior.Strict);

            mock.Setup(m => m.GetAll()).Returns(moviesToReturn);
            var controller = new MovieController(mock.Object);

            var result   = controller.Get();
            var okResult = result as OkObjectResult;
            var movies   = okResult.Value as IEnumerable <MovieBasicInfoModel>;

            mock.VerifyAll();
            Assert.IsTrue(moviesToReturn.Select(m => new MovieBasicInfoModel(m)).SequenceEqual(movies));
        }
        public async Task PostTagTest()
        {
            var          inputMovie = TestingHelper.GetRandomMovie();
            var          inputTag   = TestingHelper.GetRandomTaggingDTO(inputMovie.ImdbId);
            MovieTagUser movieTagUser;

            // Seed the test database
            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                TestingHelper.AddMovieDTOToDatabase(context, inputMovie);

                RepoLogic       repoLogic       = new RepoLogic(context);
                IMovieLogic     movieLogic      = new MovieLogic(repoLogic);
                MovieController movieController = new MovieController(movieLogic);
                // Test TagMovie()
                await movieController.TagMovie(inputTag);
            }

            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                movieTagUser = context.MovieTagUsers.FirstOrDefault(m => m.ImdbId == inputTag.MovieId);
            }

            Assert.Equal(inputTag.MovieId, movieTagUser.ImdbId);
            Assert.Equal(inputTag.TagName, movieTagUser.TagName);
            Assert.Equal(inputTag.UserId, movieTagUser.UserId);
        }
예제 #23
0
        private async void ViewTrending_Loaded(object sender, RoutedEventArgs e)
        {
            LayoutRoot.Opacity = 1;
            if (App.TrendingViewModel.TrendingItems.Count == 0)
            {
                indicator = App.ShowLoading(this);

                movieController = new MovieController();

                TraktMovie[] movies = await movieController.GetTrendingMovies();

                App.TrendingViewModel.ClearTrendingItems();
                foreach (TraktMovie movie in movies)
                {
                    if (App.TrendingViewModel.TrendingItems.Count <= 80)
                    {
                        App.TrendingViewModel.TrendingItems.Add(new ViewModels.TrendingListItemViewModel()
                        {
                            Imdb = movie.imdb_id, Name = movie.Title, Year = movie.year, ImageSource = movie.Images.Poster
                        });
                    }
                }
                App.TrendingViewModel.NotifyPropertyChanged("TrendingItems");
                indicator.IsVisible = false;
            }
        }
        public void UnbanTagTest()
        {
            var  inputMovie    = TestingHelper.GetRandomMovie();
            var  inputTag      = TestingHelper.GetRandomTaggingDTO(inputMovie.ImdbId);
            bool inputBanState = true;
            Tag  tag;

            // Seed the test database
            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                TestingHelper.AddMovieDTOToDatabase(context, inputMovie);
                TestingHelper.AddTagToDatabase(context, inputTag, inputBanState);

                RepoLogic       repoLogic       = new RepoLogic(context);
                IMovieLogic     movieLogic      = new MovieLogic(repoLogic);
                MovieController movieController = new MovieController(movieLogic);
                // Test UnbanTag()
                movieController.UnbanTag(inputTag.TagName);
            }

            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                tag = context.Tags.FirstOrDefault(t => t.TagName == inputTag.TagName);
            }

            Assert.False(tag.IsBanned);
        }
예제 #25
0
        public App()
        {
            MovieController movieController = new MovieController();

            // The root page of your application

            var titleSearchPage     = new TitleSearchPage(movieController, new TitleSearchViewModel(movieController));
            var titleNavigationPage = new NavigationPage(titleSearchPage)
            {
                Title = "Search"
            };

            var topRatedPage           = new CustomListPage(movieController, new TopRatedViewModel(movieController));
            var topRatedNavigationPage = new NavigationPage(topRatedPage)
            {
                Title = "Top Rated"
            };

            var popularPage           = new CustomListPage(movieController, new PopularViewModel(movieController));
            var PopularNavigationPage = new NavigationPage(popularPage)
            {
                Title = "Popular"
            };

            var tabbedPage = new TabbedPageInitializer();

            tabbedPage.Children.Add(titleNavigationPage);
            tabbedPage.Children.Add(topRatedNavigationPage);
            tabbedPage.Children.Add(PopularNavigationPage);

            this.MainPage = tabbedPage;
        }
예제 #26
0
        public MovieControllerTests()
        {
            _collections = new List <Collection>
            {
                new Collection {
                    Id = "id1", Name = "collection1", PrimaryImage = "image1", Type = CollectionType.Movies
                },
                new Collection {
                    Id = "id2", Name = "collection2", PrimaryImage = "image2", Type = CollectionType.Movies
                }
            };

            _movieStats = new MovieStats
            {
                LongestMovie = new Poster {
                    Name = "The lord of the rings"
                }
            };

            _movieServiceMock = new Mock <IMovieService>();
            _movieServiceMock.Setup(x => x.GetMovieCollections()).Returns(_collections);
            _movieServiceMock.Setup(x => x.GetGeneralStatsForCollections(It.IsAny <List <string> >()))
            .Returns(_movieStats);

            _subject = new MovieController(_movieServiceMock.Object);
        }
        public TitleSearchViewModel(MovieController movieController)
        {
            _movieController   = movieController;
            TitleSearchCommand = new Command(async() =>
            {
                if (this.searchTitle != null && this.SearchTitle != "")
                {
                    // Activate loading Icon
                    Loading = true;
                    // Search movies by title
                    NoResult = false;
                    await GetMoviesAsync();

                    if (this.Movies.Count != 0)
                    {
                        SomeResult = true;
                        NoResult   = false;
                    }
                    else
                    {
                        SomeResult = false;
                        NoResult   = true;
                    }
                    // Deactivate loading icon
                    Loading = false;
                    GetCast(Movies);
                }
            });
        }
        public void FollowMovieTest()
        {
            MovieDTO      inputMovie = TestingHelper.GetRandomMovie();
            string        userId     = Guid.NewGuid().ToString();
            List <string> followedMovies;

            // Seed the test database
            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                TestingHelper.AddMovieDTOToDatabase(context, inputMovie);

                RepoLogic   repoLogic  = new RepoLogic(context);
                IMovieLogic movieLogic = new MovieLogic(repoLogic);
                // Test FollowMovie()
                movieLogic.FollowMovie(inputMovie.ImdbId, userId);
            }

            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                RepoLogic       repoLogic       = new RepoLogic(context);
                IMovieLogic     movieLogic      = new MovieLogic(repoLogic);
                MovieController movieController = new MovieController(movieLogic);
                // Test FollowMovie()
                followedMovies = movieController.GetFollowingMovies(userId).Value;
            }

            Assert.Contains(inputMovie.ImdbId, followedMovies);
        }
예제 #29
0
        public async Task MovieTest()
        {
            string inputMovieId = "ab10101010";
            string outputMovieId;

            // Seed the test database
            using (var context = new Repository.Models.Cinephiliacs_DbContext(dbOptions))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                RepoLogic repoLogic = new RepoLogic(context);

                // Test CreateMovie()
                IMovieLogic     movieLogic      = new MovieLogic(repoLogic);
                MovieController movieController = new MovieController(movieLogic);
                await movieController.CreateMovie(inputMovieId);
            }

            using (var context = new Repository.Models.Cinephiliacs_DbContext(dbOptions))
            {
                var gmMovie = context.Movies.FirstOrDefault <Repository.Models.Movie>(m => m.MovieId == inputMovieId);
                outputMovieId = gmMovie.MovieId;
            }

            Assert.Equal(inputMovieId, outputMovieId);
        }
        public async Task PatchExistingMovieTest()
        {
            MovieDTO inputMovie = TestingHelper.GetRandomMovie();
            Movie    outputMovie;

            // Seed the test database
            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                TestingHelper.AddMovieDTOToDatabase(context, inputMovie);

                RepoLogic       repoLogic       = new RepoLogic(context);
                IMovieLogic     movieLogic      = new MovieLogic(repoLogic);
                MovieController movieController = new MovieController(movieLogic);
                // Test AppendMovie()
                await movieController.AppendMovie(inputMovie.ImdbId, TestingHelper.GetRandomMovie());
            }

            using (var context = new Cinephiliacs_MovieContext(dbOptions))
            {
                outputMovie = context.Movies.FirstOrDefault(m => m.ImdbId == inputMovie.ImdbId);
            }

            Assert.NotEqual(inputMovie.Title, outputMovie.Title);
        }
예제 #31
0
        public void ReturnImage_WhenFoundImageIsNotNull()
        {
            // Arrange
            var movieServiceMock     = new Mock <IMovieService>();
            var movieRoleServiceMock = new Mock <IMovieRoleService>();
            var fileConverterMock    = new Mock <IFileConverter>();
            var mapperMock           = new Mock <IMapper>();
            var image   = new byte[128];
            var movieId = 1;

            movieServiceMock.Setup(ms => ms.GetMovieImage(movieId)).Returns(image);

            var movieController =
                new MovieController(
                    movieServiceMock.Object,
                    movieRoleServiceMock.Object,
                    fileConverterMock.Object,
                    mapperMock.Object);

            // Act
            movieController.MovieImage(movieId);

            // Assert
            fileConverterMock.Verify(fcm => fcm.GetDefaultPicture(), Times.Never);
        }
예제 #32
0
        public ShowingModule(OrmLiteConnectionFactory db)
            : base("/showings")
        {
            Get["/"] = _ =>
            {
                var showings = new ShowingsController(db);
                return View["ShowingList", showings.ListAll()];
            };

            Get["/{showing}"] = req =>
            {
                var showings = new ShowingsController(db);
                var showing = showings.Get(req.showing);
                if (showing == null)
                    return 404;
                return View["ShowingDetail", showing];
            };

            Get["/create"] = _ =>
            {
                var movieController = new MovieController(db);
                ViewBag["Movies"] = movieController.ListAll().GetSelectList();
                return View["NewShowing", new Showing()];
            };

            Post["/create"] = _ =>
            {
                var showing = this.Bind<Showing>();
                LogTo.Debug("Adding showing: {0}", showing);
                var showingsController = new ShowingsController(db);
                var showingId = showingsController.Add(showing);
                return Response.AsRedirect(ModulePath + "/" + showingId);
            };

            Get["{showing}/edit"] = req =>
            {
                // Look up the showing with given ID
                var showings = new ShowingsController(db);
                var showing = showings.Get(req.showing);
                if (showing == null)
                    return 404;

                // Tell the view where to POST to
                ViewBag["action"] = ModulePath + $"/{req.showing}/edit";

                // Do usual showing view stuff (see the create view) - it would be great if we could consolodate the the two into one function
                var movieController = new MovieController(db);
                ViewBag["Movies"] = movieController.ListAll().GetSelectList();
                return View["NewShowing", showing];
            };

            Post["{showing}/edit"] = req =>
            {
                int showingID;
                if (!int.TryParse(req.showing, out showingID))
                    return 404; // User tried to edit a showing with an invalid (non-numeric) ID

                var editedShowing = this.Bind<Showing>();
                var showings = new ShowingsController(db);
                var oldshowing = showings.Get(showingID);
                if(oldshowing == null)
                    return 404; // User tried to edit a nonexistent showing

                var filledSeats = oldshowing.TotalSeats - oldshowing.AvailableSeats;
                editedShowing.AvailableSeats = editedShowing.TotalSeats - filledSeats;

                //if(editedShowing.AvailableSeats < 0)
                //  return "Error: negative seats available"; // is this really an error condition? Maybe they're okay with making an overbooked show..

                editedShowing.ShowingId = showingID;
                showings.Update(editedShowing);
                return Response.AsRedirect(ModulePath + "/" + showingID);
            };

            Post["{showing}/delete"] = req =>
            {
                // Again, this code duplication is pretty nasty
                int showingID;
                if (!int.TryParse(req.showing, out showingID))
                    return 500; // User tried to edit a showing with an invalid (non-numeric) ID

                var showings = new ShowingsController(db);
                if (showings.Get(showingID) == null)
                    return 404; // User tried to edit a nonexistent showing

                showings.Delete(showingID);
                return Response.AsRedirect(ModulePath + "/");
            };
        }