public async Task Succeed_ReturnMovie()
{
var options = TestUtils.GetOptions(nameof(Succeed_ReturnMovie));
using (var assertContext = new MoviesCatalogContext(options))
{
var sut = new MovieService(assertContext);
DateTime releaseDate = DateTime.Now;
var movie = await sut.CreateMovieAsync("Movie 01", "Trailer", "Poster", null, "Description", releaseDate, "3c57e188 - 409f - 447b - a55d - 37e450df359e");
var user = new ApplicationUser()
{
UserName = "******"
};
movie.User = user;
Assert.AreEqual(movie.Title, "Movie 01");
Assert.AreEqual(movie.Trailer, "Trailer");
Assert.AreEqual(movie.Poster, "Poster");
Assert.AreEqual(movie.Description, "Description");
Assert.AreEqual(movie.User.UserName, "peter");
Assert.AreEqual(movie.ReleaseDate, releaseDate);
}
}
public async Task Throw_WhenMovie_DoesExists()
{
var dabataseName = nameof(Throw_WhenMovie_DoesExists);
var options = MovieTestUtils.GetOptions(dabataseName);
// We fill the context with data and save it.
MovieTestUtils.FillContextWithActorsMoviesAndGenres(options);
var mappingProviderMock = new Mock <IMappingProvider>();
// we use new instance of that context, but it has the data already saved.
using (var actAndAssertContext = new MovieManagementContext(options))
{
var sut = new MovieService(actAndAssertContext, mappingProviderMock.Object);
string movieName = "Spiderman";
int duration = 90;
string director = "TestDirector";
string storyline = "TestStoryline";
string imageUrl = "TestImageUrl";
string genreName = "TestGenre";
await Assert.ThrowsExceptionAsync <EntityAlreadyExistsException>(
async() => await sut.CreateMovieAsync(movieName, duration, storyline, director, imageUrl, genreName));
}
}
public async Task AddNewMovie_WhenAllParametersAreValid()
{
var dabataseName = nameof(AddNewMovie_WhenAllParametersAreValid);
var options = MovieTestUtils.GetOptions(dabataseName);
MovieTestUtils.FillContextWithGenre(options);
var mappingProviderMock = new Mock <IMappingProvider>();
string movieName = "Spiderman";
int duration = 90;
string director = "TestDirector";
string storyline = "TestStoryline";
string imageUrl = "TestImageUrl";
string genreName = "Comedy";
using (var arrangeContext = new MovieManagementContext(options))
{
var sut = new MovieService(arrangeContext, mappingProviderMock.Object);
await sut.CreateMovieAsync(movieName, duration, storyline, director, imageUrl, genreName);
arrangeContext.SaveChanges();
}
using (var actAndAssertContext = new MovieManagementContext(options))
{
Assert.IsTrue(actAndAssertContext.Movies.Count() == 1);
Assert.IsTrue(actAndAssertContext.Movies.Any(m => m.Name == movieName));
}
}
public async Task ReturnCorrectViewModel()
{
// Arrange
var dabataseName = nameof(ReturnCorrectViewModel);
var options = MovieTestUtils.GetOptions(dabataseName);
MovieTestUtils.FillContextWithGenre(options);
// setting up the automapper to be able to map the object from Movie to MovieViewModel
var mappingProviderMock = new Mock <IMappingProvider>();
mappingProviderMock.Setup(x => x.MapTo <MovieViewModel>(It.IsAny <Movie>())).Returns(new MovieViewModel());
using (var actAndAssertContext = new MovieManagementContext(options))
{
var sut = new MovieService(actAndAssertContext, mappingProviderMock.Object);
string movieName = "TestMovie";
int duration = 90;
string director = "TestDirector";
string storyline = "TestStoryline";
string imageUrl = "TestImageUrl";
string genreName = "Comedy";
var result = await sut.CreateMovieAsync(movieName, duration, storyline, director, imageUrl, genreName);
Assert.IsInstanceOfType(result, typeof(MovieViewModel));
}
}
public async Task <IActionResult> Create([Bind("ID,Title,QualityType,ReleaseDate,Genre,Price,Rating")] Movie movie)
{
if (ModelState.IsValid)
{
await _movieService.CreateMovieAsync(movie);
return(RedirectToAction("Index"));
}
return(View(movie));
}
public void CatchCreateMovieWithInvalidName(string name)
{
var movieService = new MovieService(Mock.Of <IRepository>());
var inputModel = new Core.Application.InputModels.Movies.CreateMovieInputModel()
{
Name = name
};
Assert.ThrowsAsync <ModelValidationException>(async() => await movieService.CreateMovieAsync(inputModel));
}
public async Task CreateMovieShouldReturnFalseIfProvidedGenreArtistOrMovieNameIsInvalid(string movieName, string genreName, string directorName, bool expectedResult)
{
var genre1 = new Genre
{
Name = "genre1"
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = genre1,
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
await dbContext.Genres.AddAsync(genre1);
await dbContext.Artists.AddAsync(artist1);
await dbContext.Movies.AddAsync(movie1);
await dbContext.SaveChangesAsync();
var movieService = new MovieService(dbContext, reviewService.Object, watchlistService.Object, mapper);
var input = new CreateMovieInputModel
{
Name = movieName,
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = genreName,
Director = directorName,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var actualResult = await movieService.CreateMovieAsync(input);
Assert.Equal(actualResult, expectedResult);
}
public async Task CreateMovieWithSuccess()
{
using (var context = CreateContext())
{
var movieService = new MovieService(new RepositoryBase(context));
var inputModel = new Core.Application.InputModels.Movies.CreateMovieInputModel()
{
Name = "Test"
};
var result = await movieService.CreateMovieAsync(inputModel);
Assert.AreEqual(inputModel.Name, result.Name);
Assert.IsTrue(result.Id != default);
ClearContext(context);
}
}
public async Task CreateMovieShouldSetDefaultCoverAndTrailerIfNotProvided()
{
var genre1 = new Genre
{
Name = "genre1"
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
await dbContext.Genres.AddAsync(genre1);
await dbContext.Artists.AddAsync(artist1);
await dbContext.SaveChangesAsync();
var movieService = new MovieService(dbContext, reviewService.Object, watchlistService.Object, mapper);
var input = new CreateMovieInputModel
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = "genre1",
Director = "name1",
CoverImageLink = "",
TrailerLink = " ",
};
var actualResult = await movieService.CreateMovieAsync(input);
Assert.True(actualResult);
Assert.True(dbContext.Movies.Count() == 1);
Assert.Equal(genre1, dbContext.Movies.First().Genre);
Assert.Equal(artist1, dbContext.Movies.First().Director);
Assert.Equal(GlobalConstants.noImageLink, dbContext.Movies.First().CoverImageLink);
Assert.Equal(GlobalConstants.noTrailerLink, dbContext.Movies.First().TrailerLink);
}
public async Task Throw_WhenGenreIsNotFound()
{
var dabataseName = nameof(Throw_WhenGenreIsNotFound);
var options = MovieTestUtils.GetOptions(dabataseName);
var mappingProviderMock = new Mock <IMappingProvider>();
using (var actAndAssertContext = new MovieManagementContext(options))
{
var sut = new MovieService(actAndAssertContext, mappingProviderMock.Object);
string movieName = "Spiderman";
int duration = 90;
string director = "TestDirector";
string storyline = "TestStoryline";
string imageUrl = "TestImageUrl";
string genreName = "TestGenre";
await Assert.ThrowsExceptionAsync <EntityInvalidException>(
async() => await sut.CreateMovieAsync(movieName, duration, storyline, director, imageUrl, genreName));
}
}
