public void GetMovies()
{
var service = new MovieService();
var movies = service.GetMovies();
Assert.AreEqual(movies.Count,15);
}
private static async Task<List<MovieInfo>> GetMovies()
{
var service = new MovieService();
var movies = await service.GetMovies();
return movies;
}
public void GetAllMovies_ShouldCallRepository_WhenValidParametersPassed()
{
var movieRepositoryMock = new Mock <IRepository <Movie> >();
var unitOfWorkMock = new Mock <IUnitOfWork>();
var movieFactoryMock = new Mock <IMovieFactory>();
var producerServiceMock = new Mock <IProducerService>();
var studioServiceMock = new Mock <IStudioService>();
var genreServiceMock = new Mock <IGenreService>();
var bookServiceMock = new Mock <IBookService>();
var starServiceMock = new Mock <IStarService>();
var movieService = new MovieService(movieRepositoryMock.Object, unitOfWorkMock.Object, movieFactoryMock.Object, producerServiceMock.Object,
studioServiceMock.Object, genreServiceMock.Object, bookServiceMock.Object, starServiceMock.Object);
movieService.GetAllMovies();
movieRepositoryMock.Verify(r => r.Entities, Times.Once);
}
private void lbMovies_DoubleClick(object sender, EventArgs e)
{
var selectedMovie = lbMovies.SelectedItem as MovieDTO;
using (MovieService movieService = new MovieService())
{
var movie = movieService.Get(selectedMovie.MovieId);
txtMovieName.Text = movie.MovieName;
cbGenre.SelectedValue = movie.GenreId;
dateTimePicker1.Value = movie.ReleaseDate;
txtDirector.Text = movie.DirectorName;
txtImdbScore.Text = movie.ImdbScore.ToString();
txtQuantity.Text = movie.Quantity.ToString();
txtUnitPrice.Text = movie.UnitPrice.ToString();
cbRecordStatus.SelectedValue = movie.RecordStatusId;
}
}
public void MovieService_UpdateMovieStatus_ReturnNull()
{
//Arrange
Movie movie = null;
var id = Guid.NewGuid();
Task <Movie> responseTask = Task.FromResult(movie);
_mockMoviesRepository = new Mock <IMoviesRepository>();
_mockMoviesRepository.Setup(x => x.GetByIdAsync(id)).Returns(responseTask);
MovieService movieController = new MovieService(_mockMoviesRepository.Object, _mockProjectionsRepository.Object, _mockMovieTagsRepository.Object, _mockTicketRepository.Object, _mockTagRepository.Object);
//Act
var resultAction = movieController.UpdateMovieStatus(id).ConfigureAwait(false).GetAwaiter().GetResult();
var result = resultAction;
//Assert
Assert.IsNull(resultAction);
}
public void MovieService_DeleteMovie_ReturnNull()
{
//Arrange
Movie movie = null;
var id = Guid.NewGuid();
_mockMoviesRepository = new Mock <IMoviesRepository>();
_mockMoviesRepository.Setup(x => x.Delete(id)).Returns(movie);
MovieService movieController = new MovieService(_mockMoviesRepository.Object, _mockProjectionsRepository.Object, _mockMovieTagsRepository.Object, _mockTicketRepository.Object, _mockTagRepository.Object);
//Act
var resultAction = movieController.DeleteMovie(id).ConfigureAwait(false).GetAwaiter().GetResult();
var result = resultAction;
//Assert
Assert.IsNull(resultAction);
}
public void CreateMovie_calls_dbset_add_and_saves_changes_to_context()
{
//Arrange
Movie movieToBeAdded = _fixture.CreateAutoFilledObject <Movie>();
Mock <DbSet <Movie> > mockSet = _fixture.CreateManyMoqDbSet <Movie>(5);
_mockContext.Setup(c => c.Movies)
.Returns(mockSet.Object);
var service = new MovieService(_mockContext.Object);
//Act
service.CreateMovie(movieToBeAdded);
//Assert
mockSet.Verify(m => m.Add(It.IsAny <Movie>()), Times.Once());
_mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
public async Task TestListOfHighestGrossingMoviesFromFakeData()
{
// System Under Test(SUT) MovieService => GetTopRevenueMovies
// Arrange
// mock objects, data, methods etc
_sut = new MovieService(new MockMovieRepository());
// Act
var movies = _sut.GetTopRevenueMovies();
// check the actual output with expected data
// AAA
// Arrange, Act and Assert
// Assert
Assert.IsNotNull(movies);
}
public void DeleteMovie_MovieIsDeleted()
{
var mockRepo = new Mock <IMovieRepository>();
var movie = new Movie {
Id = 123, Title = "Iron Man1", PosterPath = "IronMan1.jpg"
};
List <Movie> addedMovies = new List <Movie> {
movie
};
mockRepo.Setup(repo => repo.GetMovie(movie.Id)).Returns(movie);
mockRepo.Setup(repo => repo.DeleteMovie(movie.Id)).Callback <int>((id) => addedMovies.Remove(addedMovies.Single(m => m.Id == id)));
var service = new MovieService(mockRepo.Object, null);
service.DeleteMovie(movie.Id);
Assert.True(0 == addedMovies.Count);
}
public void UpdateMovieComments_ShouldNotThrowException()
{
//arrange
var comment = "thrilling movie with superb climax";
var movieId = 10001;
var mockRepo = new Mock <IMovieRepository>();
mockRepo.Setup(x => x.UpdateMovieComments(movieId, comment, "user1"));
Mock <IHttpContextAccessor> mockContext = GetMockContext();
var service = new MovieService(mockRepo.Object, mockContext.Object);
//act
Action actual = () => service.UpdateMovieComments(movieId, comment);
var expEx = Record.Exception(actual);
//assert
Assert.Null(expEx);
}
public void GetAllMovies_ShouldReturnListofMovie()
{
//arrange
var userId = "user1";
var mockRepo = new Mock <IMovieRepository>();
Mock <IHttpContextAccessor> mockContext = GetMockContext();
mockRepo.Setup(x => x.GetMovies(userId)).Returns(this.GetMovies());
var service = new MovieService(mockRepo.Object, mockContext.Object);
//act
var actual = service.GetAllMovies();
//assert
Assert.IsAssignableFrom <IEnumerable <Movie> >(actual);
Assert.True(actual.Count > 0);
}
public void DeleteMovie_ShouldNotThrowException()
{
//arrange
var movieId = 10003;
var mockRepo = new Mock <IMovieRepository>();
mockRepo.Setup(x => x.DeleteMovie(movieId, "user1"));
Mock <IHttpContextAccessor> mockContext = GetMockContext();
var service = new MovieService(mockRepo.Object, mockContext.Object);
//act
Action actual = () => service.DeleteMovie(movieId);
var actualEx = Record.Exception(actual);
//assert
Assert.Null(actualEx);
}
private void BTNGravar_Click(object sender, EventArgs e)
{
if (ValidatedFormMovie())
{
MovieFromForm();
MovieService = new MovieService();
if (string.IsNullOrEmpty(TBXCodigo.Text) || Movie.MovieCode == 0)
{
MovieService.Save(Movie);
}
else
{
MovieService.Update(Movie);
}
ClearFormMovie();
}
}
public MovieServiceTests()
{
_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
}
};
_movie = new Movie
{
CommunityRating = (float)1.7,
Id = "id1",
Name = "The lord of the rings",
PremiereDate = new DateTime(2002, 4, 2, 0, 0, 0),
OfficialRating = "R",
RunTimeTicks = 600000000,
Primary = "primarImage"
};
var movieRepositoryMock = new Mock <IMovieRepository>();
movieRepositoryMock.Setup(x => x.GetMovieCount(It.IsAny <List <string> >())).Returns(2);
movieRepositoryMock.Setup(x => x.GetGenreCount(It.IsAny <List <string> >())).Returns(14);
movieRepositoryMock.Setup(x => x.GetLowestRatedMovie(It.IsAny <List <string> >())).Returns(_movie);
movieRepositoryMock.Setup(x => x.GetHighestRatedMovie(It.IsAny <List <string> >())).Returns(_movie);
movieRepositoryMock.Setup(x => x.GetOlderPremieredMovie(It.IsAny <List <string> >())).Returns(_movie);
movieRepositoryMock.Setup(x => x.GetYoungestPremieredMovie(It.IsAny <List <string> >())).Returns(_movie);
movieRepositoryMock.Setup(x => x.GetShortestMovie(It.IsAny <List <string> >())).Returns(_movie);
movieRepositoryMock.Setup(x => x.GetLongestMovie(It.IsAny <List <string> >())).Returns(_movie);
movieRepositoryMock.Setup(x => x.GetYoungestAddedMovie(It.IsAny <List <string> >())).Returns(_movie);
movieRepositoryMock.Setup(x => x.GetPlayLength(It.IsAny <List <string> >())).Returns(6000000000000);
var collectionRepositoryMock = new Mock <ICollectionRepository>();
collectionRepositoryMock.Setup(x => x.GetCollectionByType(CollectionType.Movies)).Returns(_collections);
var genreRepositoryMock = new Mock <IGenreRepository>();
var personServiceMock = new Mock <IPersonService>();
var configurationServiceMock = new Mock <IConfigurationRepository>();
_subject = new MovieService(movieRepositoryMock.Object, collectionRepositoryMock.Object, genreRepositoryMock.Object, personServiceMock.Object, configurationServiceMock.Object);
}
public void DeleteMovie_calls_dbset_remove_and_saves_changes_to_context()
{
//Arrange
Mock <DbSet <Movie> > mockSet = _fixture.CreateManyMoqDbSet <Movie>(5);
Movie movieToBeDeleted = mockSet.Object.OrderBy(r => Guid.NewGuid()).First();
_mockContext.Setup(c => c.Movies)
.Returns(mockSet.Object);
var service = new MovieService(_mockContext.Object);
//Act
service.DeleteMovie(movieToBeDeleted);
//Assert
mockSet.Verify(m => m.Remove(It.IsAny <Movie>()), Times.Once());
_mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
static void Main(string[] args)
{
// Composition Root
IMovieService service = new MovieService(
new XmlMovieRepository(@"..\..\..\..\..\..\..\02 - Movies.xml"),
new DefaultTimeProvider()
);
// UI Layer
IEnumerable <MovieShowing> movies = service.GetMoviesShowing();
MainViewModel vm = new MainViewModel(movies);
foreach (MovieViewModel movie in vm.Movies)
{
Console.WriteLine(movie.DisplayText);
}
}
public void GetAllShouldReturnCorrectNumberOfPagesForMovies()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPagesForMovies))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var added = movieService.Create(new WebApplication3.ViewModels.MoviePostModel
{
Title = "Tianic",
Duration = 100,
Genre = "Thriller",
WatchedState = "Yes",
DateAdded = DateTime.Parse("2019-06-15T00:00:00"),
DateClosed = null,
//Title = movie.Title,
//Duration = movie.Duration,
//Genre = genre,
//WatchedState = watchedState,
//DateAdded = movie.DateAdded,
//DateClosed = movie.DateClosed,
//Comments = movie.Comments
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "A nice movie",
}
},
}, null);
DateTime from = DateTime.Parse("2019-06-13T00:00:00");
DateTime to = DateTime.Parse("2019-06-19T00:00:00");
var allTasks = movieService.GetAll(1, from, to);
Assert.AreEqual(1, allTasks.Entries.Count);
Assert.IsNotNull(allTasks);
}
}
public void OrderMoviesShouldReturnInputIfOrderByIsInvalid()
{
var input = new List <MovieAllViewModel>
{
new MovieAllViewModel
{
Name = "movie3",
ReleaseDate = DateTime.Parse("25 July 2021"),
Genre = "genre3",
CoverImageLink = "cover3",
Rating = 1,
TotalReviews = 1,
Watchlisted = false,
},
new MovieAllViewModel
{
Name = "movie2",
ReleaseDate = DateTime.Parse("24 July 2019"),
Genre = "genre2",
CoverImageLink = "cover2",
Rating = 1,
TotalReviews = 2,
Watchlisted = false,
},
new MovieAllViewModel
{
Name = "movie1",
ReleaseDate = DateTime.Parse("25 July 2020"),
Genre = "genre1",
CoverImageLink = "cover1",
Rating = 1,
TotalReviews = 1,
Watchlisted = false,
},
};
var movieService = new MovieService(dbContext, reviewService.Object, watchlistService.Object, mapper);
var actualResult = movieService.OrderMovies(input, "invalid orderBy");
Assert.True(actualResult.Count() == 3);
Assert.Equal(input[0], actualResult[0]);
Assert.Equal(input[1], actualResult[1]);
Assert.Equal(input[2], actualResult[2]);
}
public void DeleteTest()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteTest))
.Options;
using (var context = new MoviesDbContext(options))
{
var commentService = new CommentService(context);
var movieService = new MovieService(context);
var addedMovie = movieService.Create(new Lab3Movie.ViewModels.MoviePostModel
{
Title = "movie 1",
Description = "agfas",
Genre = "comedy",
DurationInMinutes = 100,
YearOfRelease = 2019,
Director = "director1",
Rating = 10,
Watched = "yes",
DateAdded = new DateTime(),
Comments = new List <Comment>()
{
new Comment
{
Text = "text",
Important = true,
Owner = null
}
},
}, null);
var addedComment = commentService.Create(new Lab3Movie.ViewModels.CommentPostModel
{
Important = true,
Text = "fdlkflsdkm",
}, addedMovie.Id);
var comment = commentService.Delete(addedComment.Id);
var commentNull = commentService.Delete(17);
Assert.IsNull(commentNull);
Assert.NotNull(comment);
}
}
public void GetMovie_ShouldReturnExpectedMovie_WhenTheCorrectRepositoryIsPassed()
{
var movieRepositoryMock = MockRepository.GenerateMock <IMovieRepository>();
var expectedMovie = new Movie();
expectedMovie.Id = 1;
expectedMovie.Title = "Test";
//Arrange
movieRepositoryMock.Expect(dao => dao.GetMovie(Arg <int> .Is.Anything)).Return(expectedMovie).Repeat.Once();;
var movieService = new MovieService(movieRepositoryMock);
//Act
var returnedMovie = movieService.GetMovie(1);
//Assert
Assert.AreEqual(expectedMovie.Id, returnedMovie.Id);
}
// GET: Edit Movie
public ActionResult Edit(int?id)
{
MovieService service = new MovieService();
MovieDetail detail = service.GetMovieById(id);
MovieEdit movie = new MovieEdit()
{
Id = detail.Id,
PosterUrl = detail.PosterUrl,
Title = detail.Title,
Description = detail.Description,
ReleaseDate = detail.ReleaseDate,
Franchise = detail.Franchise,
AnticipationValue = detail.AnticipationValue
};
return(View(movie));
}
/// <summary>
/// Set the current language of the application
/// </summary>
/// <param name="language">Language</param>
public async Task SetCurrentLanguage(Language language)
{
User.Language.Culture = language.Culture;
await MovieService.ChangeTmdbLanguage(language);
await ShowService.ChangeTmdbLanguage(language);
try
{
LocalizeDictionary.Instance.Culture = new CultureInfo(language.Culture);
}
catch (Exception ex)
{
Logger.Error(ex);
}
Messenger.Default.Send(new ChangeLanguageMessage());
}
public void MovieService_GetAll_RepositoryReturnsNull_ReturnsNull()
{
//Arrange
IEnumerable <Movie> nullMovie = null;
Task <IEnumerable <Movie> > responseTask = Task.FromResult(nullMovie);
MovieService movieService = new MovieService(_mockMoviesRepository.Object, _mockProjectionService.Object, _mockMovieTagService.Object);
_mockMoviesRepository.Setup(x => x.GetAll()).Returns(responseTask);
//Act
var result = movieService.GetAllMovies().ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNull(result);
}
public async Task GetMovieTest()
{
int movieId = 1;
var movie = new Movie()
{
MovieId = movieId, Name = "Movie One"
};
var fakeRepositoryMock = new Mock <IMovieRepository>();
fakeRepositoryMock.Setup(x => x.GetMovie(movieId)).ReturnsAsync(movie);
var movieService = new MovieService(fakeRepositoryMock.Object);
var resultMovie = await movieService.GetMovie(movieId);
Assert.Equal("Movie One", resultMovie.Name);
}
private void Form1_Load(object sender, EventArgs e)
{
ms = new MovieService();
foreach (var movie in ms.movies)
{
var treeroot = new TreeNode(movie.MovieName);
treeroot.Tag = movie;
foreach (var time in movie.ListMovieTime)
{
var times = new TreeNode(time.MovieTimes);
times.Tag = time;
treeroot.Nodes.Add(times);
}
treeView1.Nodes.Add(treeroot);
}
treeView1.AfterSelect += TreeView1_AfterSelect;
comboBox1.SelectedIndexChanged += ComboBox1_SelectedIndexChanged;
}
public async Task MovieIdAndTitleExistsShouldReturnMovieIdUsingDbContext()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "MoviesDbTest").Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Movies.Add(new Movie {
Id = 1, Title = "Titanic"
});
await dbContext.SaveChangesAsync();
var repository = new EfRepository <Movie>(dbContext);
var service = new MovieService(repository);
Assert.True(service.MovieExist(1));
Assert.True(service.MovieTitleExists("Titanic"));
}
public void ShouldGetMoviesFromRepositoryWithFilterAndPaging()
{
var movieQuery = new MovieQuery
{
SearchFilter = "Search",
Categories = new List <string> {
"Action"
},
Take = 10,
Skip = 5
};
var movieService = new MovieService(_mockMovieRepository.Object, _mockMovieConverter.Object);
movieService.All(movieQuery);
_mockMovieRepository.Verify(m => m.GetAll(movieQuery), Times.Once);
}
public void GivenMovieWithSameTitle_WhenAddingNewMovie_ThenMovieFromRepository()
{
var mock = new Mock <IMovieRepository>();
var movie = new Movie()
{
Title = "test film", Description = "description"
};
mock.Setup(p => p.GetByTitle(It.IsAny <string>()))
.Returns(movie);
mock.Setup(p => p.Add(It.IsAny <Movie>()))
.Returns(movie);
var service = new MovieService(mock.Object);
var dbMovie = service.Add(movie);
Assert.IsNull(dbMovie);
}
public void SetUp()
{
var myProfile = new MoviesMappingProfile();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(myProfile));
_mapper = new Mapper(configuration);
_mockMovieRepository = new Mock <IMovieRepository>();
_mockGenresRepository = new Mock <IAsyncRepository <MovieGenre> >();
_mockPurchaseRepository = new Mock <IPurchaseRepository>();
_mockFavoriteRepository = new Mock <IAsyncRepository <Favorite> >();
_sut = new MovieService(_mockMovieRepository.Object, _mapper, _mockGenresRepository.Object,
_mockPurchaseRepository.Object,
_mockFavoriteRepository.Object);
_mockMovieRepository.Setup(m => m.GetHighestGrossingMovies()).ReturnsAsync(_movies);
}
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 MoviesListViewModel()
{
genreService = new GenresService();
movieService = new MovieService();
Genres = new ObservableCollection <Genre>(genreService.GetAllGenres());
Movies = new ObservableCollection <Movie>();
ShowSearchItemsCommand = new Command(ShowSearchItems);
SearchCommand = new Command(RePopulateCollection);
ResetCommand = new Command(
() => {
selectedGenre = null;
RePopulateCollection();
});
RePopulateCollection();
}
public ActionResult Create(MovieCreate model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
//var userId = Guid.Parse(User.Identity.GetUserId());
var service = new MovieService();
if (service.CreateMovie(model))
{
TempData["SaveResult"] = "Your Movie was Created";
return(RedirectToAction("Index"));
}
return(View(model));
}
public MoviesController()
{
_context = new ApplicationDbContext();
_movieService = new MovieService(new MovieRepository(_context));
}
