public async Task BoundaryTestFor_ValidMovieId()
{
//mocking
_mockCollection.Setup(op => op.InsertOneAsync(_movieManagement, null,
default(CancellationToken))).Returns(Task.CompletedTask);
_mockContext.Setup(c => c.GetCollection <MovieManagement>(typeof(MovieManagement).Name)).Returns(_mockCollection.Object);
//Craetion of new Db
_mockOptions.Setup(s => s.Value).Returns(settings);
var context = new MongoDBContext(_mockOptions.Object);
var userRepo = new MovieServices(context);
var res = false;
//Act
await userRepo.RegisterAsync(_movieManagement);
var result = await userRepo.SearchByMovieByIdAsync(_movieManagement.MovieId);
Assert.InRange(_movieManagement.MovieId.Length, 20, 30);
//writing tset boolean output in text file, that is present in project directory
if (result.MovieId.Length.ToString() == _movieManagement.MovieId.Length.ToString())
{
res = true;
}
File.AppendAllText("../../../../output_boundary_revised.txt", "BoundaryTestFor_ValidMovieId=" + res + "\n");
}
public async Task BoundaryTestFor_ValidMovieName()
{
//mocking
_mockCollection.Setup(op => op.InsertOneAsync(_movieManagement, null,
default(CancellationToken))).Returns(Task.CompletedTask);
_mockContext.Setup(c => c.GetCollection <MovieManagement>(typeof(MovieManagement).Name)).Returns(_mockCollection.Object);
//Craetion of new Db
_mockOptions.Setup(s => s.Value).Returns(settings);
var context = new MongoDBContext(_mockOptions.Object);
var userRepo = new MovieServices(context);
//Act
await userRepo.RegisterAsync(_movieManagement);
var result = await userRepo.SearchByMovieByIdAsync(_movieManagement.MovieId);
bool DirectorName = Regex.IsMatch(result.DirectedBy, @"^[a-zA-Z0-9]{4,10}$", RegexOptions.IgnoreCase);
bool isUserName = Regex.IsMatch(_movieManagement.DirectedBy, @"^[a-zA-Z0-9]{4,10}$", RegexOptions.IgnoreCase);
//writing tset boolean output in text file, that is present in project directory
File.AppendAllText("../../../../output_boundary_revised.txt", "BoundaryTestFor_ValidBuyerName=" + isUserName.ToString() + "\n");
//Assert
Assert.True(isUserName);
Assert.True(DirectorName);
}
public void UpdateMovie_WhenParametersAreCorrect()
{
var updatedMovie = new Movie();
unitOfWork.Setup(x => x.Movies).Returns(movieRepoMock.Object);
movieRepoMock
.Setup(repo => repo.AllAndDeleted())
.Returns(predifinedListOfMovies.AsQueryable());
movieRepoMock
.Setup(repo => repo.Update(It.IsAny <Movie>()))
.Callback <Movie>((movie) =>
{
predifinedListOfMovies.Remove(movie);
predifinedListOfMovies.Add(updatedMovie);
});
//Act
var command = new MovieServices(unitOfWork.Object);
command.UpdateMovie(testMovieName, testMovieDescription, testMovieReleaseYear, testMovieDuration);
//Assert
Assert.AreEqual(1, predifinedListOfMovies.Count);
Assert.AreSame(updatedMovie, predifinedListOfMovies.First());
Assert.IsFalse(updatedMovie.IsDeleted);
}
public async Task ThrowMovieNotFoundExceptionWhenMovieIsNotValid(int movieID, bool deletedFlag)
{
// Arrange
var reviewRepoStub = new Mock <IRepository <Review> >();
var movieRepoMock = new Mock <IRepository <Movie> >();
var movieMock = new Movie
{
Name = "Stivi's adventure into unit testing of the underworld",
ID = 1,
IsDeleted = deletedFlag,
};
movieRepoMock
.Setup(mr => mr.All())
.Returns(new List <Movie>()
{
movieMock
}.AsQueryable().BuildMock().Object);
var directorRepoStub = new Mock <IRepository <Director> >();
var genreRepoStub = new Mock <IRepository <Genre> >();
var movieGenreRepoStub = new Mock <IRepository <MovieGenre> >();
var sut = new MovieServices(reviewRepoStub.Object, movieRepoMock.Object, directorRepoStub.Object, genreRepoStub.Object, movieGenreRepoStub.Object);
// Act & Assert
await Assert.ThrowsExceptionAsync <MovieNotFoundException>(async() => await sut.RateMovieAsync(movieID, 5, "pishki", "randomUseRId"));
}
public ActionResult AddGenre(MovieModel movieModel, GenreModel genreModel)
{
_movieServices = new MovieServices();
_movieServices.AddGenreForMovie(movieModel.Id, genreModel.Name);
return(RedirectToAction("ListMovie"));
}
public void SearchMovie_Should_FindTheCorrectOnes()
{
var db = new TFContext(DatabaseSimulator());
var genreServiceMock = new Mock <IGenreServices>();
var movieService = new MovieServices(db, genreServiceMock.Object);
var movie = new Movie()
{
Id = 1,
Title = "The Movie"
};
var secondMovie = new Movie()
{
Id = 2,
Title = "The Movies"
};
var movieWithoutThe = new Movie()
{
Id = 3,
Title = "Movie"
};
db.Movies.AddRange(movie, secondMovie, movieWithoutThe);
db.SaveChanges();
int movieCount = movieService.SearchMovie("The").Count();
Assert.AreEqual(2, movieCount);
}
public ActionResult AddMovie(MovieModel model)
{
_movieServices = new MovieServices();
_movieServices.InsertMovie(model);
return(RedirectToAction("ListMovie"));
}
public IActionResult GetRecomandedMovies(string customerID)
{
IMovieServices services = new MovieServices();
var list = services.GetMovieLists(customerID);
return(new JsonResult(list));
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
// Get our button from the layout resource,
// and attach an event to it
var movieInputText = this.FindViewById <EditText>(Resource.Id.movieTextInputLabel);
var getMovieButton = this.FindViewById <Button>(Resource.Id.getMovieButton);
var displayMovieTextView = this.FindViewById <TextView>(Resource.Id.isplayMovieSearchLabel);
MovieDbFactory.RegisterSettings(new MovieDbSettings());
var movieApi = MovieDbFactory.Create <IApiMovieRequest>().Value;
var movieService = new MovieServices(movieApi);
MovieDownload.StorageClient storageClient = new MovieDownload.StorageClient();
MovieDownload.ImageDownloader imageDownloader = new MovieDownload.ImageDownloader(storageClient);
getMovieButton.Click += async(object sender, EventArgs e) =>
{
this._movieList = await movieService.getListOfMoviesMatchingSearch(movieInputText.Text);
// await imageDownloader.getLocalPath(this._movieList);
//var answer = getListOfMoviesMatchingSearch(movieInputText.Text);
var manager = (InputMethodManager)this.GetSystemService(InputMethodService);
manager.HideSoftInputFromWindow(movieInputText.WindowToken, 0);
displayMovieTextView.Text = this._movieList[0].Title;
};
}
public ActionResult ListMovie()
{
_movieServices = new MovieServices();
var model = _movieServices.GetMovieList();
return(View(model));
}
//get movie by genre
public IHttpActionResult Get(GenreType genre)
{
MovieServices movieService = CreateMovieService();
var movie = movieService.GetMovieByGenre((Data.GenreType)genre);
return(Ok(genre));
}
//Get(string title)
public IHttpActionResult Get(string title)
{
MovieServices movieService = CreateMovieService();
var movie = movieService.GetMovieByTitle(title);
return(Ok(title));
}
//get all movies
public IHttpActionResult Get()
{
MovieServices movieService = CreateMovieService();
var movies = movieService.GetMovies();
return(Ok(movies));
}
private MovieServices CreateMovieService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var movieService = new MovieServices(userId);
return(movieService);
}
public ActionResult EditMovie(int id)
{
_movieServices = new MovieServices();
var model = _movieServices.GetMovieById(id);
return(View(model));
}
public async Task ReturnsEmptyList_WhenMovieNameDoNotMach()
{
var reviewRepoMock = new Mock <IRepository <Review> >();
var directorRepoMock = new Mock <IRepository <Director> >();
var genreRepoStub = new Mock <IRepository <Genre> >();
var movieGenreRepoStub = new Mock <IRepository <MovieGenre> >();
var movieRepoMock = new Mock <IRepository <Movie> >();
movieRepoMock
.Setup(mr => mr.All())
.Returns(new List <Movie> {
Venom, TheMovie23
}.AsQueryable().BuildMock().Object);
var sut = new MovieServices(reviewRepoMock.Object,
movieRepoMock.Object, directorRepoMock.Object,
genreRepoStub.Object, movieGenreRepoStub.Object);
//Act
var result = await sut.SearchMovieAsync("GoshoPansa", new List <string> {
"NemaTakivJanr"
}, "Bay Pesho");
//Assert
Assert.IsTrue(result.Count == 0);
}
public async Task SearchAndFindMovie_WhenParametersAreCorrect()
{
//Arrange
var expectedMovie = new List <Movie>();
expectedMovie.Add(Venom);
var reviewRepoMock = new Mock <IRepository <Review> >();
var directorRepoMock = new Mock <IRepository <Director> >();
var genreRepoStub = new Mock <IRepository <Genre> >();
var movieGenreRepoStub = new Mock <IRepository <MovieGenre> >();
var movieRepoMock = new Mock <IRepository <Movie> >();
movieRepoMock
.Setup(mr => mr.All())
.Returns(new List <Movie> {
Venom, TheMovie23
}.AsQueryable().BuildMock().Object);
var sut = new MovieServices(reviewRepoMock.Object,
movieRepoMock.Object, directorRepoMock.Object,
genreRepoStub.Object, movieGenreRepoStub.Object);
//Act
var result = await sut.SearchMovieAsync("Venom", new List <string> {
"p**n"
}, "thebsetdirector");
//Assert
Assert.AreEqual("Venom", result.FirstOrDefault().Name);
}
public async Task ThrowMovieNotFoundException_WhenMovieIsDeleted()
{
//Arrange
var reviewRepoStub = new Mock <IRepository <Review> >();
var movieRepoMock = new Mock <IRepository <Movie> >();
var movieToBeChecked = new Movie
{
Name = "Stivi's adventure into unit testing of the underworld",
ID = 1,
IsDeleted = true,
};
movieRepoMock
.Setup(mr => mr.All())
.Returns(new List <Movie>()
{
movieToBeChecked
}.AsQueryable().BuildMock().Object);
var directorRepoStub = new Mock <IRepository <Director> >();
var genreRepoStub = new Mock <IRepository <Genre> >();
var movieGenreRepoStub = new Mock <IRepository <MovieGenre> >();
var sut = new MovieServices(reviewRepoStub.Object, movieRepoMock.Object, directorRepoStub.Object, genreRepoStub.Object, movieGenreRepoStub.Object);
//Act & Assert
await Assert.ThrowsExceptionAsync <MovieNotFoundException>(async() => await sut.CheckMovieAsync(1));
}
public async Task ThrowsMovieNotFoundException_WhenMovieIsDeleted()
{
// Arrange
const int movieID = 1;
var reviewRepoStub = new Mock <IRepository <Review> >();
var movieRepoMock = new Mock <IRepository <Movie> >();
movieRepoMock
.Setup(mr => mr.All())
.Returns(new List <Movie>()
{
new Movie {
ID = movieID, IsDeleted = true
}
}
.AsQueryable()
.BuildMock()
.Object);
var directorRepoStub = new Mock <IRepository <Director> >();
var genreRepoStub = new Mock <IRepository <Genre> >();
var movieGenreRepoStub = new Mock <IRepository <MovieGenre> >();
var sut = new MovieServices(reviewRepoStub.Object, movieRepoMock.Object, directorRepoStub.Object, genreRepoStub.Object, movieGenreRepoStub.Object);
// Act & Assert
await Assert.ThrowsExceptionAsync <MovieNotFoundException>(async() => await sut.DeleteMovieAsync(movieID));
}
// [OneTimeSetup] in nUnit
public void OneTimeSetup()
{
_MockMovieRepo = new Mock <IMovieRepository>();
// SUT System under Test MovieService => GetTopRevenueMovies
_sut = new MovieServices(_MockMovieRepo.Object);
_MockMovieRepo.Setup(m => m.GetHighestRevenueMovies()).ReturnsAsync(_movies);
}
public XFMovieSearchPage(MovieServices movieService)
{
this._movieService = movieService;
this._viewModel = new MovieListViewModel(this.Navigation, this._movieService);
this.BindingContext = this._viewModel;
InitializeComponent();
}
public void DeleteAllMovieGenres_WhenMovieIsDeleted()
{
// Arrange
var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>()
.UseInMemoryDatabase(databaseName: "DeleteAllMovieGenres_WhenMovieIsDeleted")
.Options;
var movieGenre = new MovieGenre();
movie.MovieGenres.Add(movieGenre);
//Act
using (var actContext = new AlphaCinemaContext(contextOptions))
{
actContext.Movies.Add(movie);
actContext.SaveChanges();
var unitOfWork = new UnitOfWork(actContext);
var command = new MovieServices(unitOfWork);
command.DeleteMovie(testMovieName);
}
//Assert
using (var assertContext = new AlphaCinemaContext(contextOptions))
{
Assert.IsTrue(movie.MovieGenres.First().IsDeleted);
}
}
public MoviePage(Movie movie, MovieServices movieService)
{
this._movie = movie;
this._movieService = movieService;
this.BindingContext = movie;
InitializeComponent();
}
public void CallDeleteMethodOnMovie_WhenMovieExists()
{
//Arrange
movieMock.Object.IsDeleted = false;
movieRepoMock
.Setup(repo => repo.Delete(It.IsAny <Movie>()))
.Callback <Movie>((movie) =>
{
predifinedListOfMovies.Remove(movieMock.Object);
});
unitOfWork.Setup(x => x.Movies).Returns(movieRepoMock.Object);
unitOfWork.Setup(p => p.Projections.All()).Returns(new List <Projection>().AsQueryable());
unitOfWork.Setup(mg => mg.MovieGenres.All()).Returns(new List <MovieGenre>().AsQueryable());
movieRepoMock.Setup(repo => repo.AllAndDeleted()).Returns(predifinedListOfMovies.AsQueryable());
//Act
var command = new MovieServices(unitOfWork.Object);
command.DeleteMovie(movieMock.Object.Name);
//Assert
Assert.AreEqual(0, predifinedListOfMovies.Count);
}
public App()
{
InitializeComponent();
MovieDbFactory.RegisterSettings(new MovieDbSettings());
var movieApi = MovieDbFactory.Create <IApiMovieRequest>().Value;
this._movieService = new MovieServices(movieApi);
var moviePage = new XFMovieSearchPage(this._movieService);
var movieNavigationPage = new NavigationPage(moviePage);
movieNavigationPage.Title = "Search";
this._topRatedPage = new TopRatedPage(this._movieService);
var topRatedNavigationPage = new NavigationPage(this._topRatedPage);
topRatedNavigationPage.Title = "Top Rated";
this._popularMoviesPage = new PopularMoviesPage(this._movieService);
var popularNavigationPage = new NavigationPage(this._popularMoviesPage);
popularNavigationPage.Title = "Popular movies";
this._tabbedPage = new TabPage(this._topRatedPage, this._popularMoviesPage);
this._tabbedPage.Children.Add(movieNavigationPage);
this._tabbedPage.Children.Add(topRatedNavigationPage);
this._tabbedPage.Children.Add(popularNavigationPage);
MainPage = this._tabbedPage;
}
public void AddAllPreviousMovieGenres_WhenMovieIsRestored()
{
// Arrange
var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>()
.UseInMemoryDatabase(databaseName: "AddAllPreviousMovieGenres_WhenMovieIsRestored")
.Options;
movie.IsDeleted = true;
movieGenre.IsDeleted = true;
movie.MovieGenres.Add(movieGenre);
//Act
using (var actContext = new AlphaCinemaContext(contextOptions))
{
actContext.Movies.Add(movie);
actContext.SaveChanges();
var unitOfWork = new UnitOfWork(actContext);
var addMovieCommand = new MovieServices(unitOfWork);
addMovieCommand.AddNewMovie(testMovieName, testMovieDescription,
testMovieReleaseYear, testMovieDuration);
}
//Assert
using (var assertContext = new AlphaCinemaContext(contextOptions))
{
Assert.IsFalse(movie.MovieGenres.First().IsDeleted);
}
}
private void cmdBrowseFile_Click(object sender, RoutedEventArgs e)
{
try
{
OpenFileDialog objDialog = new OpenFileDialog();
objDialog.InitialDirectory = Environment.SpecialFolder.MyComputer.ToString();
if (objDialog.ShowDialog() == true)
{
if (string.IsNullOrEmpty(objDialog.FileName) == false)
{
txtFileName.Text = objDialog.SafeFileName;
_objEntity.FileName = objDialog.SafeFileName;
if (string.IsNullOrWhiteSpace(txtFilePath.Text))
{
txtFilePath.Text = objDialog.FileName.Replace(objDialog.SafeFileName, "");
_objEntity.FilePath = txtFilePath.Text;
}
MovieServices.Fill(MediaInfoService.getInfo(objDialog.FileName, _objEntity.Id), _objEntity);
MovieUpdate parent = Util.TryFindParent <MovieUpdate>(this);
parent.Bind();
}
}
}
catch (Exception ex)
{
Util.LogException(ex);
new MessageBoxYesNo(ex.Message, false, true).ShowDialog();
}
}
public async Task TestFor_SearchByAllotMovieIdAsync()
{
//Arrange
//mocking
//mocking
var res = false;
_mockCollection.Setup(op => op.InsertOneAsync(_movieManagement, null,
default(CancellationToken))).Returns(Task.CompletedTask);
_mockContext.Setup(c => c.GetCollection <MovieManagement>(typeof(MovieManagement).Name)).Returns(_mockCollection.Object);
_mockOptions.Setup(s => s.Value).Returns(settings);
var context = new MongoDBContext(_mockOptions.Object);
var userRepo = new MovieServices(context);
//Action
var movie = await userRepo.RegisterAsync(_movieManagement);
//Assert
Assert.NotNull(movie);
Assert.Equal(_movieManagement.DirectedBy, movie.DirectedBy);
//writing tset boolean output in text file, that is present in project directory
if (movie != null)
{
res = true;
}
File.AppendAllText("../../../../output_revised.txt", "TestFor_SearchByAllotMovieIdAsync=" + res + "\n");
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
MovieServices listmovie = new MovieServices();
MoviePeopleServices castlist = new MoviePeopleServices();
List <MovieModelDTO> ListOfAllMovies = new List <MovieModelDTO>();
ListOfAllMovies = listmovie.GetAllMovies();
ddlTitleMovie.DataSource = ListOfAllMovies;
ddlTitleMovie.DataBind();
ddlTitleMovie.Items.Insert(0, new ListItem("<-Choose Movie->", "0"));
//-------------------------------------------------------------------------
List <MovieModelDTO> ListOfYears = listmovie.GetAllYears();
List <string> Years = new List <string>();
foreach (var item in ListOfYears)
{
string year = item.Year;
Years.Add(year);
}
ddlYearMovie.DataSource = Years.ToList().Distinct();
ddlYearMovie.DataBind();
ddlYearMovie.Items.Insert(0, new ListItem("<-Choose Year->", "0"));
//-----------------------------
List <MoviePersonDTO> ListOfAcotrs = castlist.GetActors();
ddlActorMovie.DataTextField = "FirstName";
ddlActorMovie.DataValueField = "LastName";
ddlActorMovie.DataSource = ListOfAcotrs;
ddlActorMovie.DataBind();
ddlActorMovie.Items.Insert(0, new ListItem("<-Choose Actor->", "0"));
//----------------------------------------------
List <MoviePersonDTO> ListOfProducers = castlist.GetProducers();
ddlProducerMovie.DataTextField = "FirstName";
ddlProducerMovie.DataValueField = "LastName";
ddlProducerMovie.DataSource = ListOfProducers;
ddlProducerMovie.DataBind();
ddlProducerMovie.Items.Insert(0, new ListItem("<-Choose Producer->", "0"));
//-------------------------------------------------------
//genre to bind
ddlGenreMovie.DataSource = listmovie.GetAllGenres();
ddlGenreMovie.DataBind();
ddlGenreMovie.Items.Insert(0, new ListItem("<-Choose Genre->", "0"));
//repeater to bind
List <MovieModelDTO> ListOfMovies = new List <MovieModelDTO>();
ListOfMovies = listmovie.GetAllMovies();
RepeaterMovie.DataSource = ListOfMovies;
RepeaterMovie.DataBind();
}
}
public MovieListPage(List <Movie> movieList, MovieServices movieService)
{
this._movieList = movieList;
this._movieService = movieService;
this._viewModel = new MovieListViewModel(this.Navigation, this._movieService);
this.BindingContext = this._viewModel;
InitializeComponent();
}
