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);
}
