public void CallAddMethodOfMovieRepositoryOnce()
{
// Arrange
var movieMock = new Mock <Movie>();
var genreMock = new Mock <Genre>();
var movieRepositoryMock = new Mock <IRepository <Movie> >();
var personRepositoryMock = new Mock <IRepository <Person> >();
var genreRepositoryMock = new Mock <IRepository <Genre> >();
var movieRoleRepositoryMock = new Mock <IRepository <MovieRole> >();
var movieRatingRepositoryMock = new Mock <IRepository <MovieRating> >();
IEnumerable <Movie> filteredMovies = new List <Movie>();
ICollection <Genre> filteredGenres = new List <Genre>();
filteredGenres.Add(genreMock.Object);
movieRepositoryMock.Setup(mr => mr.GetAllFiltered(It.IsAny <Expression <Func <Movie, bool> > >()))
.Returns(filteredMovies);
genreRepositoryMock.Setup(gr => gr.GetAllFiltered(It.IsAny <Expression <Func <Genre, bool> > >()))
.Returns(filteredGenres);
var movieService = new MovieService(
movieRepositoryMock.Object,
personRepositoryMock.Object,
genreRepositoryMock.Object,
movieRoleRepositoryMock.Object,
movieRatingRepositoryMock.Object);
// Act
movieService.AddMovie(movieMock.Object, string.Empty);
// Assert
movieRepositoryMock.Verify(mr => mr.Add(movieMock.Object), Times.Once);
}
public void ThrowArgumentNullException_WhenGenreDoesNotExist()
{
// Arrange
var movieMock = new Mock <Movie>();
var movieRepositoryMock = new Mock <IRepository <Movie> >();
var personRepositoryMock = new Mock <IRepository <Person> >();
var genreRepositoryMock = new Mock <IRepository <Genre> >();
var movieRoleRepositoryMock = new Mock <IRepository <MovieRole> >();
var movieRatingRepositoryMock = new Mock <IRepository <MovieRating> >();
IEnumerable <Movie> filteredMovies = new List <Movie>();
IEnumerable <Genre> filteredGenres = new List <Genre>();
movieRepositoryMock.Setup(mr => mr.GetAllFiltered(It.IsAny <Expression <Func <Movie, bool> > >()))
.Returns(filteredMovies);
genreRepositoryMock.Setup(gr => gr.GetAllFiltered(It.IsAny <Expression <Func <Genre, bool> > >()))
.Returns(filteredGenres);
var movieService = new MovieService(
movieRepositoryMock.Object,
personRepositoryMock.Object,
genreRepositoryMock.Object,
movieRoleRepositoryMock.Object,
movieRatingRepositoryMock.Object);
// Act && Assert
Assert.Throws <ArgumentNullException>(() => movieService.AddMovie(movieMock.Object, string.Empty));
}
public async Task ChangeIsDeletedToFalse_WhenMovieAlreadyExist()
{
// Arrange
var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>()
.UseInMemoryDatabase(databaseName: "ChangeIsDeletedToFalse_WhenMovieAlreadyExist")
.UseInternalServiceProvider(serviceProvider)
.Options;
using (var arrangeContext = new AlphaCinemaContext(contextOptions))
{
movie.IsDeleted = true;
await arrangeContext.AddAsync(movie);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new AlphaCinemaContext(contextOptions))
{
var command = new MovieService(assertContext);
await command.AddMovie(movieName, movieDescription, releaseYear, movieDuration);
Assert.IsTrue(!assertContext.Movies.First().IsDeleted);
Assert.AreEqual(1, await assertContext.Movies.CountAsync());
Assert.AreEqual(movieName, assertContext.Movies.First().Name);
Assert.AreEqual(movieDescription, assertContext.Movies.First().Description);
Assert.AreEqual(int.Parse(movieDuration), assertContext.Movies.First().Duration);
Assert.AreEqual(int.Parse(releaseYear), assertContext.Movies.First().ReleaseYear);
}
}
public void AddMovieShouldCorrectlyAddMovieToDb_WhenCalledWithValidData()
{
// arrange
var effortContext = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var movieObjectToReturn = new Movie()
{
Title = "Test Movie Object",
Runtime = 120
};
mapperMock.Setup(x => x.Map <Movie>(It.IsAny <MovieModel>()))
.Returns(movieObjectToReturn);
var movieModelToAdd = new MovieModel()
{
Title = "Test Movie model",
Runtime = 120
};
// Act
var sut = new MovieService(effortContext, mapperMock.Object);
sut.AddMovie(movieModelToAdd);
Assert.AreEqual(1, effortContext.Movies.Count());
}
public async void ShouldNotAddMovieIfExistsWithSameName()
{
var name = "film";
var description = "opis filmu";
var logo = new ImageModel();
var repo = new Mock <IRepository <Movie> >();
var reviewRepo = new Mock <IRepository <Review> >();
var favouriteMovieRepo = new Mock <IRepository <FavouriteMovie> >();
var hostingEnvironment = new Mock <IHostingEnvironment>();
var store = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(store.Object, null, null, null, null, null, null, null, null);
repo.Setup(x => x.Exists(It.IsAny <Expression <Func <Movie, bool> > >())).Returns(Task.FromResult(true));
var movieModel = new MovieModel()
{
Name = name,
Description = description,
Logo = logo.Image
};
var movieService = new MovieService(repo.Object, reviewRepo.Object, userManager.Object, hostingEnvironment.Object, favouriteMovieRepo.Object);
var result = await movieService.AddMovie(movieModel);
string error = "Film o podanej nazwie został już utworzony";
Assert.Contains(error, result.Error);
}
private void registerMovieButton_Click(object sender, EventArgs e)
{
try
{
var name = this.nameTextBox.Text;
var directorName = this.directorNameTextBox.Text;
float?rating = (float?)this.ratingUpDown.Value;
var year = (int)this.yearUpDown.Value;
var image = this.movieImageBytes;
//TODO: CHECK IF IMAGE ALREADY EXISTS
//TODO: IF NOT -> UPLOAD IT FIRST (code)
MovieService.AddMovie(name, rating, 150, directorName, year, this.ageRestriction, null, null, image);
MessageBox.Show(Constants.SuccessMessages.MovieRegisteredSuccessfully);
AdminMenuForm adminMenuForm = new AdminMenuForm();
adminMenuForm.TopLevel = false;
adminMenuForm.AutoScroll = true;
this.Hide();
((Button)sender).Parent.Parent.Controls.Add(adminMenuForm);
adminMenuForm.Show();
}
catch (Exception exception)
{
MessageBox.Show("Movie Register failed!");
}
}
public static void ImportMovie(MovieDTO movieDto)
{
string movieName = movieDto.Name;
InputDataValidator.ValidateStringMaxLength(movieName, Constants.MaxMovieNameLength);
float?rating = movieDto.Rating;
InputDataValidator.ValidateFloatInRange(rating, Constants.MinRatingValue, Constants.MaxRatingValue);
int releaseYear = movieDto.ReleaseYear;
MovieValidator.ValidateMovieDoesNotExist(movieName, releaseYear);
List <string> categories = movieDto.Categories.Select(c => c.Name).ToList();
CategoryValidator.CheckCategoriesExist(categories);
string directorName = movieDto.DirectorName;
int length = movieDto.Length;
AgeRestriction ageRestriction = (AgeRestriction)Enum.Parse(typeof(AgeRestriction), movieDto.AgeRestriction);
string synopsis = movieDto.Synopsis;
string releaseCountry = movieDto.ReleaseCountry;
byte[] image = movieDto.Image;
MovieService.AddMovie(movieName, rating, length, directorName, releaseYear, ageRestriction, synopsis,
releaseCountry, image);
MovieImportService.AddCategoriesToMovie(movieName, releaseYear, categories);
Console.WriteLine(string.Format(Constants.ImportSuccessMessages.MoviesAddedSuccess, movieName));
}
public void ThrowInvalidOperationException_WhenPassedMovieExists()
{
// Arrange
var movieMock = new Mock <Movie>();
var movieRepositoryMock = new Mock <IRepository <Movie> >();
var personRepositoryMock = new Mock <IRepository <Person> >();
var genreRepositoryMock = new Mock <IRepository <Genre> >();
var movieRoleRepositoryMock = new Mock <IRepository <MovieRole> >();
var movieRatingRepositoryMock = new Mock <IRepository <MovieRating> >();
ICollection <Movie> filteredMovies = new List <Movie>();
filteredMovies.Add(movieMock.Object);
movieRepositoryMock.Setup(mr => mr.GetAllFiltered(It.IsAny <Expression <Func <Movie, bool> > >()))
.Returns(filteredMovies);
var movieService = new MovieService(
movieRepositoryMock.Object,
personRepositoryMock.Object,
genreRepositoryMock.Object,
movieRoleRepositoryMock.Object,
movieRatingRepositoryMock.Object);
// Act && Assert
Assert.Throws <InvalidOperationException>(() => movieService.AddMovie(movieMock.Object, string.Empty));
}
protected void UploadButton_Click(object sender, EventArgs e)
{
if (EmptyCheck())
{
string name = ImageUpload.FileName;
string ipath = Server.MapPath(@"~\Images\") + name;
ImageUpload.SaveAs(ipath);
var movie = new Movie()
{
MovieTypeId = Convert.ToInt32(MovieTypeList.SelectedValue),
MovieName = MovieNameBox.Text,
Description = DescriptionBox.Text,
Actor = ActorBox.Text,
Image = @"~\Images\" + name,
UploadDate = DateTime.Now,
IsAudit = false
};
var movieService = new MovieService();
var result = movieService.AddMovie(movie);
if (result == 1)
{
Response.Redirect("MovieMaintenance.aspx");
}
else
{
Response.Write("<script>alert('添加失败')</script>");
}
}
}
public async void ShouldAddMovieIfDataIsCorrect()
{
var name = "film";
var description = "opis filmu";
var logo = new ImageModel();
var repo = new Mock <IRepository <Movie> >();
var reviewRepo = new Mock <IRepository <Review> >();
var favouriteMovieRepo = new Mock <IRepository <FavouriteMovie> >();
var hostingEnvironment = new Mock <IHostingEnvironment>();
var store = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(store.Object, null, null, null, null, null, null, null, null);
repo.Setup(x => x.Exists(It.IsAny <Expression <Func <Movie, bool> > >())).Returns(Task.FromResult(false));
var movieModel = new MovieModel()
{
Name = name,
Description = description,
Logo = logo.Image
};
var movieService = new MovieService(repo.Object, reviewRepo.Object, userManager.Object, hostingEnvironment.Object, favouriteMovieRepo.Object);
var result = await movieService.AddMovie(movieModel);
Assert.Null(result.Error);
}
public async Task AddNewMovie_WhenParametersAreCorrect()
{
// Arrange
var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>()
.UseInMemoryDatabase(databaseName: "AddNewMovie_WhenParametersAreCorrect")
.UseInternalServiceProvider(serviceProvider)
.Options;
//Act
using (var actContext = new AlphaCinemaContext(contextOptions))
{
var command = new MovieService(actContext);
await command.AddMovie(movieName, movieDescription, releaseYear, movieDuration);
await actContext.SaveChangesAsync();
}
//Assert
using (var assertContext = new AlphaCinemaContext(contextOptions))
{
Assert.AreEqual(1, await assertContext.Movies.CountAsync());
Assert.AreEqual(movieName, assertContext.Movies.First().Name);
Assert.AreEqual(movieDescription, assertContext.Movies.First().Description);
Assert.AreEqual(int.Parse(movieDuration), assertContext.Movies.First().Duration);
Assert.AreEqual(int.Parse(releaseYear), assertContext.Movies.First().ReleaseYear);
}
}
public IActionResult PostCadastrar(Film movie)
{
if (movie != null)
{
serviceMovie = new MovieService(_context);
serviceMovie.AddMovie(movie);
}
return(Accepted());
}
public void MovieService_AddMovie_ThrowsDbUpdateException()
{
//Arrange
MovieService movieService = new MovieService(_mockMoviesRepository.Object, _mockProjectionService.Object, _mockMovieTagService.Object);
_mockMoviesRepository.Setup(x => x.Insert(It.IsAny <Movie>())).Throws(new DbUpdateException());
//Act
var result = movieService.AddMovie(_movieDomainModel).ConfigureAwait(false).GetAwaiter().GetResult();
}
public async Task <IActionResult> CreateMovie([FromBody] MovieAddRequest request)
{
var movieSameTitleAndDate = await MovieService.GetMovie(request.Title, request.ReleaseDate);
if (movieSameTitleAndDate != null)
{
return(BadRequest(ApiResponse.Failure("Movie", $"Movie {request.Title} released: {request.ReleaseDate.Date} exists")));
}
var addedMovie = await MovieService.AddMovie(request);
return(Ok(ApiResponse <MovieDetails> .Success(addedMovie)));
}
public void MovieService_AddMovie_ReturnsCreatedMovie()
{
//Arrange
MovieService movieService = new MovieService(_mockMovieRepository.Object, _mockProjectionRepository.Object);
//Act
var resultAction = movieService.AddMovie(_movieDomainModel).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.AreEqual(_movieDomainModel.Title, resultAction.Title);
Assert.AreEqual(_movie.Id, resultAction.Id);
Assert.IsInstanceOfType(resultAction, typeof(MovieDomainModel));
}
public void AddMovie_MovieAdded()
{
var mockRepo = new Mock <IMovieRepository>();
var movie = new Movie {
Id = 123, Title = "Iron Man1", PosterPath = "IronMan1.jpg"
};
List <Movie> addedMovies = new List <Movie>();
mockRepo.Setup(repo => repo.AddMovie(movie)).Callback <Movie>((m) => addedMovies.Add(m));
var service = new MovieService(mockRepo.Object, null);
service.AddMovie(movie);
Assert.True(1 == addedMovies.Count);
Assert.NotNull(addedMovies.SingleOrDefault(m => m.Title == "Iron Man1"));
}
private void registerMovieButton_Click(object sender, EventArgs e)
{
var name = this.nameTextBox.Text;
var directorName = this.directorNameTextBox.Text;
float?rating = (float?)this.ratingUpDown.Value;
var year = (int)this.yearUpDown.Value;
var image = this.movieImageBytes;
movieService.AddMovie(name, rating, 150, directorName, year, this.ageRestriction, null, null, image);
MessageBox.Show(Constants.SuccessMessages.MovieRegisteredSuccessfully);
var mainForm = (SoftCinemaForm)((Button)sender).Parent.Parent.Parent;
mainForm.RenderSideBar();
//Redirect to home page view
SoftCinemaForm.SetContentHolderForm(new HomeForm());
}
public void MovieService_AddMovie_RepositoryReturnsNull_ReturnsNull()
{
// Arrange
Movie nullMovie = null;
MovieService movieService = new MovieService(_mockMoviesRepository.Object, _mockProjectionService.Object, _mockMovieTagService.Object);
_mockMoviesRepository.Setup(x => x.Insert(It.IsAny <Movie>())).Returns(nullMovie);
_mockMoviesRepository.Setup(x => x.Save());
//Act
var result = movieService.AddMovie(_movieDomainModel).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNull(result);
}
public void GivenMovieWithSameTitle_WhenAddingNewMovie_ThenMovie()
{
var mock = new Mock <IMovieRepository>();
var movie = new Movie()
{
Title = "Hello World", Description = "Test"
};
mock.Setup(p => p.GetByTitle(It.IsAny <string>()))
.Returns(It.IsAny <Movie>());
var service = new MovieService(mock.Object);
var dbMovie = service.AddMovie(movie);
Assert.IsNull(dbMovie);
}
public void MovieService_AddMovie_ReturnsAddedMovie()
{
//Arrange
MovieService movieService = new MovieService(_mockMoviesRepository.Object, _mockProjectionService.Object, _mockMovieTagService.Object);
_mockMoviesRepository.Setup(x => x.Insert(It.IsAny <Movie>())).Returns(_movie);
_mockMoviesRepository.Setup(x => x.Save());
//Act
var result = movieService.AddMovie(_movieDomainModel).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(MovieDomainModel));
Assert.AreEqual(result.Id, _movie.Id);
}
public void MovieService_AddMovie_ReturnNull()
{
//Arrange
MovieDomainModel movieDomainModel = _movieDomainModel;
MovieCreateTagDomainModel movieCreate = new MovieCreateTagDomainModel();
Movie movie = null;
_mockMoviesRepository = new Mock <IMoviesRepository>();
_mockMoviesRepository.Setup(x => x.Insert(It.IsAny <Movie>())).Returns(movie);
MovieService movieController = new MovieService(_mockMoviesRepository.Object, _mockProjectionsRepository.Object, _mockMovieTagsRepository.Object, _mockTicketRepository.Object, _mockTagRepository.Object);
//Act
var resultAction = movieController.AddMovie(movieDomainModel, movieCreate).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNull(resultAction);
}
public void AddMovie_ShouldReturnMovie_forValidMovieId()
{
//arrange
Movie newMovie = new Movie {
Id = 10004, Name = "Spiderman", Comments = string.Empty, PosterPath = "spiderman.jpg", ReleaseDate = "13-10-2003", VoteCount = 82345, VoteAverage = 7.9, UserId = "user1"
};
var mockRepo = new Mock <IMovieRepository>();
Mock <IHttpContextAccessor> mockContext = GetMockContext();
mockRepo.Setup(x => x.AddMovie(newMovie)).Returns(newMovie);
var service = new MovieService(mockRepo.Object, mockContext.Object);
//act
var actual = service.AddMovie(newMovie);
//assert
Assert.NotNull(actual);
Assert.Same(newMovie, actual);
}
public void ThrowArgumentNullException_WhenPassedMovieIsNull()
{
// Arrange
var movieRepositoryMock = new Mock <IRepository <Movie> >();
var personRepositoryMock = new Mock <IRepository <Person> >();
var genreRepositoryMock = new Mock <IRepository <Genre> >();
var movieRoleRepositoryMock = new Mock <IRepository <MovieRole> >();
var movieRatingRepositoryMock = new Mock <IRepository <MovieRating> >();
var movieService = new MovieService(
movieRepositoryMock.Object,
personRepositoryMock.Object,
genreRepositoryMock.Object,
movieRoleRepositoryMock.Object,
movieRatingRepositoryMock.Object);
// Act && Assert
Assert.Throws <ArgumentNullException>(() => movieService.AddMovie(null, string.Empty));
}
public void MovieService_AddMovie_ReturnMovieDomainModel()
{
//Arrange
MovieDomainModel movieDomainModel = _movieDomainModel;
MovieCreateTagDomainModel movieCreate = new MovieCreateTagDomainModel();
Movie movie = _movie;
//MovieDomainModel repositoryResponse = _mov;
_mockMoviesRepository = new Mock <IMoviesRepository>();
_mockMoviesRepository.Setup(x => x.Insert(It.IsAny <Movie>())).Returns(movie);
MovieService movieController = new MovieService(_mockMoviesRepository.Object, _mockProjectionsRepository.Object, _mockMovieTagsRepository.Object, _mockTicketRepository.Object, _mockTagRepository.Object);
//Act
var resultAction = movieController.AddMovie(movieDomainModel, movieCreate).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.IsInstanceOfType(resultAction, typeof(MovieDomainModel));
Assert.AreEqual(resultAction.Rating, movieDomainModel.Rating);
Assert.AreEqual(resultAction.Id, movieDomainModel.Id);
}
public void AddMovie_ShouldCallMovieRepositoryMockOnce_WhenTheCorrectRepositoryIsPassed()
{
var movieRepositoryMock = MockRepository.GenerateMock <IMovieRepository>();
//Arrange
var movie = new Movie {
Id = 1
};
movieRepositoryMock.Expect(dao => dao.AddMovie(Arg <Movie> .Is.Anything)).Repeat.Once();;
var movieService = new MovieService(movieRepositoryMock);
//Act
movieService.AddMovie(movie);
//Assert
//movieRepositoryMock.AssertWasCalled(x => x.AddMovie(movie),
// x => x.Repeat.Once());
movieRepositoryMock.VerifyAllExpectations();
}
public async Task ThrowException_WhenMovieAlreadyExist()
{
// Arrange
var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>()
.UseInMemoryDatabase(databaseName: "ThrowException_WhenMovieAlreadyExist")
.UseInternalServiceProvider(serviceProvider)
.Options;
using (var arrangeContext = new AlphaCinemaContext(contextOptions))
{
await arrangeContext.AddAsync(movie);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new AlphaCinemaContext(contextOptions))
{
var command = new MovieService(assertContext);
await Assert.ThrowsExceptionAsync <Exception>(async() => await command.AddMovie(movieName, movieDescription, releaseYear, movieDuration));
}
}
public async Task <IActionResult> AddMovies([FromBody] Movie movie)
{
var user = HttpContext.User;
if (user == null)
{
return(Unauthorized());
}
var userrole = user.Claims.FirstOrDefault(x => x.Type.Equals("userroles"))?.Value;
if (!(await _userSer.IsAdmin(userrole)))
{
return(Unauthorized());
}
if (string.IsNullOrWhiteSpace(movie.Name))
{
return(Ok(new { data = "Movie name is blank. Cant add Movie", success = 0 }));
}
var response = await _movSer.AddMovie(movie);
return(Ok(new { data = response.Item1, success = response.Item2 }));
}
public void AddMovie_ShouldAddNewMovieRecord()
{
var initialCount = GetMovies().Count;
var title = Guid.NewGuid().ToString();
var movieViewModel = new MovieViewModel
{
Name = title,
Rating = "PG-13",
ShowTime = DateTime.Now,
TicketPrice = 8.85m
};
_movieService.AddMovie(movieViewModel);
var actual = GetMovieByTitle(title);
Assert.AreEqual(initialCount + 1, GetMovies().Count);
Assert.AreEqual(movieViewModel.Name, actual.Name);
Assert.AreEqual(movieViewModel.Rating, actual.Rating);
Assert.AreEqual(movieViewModel.TicketPrice, actual.TicketPrice);
}
public void AddMovieShould_ThrowWhenCalledWithInvalidData()
{
// arrange
var effortContext = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var movieObjectToReturn = new Movie()
{
Title = "Test Movie Object",
Runtime = 120
};
mapperMock.Setup(x => x.Map <Movie>(It.IsAny <MovieModel>()))
.Returns(movieObjectToReturn);
var movieToAdd = new MovieModel();
var sut = new MovieService(effortContext, mapperMock.Object);
// Act & Assert
Assert.ThrowsException <ArgumentException>(() => sut.AddMovie((movieToAdd)));
}
public ActionResult Create(MovieDto model)
{
_movieService.AddMovie(model);
return(RedirectToAction("Index"));
}
