public void Setup()
{
movieRepository = new FakeMovieRepository();
seenRepository = new FakeSeenRepository();
controller = new MoviesController(movieRepository, seenRepository);
MockUserAuthentication(false);
}
public void ReturnBackWithErrorOnInvalidModel()
{
// Arrange
var moviesSvMock = new Mock <IMoviesService>();
var fakeMovie = new MovieEditViewModel();
var sut = new MoviesController(moviesSvMock.Object);
var fakeHttpContext = new Mock <HttpContextBase>();
sut.ControllerContext = new ControllerContext
{
Controller = sut,
HttpContext = fakeHttpContext.Object
};
sut.ModelState.AddModelError("Name", "Ivalid movie name");
// Act & Assert
sut
.WithCallTo(c => c.Edit(fakeMovie))
.ShouldRenderDefaultView()
.WithModel <MovieEditViewModel>()
.AndModelErrorFor(m => m.Name);
}
public void GetMoviesById_ShouldReturnNotFound_InvalidId()
{
//Arrange
var expectedData = this.nullMovie;
var movieId = -1;
mockRepository
.Setup(x => x.GetMovie(movieId))
.Returns(expectedData);
var controller = new MoviesController(mockRepository.Object, cacheStorage.Object, mockUrlHelper.Object);
controller.Request = new HttpRequestMessage()
{
Properties = { { System.Web.Http.Hosting.HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } }
};
//Act
var response = controller.GetDataById(movieId);
//Assert
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
}
public void Create_ReturnsARedirectAndAddsSession_WhenModelStateIsValid()
{
// Arrange
var mockRepo = new Mock <IRepository>();
mockRepo.Setup(repo => repo.Add <Movie>(It.IsAny <Movie>()))
.Verifiable();
var controller = new MoviesController(mockRepo.Object, webHostEnvironment);
var newMovie = new MovieCreateViewModel()
{
Title = "New Movie"
};
// Act
var result = controller.Create(newMovie);
// Assert
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Movies", redirectToActionResult.ControllerName);
Assert.Equal("Index", redirectToActionResult.ActionName);
mockRepo.Verify();
}
public void CreateMovieReturnsMovieWSlugAlreadyExists()
{
// Arrange
var movieRepositoryMock = new Mock <IMovieRepository>();
var controller = new MoviesController(movieRepositoryMock.Object);
var movie = new Movie()
{
Id = 1, CodeName = "test", Gender = "test", Name = "test", Slug = "test"
};
var movie2 = new Movie()
{
Id = 2, CodeName = "test2", Gender = "test2", Name = "test2", Slug = "test"
};
var message = "There is already a movie with the same slug";
movieRepositoryMock.Setup(repo => repo.GetBySlug(movie.Name)).Returns(movie2);
// Act
var result = (ObjectResult)controller.Post(movie);
// Assert
Assert.AreEqual(message, result.Value, "Create movie is not validating existing movies with same slug");
}
public TestIntegrations()
{
//Create TestServer
var builder = new WebHostBuilder()
.UseStartup <Startup>();
server = new TestServer(builder);
//Get individual scopes from testserver to create controllerinstances with scoped services
movieslogic = server.Host.Services.GetService <IMoviesLogic>();
accountlogic = server.Host.Services.GetService <IAccountLogic>();
sessionlogic = new Mock <IUserSession>();
account = new Account
{
Name = "Simon",
Password = "******"
};
//Inject services from testserver into the controllers
moviescontroller = new MoviesController(movieslogic, sessionlogic.Object);
accountcontroller = new AccountController(accountlogic, sessionlogic.Object);
}
public void MovieStore_ListFromDB()
{
var list = new List <Movie>
{
new Movie()
{
MovieId = 1, Title = "Superman"
},
new Movie()
{
MovieId = 2, Title = "Batman"
}
}.AsQueryable();
Mock <MovieStoreDBContext> mockContext = new Mock <MovieStoreDBContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
mockSet.As <IQueryable <Movie> >().Setup(m => m.GetEnumerator()).Returns(list.GetEnumerator());
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
MoviesController controller = new MoviesController(mockContext.Object);
ViewResult result = controller.ListFromDB() as ViewResult;
Assert.IsNotNull(result);
}
public void PostMovie_ShouldReturn_BadRequestStatusCode()
{
//Arrange
var newMovie = nullMovie;
var newMovieId = -1;
mockRepository
.Setup(x => x.AddMovie(newMovie, ref newMovieId))
.Returns(false);
var controller = new MoviesController(mockRepository.Object, cacheStorage.Object, mockUrlHelper.Object);
controller.Request = new HttpRequestMessage()
{
Properties = { { System.Web.Http.Hosting.HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } }
};
//Act
var response = controller.PostMovie(newMovie);
//Assert
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task FilterByInTheaters()
{
var databaseName = CreateTestData();
var mapper = BuildMap();
var context = BuildContext(databaseName);
var controller = new MoviesController(context, mapper, null, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var filterDTO = new FilterMoviesDTO()
{
InTheaters = true,
RecordsPerPage = 10
};
var response = await controller.Filter(filterDTO);
var movies = response.Value;
Assert.AreEqual(1, movies.Count);
Assert.AreEqual("In Theaters Movie", movies[0].Title);
}
public void C_Create_Movie_RedirectsToIndex()
{
// Arrange
var moviesController = new MoviesController(db);
// Act
var actionResult = moviesController.Create(
new Movie
{
Title = "Casablanca",
DateSeen = DateTime.Now.Date,
Genre = "Drama",
Rating = 4
});
;
// Assert
Assert.IsType <RedirectToActionResult>(actionResult);
var redirectToActionResult = actionResult as RedirectToActionResult;
Assert.Equal("Index", redirectToActionResult.ActionName);
}
public void MovieStore_Edit_MovieParam_BadBind()
{
//Arrange
MoviesController controller = new MoviesController();
controller.ModelState.AddModelError("key", "error message");
var list = new List <Movie>
{
new Movie {
MovieId = 1, Title = "Jaws"
},
new Movie {
MovieId = 2, Title = "Despicable Me"
}
}.AsQueryable();
//Act
var result = controller.Edit(list.First()) as ViewResult;
//Assert
Assert.IsNotNull(result);
}
public void MovieStore_Edit_MovieIsNull()
{
var list = new List <Movie>
{
new Movie {
MovieId = 1, Title = "Superman 1"
},
new Movie {
MovieId = 2, Title = "Superman 2"
},
}.AsQueryable();
//2
Mock <MovieStoreDBContext> mockContext = new Mock <MovieStoreDBContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
//3
mockSet.As <IQueryable <Movie> >().Setup(m => m.GetEnumerator()).Returns(list.GetEnumerator());
mockSet.As <IQueryable <Movie> >().Setup(m => m.Provider).Returns(list.Provider);
mockSet.As <IQueryable <Movie> >().Setup(m => m.ElementType).Returns(list.ElementType);
Movie movie = null;
mockSet.Setup(m => m.Find(It.IsAny <Object>())).Returns(movie);
//4
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
//Arrage
MoviesController controller = new MoviesController(mockContext.Object);
//Act
HttpStatusCodeResult result = controller.Edit(0) as HttpStatusCodeResult;
//Assert
Assert.AreEqual(HttpStatusCode.NotFound, (HttpStatusCode)result.StatusCode);
}
public void AllMoviesMethodShouldReturnCorrectData()
{
var repository = new Mock <IRepository <Movie> >();
var movieService = new Mock <IMoviesService>();
var projectiosRepo = new Mock <IProjectionsService>();
movieService.Setup(r => r.AllMovies <Movie>()).Returns(new List <Movie>
{
new Movie
{
Id = 1,
Title = "Titanic",
Country = MegaCinema.Data.Models.Enums.Country.UK,
Rating = MPAARating.G,
Duration = new System.TimeSpan(2, 25, 35),
Genre = GenreType.Adventure,
Language = MegaCinema.Data.Models.Enums.Language.English,
},
new Movie
{
Id = 2,
Title = "Die hard 5",
Language = MegaCinema.Data.Models.Enums.Language.French,
Genre = GenreType.Drama,
Rating = MPAARating.PG13,
Score = 7.5,
},
});
var moviesController = new MoviesController(movieService.Object, projectiosRepo.Object);
var result = moviesController.Details(2);
Assert.IsType <ViewResult>(result);
var viewResult = result as Task <IActionResult>;
Assert.IsType <MovieViewModel>(viewResult);
}
public async Task FilterOrderByTitleAscending()
{
//Preparation
var databaseName = CreateTestsData();
var context = BuildContext(databaseName);
var mapper = BuildMap();
var context2 = BuildContext(databaseName);
var filterMovieDto = new FilterMoviesDto()
{
OrderingField = "title",
AscendingOrder = true,
RecordsPerPage = 10
};
//Testing
var controller = new MoviesController(context, mapper, null, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var response = await controller.Filter(filterMovieDto);
var moviesFromDb = context2.Movies.OrderBy(x => x.Title).ToList();
//Verification
var result = response.Value;
Assert.AreEqual(moviesFromDb.Count, result.Count);
for (int i = 0; i < moviesFromDb.Count; i++)
{
var movieFromController = result[i];
var movieFromDb = moviesFromDb[i];
Assert.AreEqual(movieFromDb.Id, movieFromController.Id);
}
}
public void MovieStore_ListFromDb()
{
// Step 1
var list = new List <Movie>
{
new Movie()
{
MovieId = 1, Title = "Jaws"
},
new Movie()
{
MovieId = 2, Title = "Jurassic Park"
}
}.AsQueryable();
// Step 2
Mock <MovieStoreDbContext> mockContext = new Mock <MovieStoreDbContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
// Step 3
mockSet.As <IOrderedQueryable <Movie> >().Setup(m => m.GetEnumerator()).Returns(list.GetEnumerator);
// Step 4
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
// Arrange
MoviesController controller = new MoviesController(mockContext.Object);
// Act
ViewResult result = controller.ListFromDb() as ViewResult;
List <Movie> resultModel = result.Model as List <Movie>;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual("Jaws", resultModel[0].Title);
Assert.AreEqual("Jurassic Park", resultModel[0].Title);
}
public void DeleteMovie_ValidData()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "DeleteMovie_ValidData")
.Options;
MoviesController controller = new MoviesController(new ApplicationDbContext(options));
var tmp = new Movie
{
Description = "Movie Description",
Genre = Genre.Action,
Rating = 5.4,
Title = "Movie Title",
Year = 2019
};
using (var context = new ApplicationDbContext(options))
{
context.Movies.Add(tmp);
context.SaveChanges();
}
Movie movie;
using (var context = new ApplicationDbContext(options))
{
movie = context.Movies.FirstOrDefault(x => x.Id == 1);
}
controller.Delete(1, movie);
using (var context = new ApplicationDbContext(options))
{
Assert.Equal(0, context.Movies.Count());
}
}
public void MovieStore_DeleteGET_Success()
{
// Step 1
var list = new List <Movie>
{
new Movie()
{
MovieId = 1, Title = "Superman 1"
},
new Movie()
{
MovieId = 2, Title = "Superman 2"
}
}.AsQueryable();
// Step 2
Mock <MovieStoreDbContext> mockContext = new Mock <MovieStoreDbContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
// Step 3
mockSet.As <IQueryable <Movie> >().Setup(m => m.GetEnumerator()).Returns(list.GetEnumerator());
mockSet.As <IQueryable <Movie> >().Setup(m => m.Provider).Returns(list.Provider);
mockSet.As <IQueryable <Movie> >().Setup(m => m.ElementType).Returns(list.ElementType);
mockSet.Setup(m => m.Find(It.IsAny <Object>())).Returns(list.First());
// Step 4
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
// Arrange
MoviesController controller = new MoviesController(mockContext.Object);
// Act
ViewResult result = controller.Delete(1) as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void MovieStore_EditGET_IdIsNull()
{
// Step 1
var list = new List <Movie>
{
new Movie()
{
MovieId = 1, Title = "Superman 1"
},
new Movie()
{
MovieId = 2, Title = "Superman 2"
}
}.AsQueryable();
// Step 2
Mock <MovieStoreDbContext> mockContext = new Mock <MovieStoreDbContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
// Step 3
mockSet.As <IQueryable <Movie> >().Setup(m => m.GetEnumerator()).Returns(list.GetEnumerator());
mockSet.As <IQueryable <Movie> >().Setup(m => m.Provider).Returns(list.Provider);
mockSet.As <IQueryable <Movie> >().Setup(m => m.ElementType).Returns(list.ElementType);
mockSet.Setup(m => m.Find(It.IsAny <Object>())).Returns(list.First());
// Step 4
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
// Arrange
MoviesController controller = new MoviesController(mockContext.Object);
// Act
HttpStatusCodeResult result = controller.Edit((int?)null) as HttpStatusCodeResult;
// Assert
Assert.AreEqual(HttpStatusCode.BadRequest, (HttpStatusCode)result.StatusCode);
}
public void MovieStore_Delete_MovieNull()
{
//Arrange
Mock <MovieStoreDbContext> mockContext = new Mock <MovieStoreDbContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
var list = new List <Movie>
{
new Movie {
MovieId = 1, Title = "Jaws"
},
new Movie {
MovieId = 2, Title = "Despicable Me"
}
}.AsQueryable();
mockSet.As <IQueryable <Movie> >().Setup(m => m.Provider).Returns(list.Provider);
mockSet.As <IQueryable <Movie> >().Setup(m => m.GetEnumerator()).Returns(list.GetEnumerator());
mockSet.As <IQueryable <Movie> >().Setup(m => m.Expression).Returns(list.Expression);
mockSet.As <IQueryable <Movie> >().Setup(m => m.ElementType).Returns(list.ElementType);
Movie movie = null;
mockSet.Setup(m => m.Find(It.IsAny <Object>())).Returns(movie);
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
//Controller needs a mock object for Dependency Injection
MoviesController controller = new MoviesController(mockContext.Object);
//Act
HttpStatusCodeResult result = controller.Delete(1) as HttpStatusCodeResult;
//Assert
Assert.AreEqual(HttpStatusCode.NotFound, (HttpStatusCode)result.StatusCode);
}
public void MovieStore_DeleteConfirmed_Success()
{
//Goal: Query from own list instead of the db
var list = new List <Movie>
{
new Movie()
{
MovieId = 1, Title = "Superman 1"
},
new Movie()
{
MovieId = 2, Title = "Superman 2"
}
}.AsQueryable();
Mock <MovieStoreDbContext> mockContext = new Mock <MovieStoreDbContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
mockSet.As <IQueryable <Movie> >().Setup(m => m.GetEnumerator()).Returns(list.GetEnumerator());
mockSet.As <IQueryable <Movie> >().Setup(m => m.Provider).Returns(list.Provider);
mockSet.As <IQueryable <Movie> >().Setup(m => m.ElementType).Returns(list.ElementType);
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
//Arrange
MoviesController controller = new MoviesController(mockContext.Object);
//Act
RedirectToRouteResult result = controller.DeleteConfirmed(1) as RedirectToRouteResult;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual("Index", result.RouteValues["action"]);
}
public void MovieStore_Details_MovieIsNull()
{
//Goal: query from out own list instead of DB
var list = new List <Movie>
{
new Movie()
{
MovieID = 1, Title = "Superman 1"
},
new Movie()
{
MovieID = 2, Title = "Superman 2"
}
}.AsQueryable();
Mock <MovieStoreDBContext> mockContext = new Mock <MovieStoreDBContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
mockSet.As <IQueryable <Movie> >().Setup(expression: m => m.GetEnumerator()).Returns(list.GetEnumerator());
mockSet.As <IQueryable <Movie> >().Setup(expression: m => m.Provider).Returns(list.Provider);
mockSet.As <IQueryable <Movie> >().Setup(expression: m => m.ElementType).Returns(list.ElementType);
Movie movie = null;
mockSet.Setup(expression: m => m.Find(It.IsAny <Object>())).Returns(movie);
mockContext.Setup(expression: db => db.Movies).Returns(mockSet.Object);
// Arrange
MoviesController controller = new MoviesController(mockContext.Object);
// Act
HttpStatusCodeResult result = controller.Details(id: 0) as HttpStatusCodeResult;
// Assert
Assert.AreEqual(expected: HttpStatusCode.NotFound, actual: (HttpStatusCode)result.StatusCode);
}
public void MovieStore_ListFromDb()
{
// Arrange
Mock <MovieStoreDbContext> mockContext = new Mock <MovieStoreDbContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >(); // Error starts from here
var list = new List <Movie> {
new Movie()
{
MovieId = 1, Title = "Jaws"
},
new Movie()
{
MovieId = 2, Title = "Despicable Me"
}
}.AsQueryable();
mockSet.As <IQueryable <Movie> >().Setup(m => m.Provider).Returns(list.Provider);
mockSet.As <IQueryable <Movie> >().Setup(m => m.Expression).Returns(list.Expression);
mockSet.As <IQueryable <Movie> >().Setup(m => m.ElementType).Returns(list.ElementType);
mockSet.As <IQueryable <Movie> >().Setup(m => m.GetEnumerator()).Returns(list.GetEnumerator());
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
//Controller needs a mock object for Dependency Injection
MoviesController controller = new MoviesController(mockContext.Object);
// Act
ViewResult result = controller.ListFromDb() as ViewResult;
List <Movie> resultModel = result.Model as List <Movie>;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual("Jaws", resultModel[0].Title);
Assert.AreEqual("Despicable Me", resultModel[1].Title);
}
public void MovieStore_EditePostFail()
{
// Goal: Query from out own list instead of the database.
// Set up own list
var list = new List <Movie>
{
new Movie()
{
MovieId = 1, Title = "Superman 1"
},
new Movie()
{
MovieId = 2, Title = "Superman 2"
}
}.AsQueryable();
// Step 2
Mock <MovieStoreDBContext> mockContext = new Mock <MovieStoreDBContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
// Step 3
mockSet.As <IQueryable <Movie> >().Setup(expression: m => m.GetEnumerator()).Returns(list.GetEnumerator());
mockSet.Setup(expression: m => m.Find(It.IsAny <Object>())).Returns(list.First());
// Step 4
mockContext.Setup(expression: db => db.Movies).Returns(mockSet.Object);
// Arrange
MoviesController controller = new MoviesController(mockContext.Object);
// Act
ViewResult result = controller.Edit(id: 0) as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void Delete_Not_Successful_Throw_DbUpdate_Exception()
{
//Arrange
Guid g = new Guid();
MovieDomainModel movieDomainModel = new MovieDomainModel
{
Id = Guid.NewGuid(),
Current = true,
HasOscar = true,
Rating = 2,
Title = "Film1",
Year = 2015
};
string expectedMessage = "Inner exception error message.";
int expectedStatusCode = 400;
Exception exception = new Exception("Inner exception error message.");
DbUpdateException dbUpdateException = new DbUpdateException("Error.", exception);
Task <MovieDomainModel> responseTask = Task.FromResult(movieDomainModel);
_movieService = new Mock <IMovieService>();
_loggerService = new Mock <ILogger <MoviesController> >();
_movieService.Setup(x => x.DeleteMovie(It.IsAny <Guid>())).Throws(dbUpdateException);
MoviesController moviesController = new MoviesController(_loggerService.Object, _movieService.Object);
//Act
var result = moviesController.Delete(g).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var objectResult = ((BadRequestObjectResult)result).Value;
var errorResponse = (ErrorResponseModel)objectResult;
//Assert
Assert.IsNotNull(errorResponse);
Assert.AreEqual(expectedMessage, errorResponse.ErrorMessage);
Assert.AreEqual(expectedStatusCode, ((BadRequestObjectResult)result).StatusCode);
Assert.IsInstanceOfType(result, typeof(BadRequestObjectResult));
}
public void Movie_Delete_MovieIsNull()
{
// Goal: Query from our own list instead of the database.
var list = new List <Movie>
{
new Movie()
{
MovieId = 1, Title = "Superman 1"
},
new Movie()
{
MovieId = 2, Title = "Superman 2"
}
}.AsQueryable();
Mock <MovieStoreDbContext> mockContext = new Mock <MovieStoreDbContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
mockSet.As <IQueryable <Movie> >().Setup(m => m.GetEnumerator()).Returns(list.GetEnumerator());
mockSet.As <IQueryable <Movie> >().Setup(m => m.Provider).Returns(list.Provider);
mockSet.As <IQueryable <Movie> >().Setup(m => m.ElementType).Returns(list.ElementType);
Movie movie = null;
mockSet.Setup(m => m.Find(It.IsAny <Object>())).Returns(movie);
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
// Arrange
MoviesController controller = new MoviesController(mockContext.Object);
// Act
HttpStatusCodeResult result = controller.Delete(0) as HttpStatusCodeResult;
// Assert
Assert.AreEqual(HttpStatusCode.NotFound, (HttpStatusCode)result.StatusCode);
}
public void Init()
{
_movies = new List <Movie>
{
new Movie
{
Id = 1,
Genre = "Action",
Price = (decimal)9.99,
Rating = "R",
ReleaseDate = DateTime.Now,
Title = "Pulp Fiction"
},
new Movie
{
Id = 2,
Genre = "Comedy",
Price = (decimal)9.99,
Rating = "R",
ReleaseDate = DateTime.Now,
Title = "The Big Lebowski"
},
new Movie
{
Id = 3,
Genre = "Action",
Price = (decimal)9.99,
Rating = "PG-13",
ReleaseDate = DateTime.Now,
Title = "Batman Begins"
}
};
_mockService = new Mock <IMovieService>();
_controller = new MoviesController(_mockService.Object);
}
public Index()
{
var mockDb = new Mock<IMovieDbContext>();
_allMovies = new List<Movie>
{
_anActionMovie,
_speed,
_aRomanceMovie,
_romeoAndJuliet,
_aComedyMovie,
_zoolander
}.AsQueryable();
var mockSet = new Mock<DbSet<Movie>>();
mockSet.As<IQueryable<Movie>>().Setup(m => m.Provider).Returns(_allMovies.Provider);
mockSet.As<IQueryable<Movie>>().Setup(m => m.Expression).Returns(_allMovies.Expression);
mockSet.As<IQueryable<Movie>>().Setup(m => m.ElementType).Returns(_allMovies.ElementType);
mockSet.As<IQueryable<Movie>>().Setup(m => m.GetEnumerator()).Returns(_allMovies.GetEnumerator());
mockDb.Setup(x => x.Movies).Returns(mockSet.Object);
_sut = new MoviesController(mockDb.Object);
}
public async Task FilterGender()
{
var nameDB = CreateDataTest();
var mapper = ConfigurationAutoMapper();
var context = BuildContext(nameDB);
var controller = new MoviesController(context, mapper, null, null);
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var genderId = context.Genders.Select(x => x.Id).First();
var filterDTO = new FilterMoviesDTO()
{
GenderId = genderId
};
var response = await controller.Filters(filterDTO);
var movies = response.Value;
Assert.AreEqual(1, movies.Count);
Assert.AreEqual("Película con Género", movies[0].Title);
}
public void MovieStore_Edit_ModelStateValid()
{
#region Arrange
var movies = new List <Movie>()
{
new Movie {
MovieId = 1, Title = "Superman 1", YearRelease = 2019
},
new Movie {
MovieId = 2, Title = "Superman 2", YearRelease = 2007
}
}.AsQueryable();
Mock <MovieStoreDbContext> mockContext = new Mock <MovieStoreDbContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
mockSet.As <IQueryable <Movie> >().Setup(o => o.GetEnumerator())
.Returns(movies.GetEnumerator());
mockContext.Setup(o => o.Movies)
.Returns(mockSet.Object);
MoviesController controller = new MoviesController(mockContext.Object);
// Force ModelState.IsValid to be false
controller.ModelState.AddModelError("key", "errorMessage");
#endregion
#region Act
ViewResult result = controller.Edit(movies.First()) as ViewResult;
#endregion
#region Assert
Assert.IsNotNull(result);
#endregion
}
public void MovieStore_Delete_IdIsNull()
{
#region Arrange
var movies = new List <Movie>()
{
new Movie {
MovieId = 1, Title = "Superman 1"
},
new Movie {
MovieId = 2, Title = "Superman 2"
}
}.AsQueryable();
Mock <MovieStoreDbContext> mockContext = new Mock <MovieStoreDbContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
mockSet.As <IQueryable <Movie> >().Setup(o => o.GetEnumerator())
.Returns(movies.GetEnumerator());
mockSet.Setup(o => o.Find(It.IsAny <object>())).Returns(movies.FirstOrDefault());
mockContext.Setup(o => o.Movies)
.Returns(mockSet.Object);
#endregion
#region Act
MoviesController controller = new MoviesController(mockContext.Object);
HttpStatusCodeResult result = controller.Delete(id: null) as HttpStatusCodeResult;
#endregion
#region Assert
Assert.AreEqual(HttpStatusCode.BadRequest, (HttpStatusCode)result.StatusCode);
#endregion
}
public void MovieStore_Delete_Success()
{
#region Arrange
var movies = new List <Movie>()
{
new Movie {
MovieId = 1, Title = "Superman 1"
},
new Movie {
MovieId = 2, Title = "Superman 2"
}
}.AsQueryable();
Mock <MovieStoreDbContext> mockContext = new Mock <MovieStoreDbContext>();
Mock <DbSet <Movie> > mockSet = new Mock <DbSet <Movie> >();
mockSet.As <IQueryable <Movie> >().Setup(o => o.GetEnumerator())
.Returns(movies.GetEnumerator());
mockSet.Setup(o => o.Find(It.IsAny <object>())).Returns(movies.FirstOrDefault());
mockContext.Setup(o => o.Movies)
.Returns(mockSet.Object);
#endregion
#region Act
MoviesController controller = new MoviesController(mockContext.Object);
ViewResult result = controller.Delete(1) as ViewResult;
#endregion
#region Assert
Assert.IsNotNull(result);
#endregion
}
private void Setup()
{
m_moviesService = new InMemoryMoviesService();
m_controller = new MoviesController(m_moviesService);
}
