public void Delete_NullId_ReturnsBadRequest()
{
// Arrange
// Act
var result = _controller.Delete(null) as HttpStatusCodeResult;
// Assert
Assert.AreEqual(result.StatusCode, HttpStatusCode.BadRequest.GetHashCode());
}
public void DeleteMovie_InvalidData()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "DeleteMovie_InvalidData")
.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 = null;
controller.Delete(2, movie);
using (var context = new ApplicationDbContext(options))
{
Assert.NotEqual(0, context.Movies.Count());
}
}
public void MovieStore_Delete_IdIsNull()
{
//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);
mockSet.Setup(m => m.Find(It.IsAny <Object>())).Returns(list.First());
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
Nullable <int> id = null;
//Arrange
MoviesController controller = new MoviesController(mockContext.Object);
//Act
HttpStatusCodeResult result = controller.Delete(id) as HttpStatusCodeResult;
//Assert
Assert.AreEqual(HttpStatusCode.BadRequest, (HttpStatusCode)result.StatusCode);
}
public void MovieStore_Delete_Success()
{
//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);
mockSet.Setup(m => m.Find(It.IsAny <Object>())).Returns(list.First());
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.Delete(1) as ViewResult;
//Assert
Assert.IsNotNull(result);
}
public void MovieStore_Delete_TestPost()
{
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);
mockSet.Setup(m => m.Find(It.IsAny <Object>())).Returns(list.First());
//4
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
//Arrage
MoviesController controller = new MoviesController(mockContext.Object);
//Act
ViewResult result = controller.Delete(0) as ViewResult;
//Assert
Assert.IsNotNull(result);
}
public void Movie_Delete_Success()
{
// 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);
mockSet.Setup(m => m.Find(It.IsAny <Object>())).Returns(list.First());
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 Delete_Successful_Return_Accepted()
{
int expectedStatusCode = 202;
MovieDomainModel movieDomainModel = new MovieDomainModel
{
Id = Guid.NewGuid(),
Current = true,
HasOscar = true,
Rating = 2,
Title = "Film1",
Year = 2015
};
Task <MovieDomainModel> responseTask = Task.FromResult(movieDomainModel);
_movieService = new Mock <IMovieService>();
_loggerService = new Mock <ILogger <MoviesController> >();
_movieService.Setup(x => x.DeleteMovie(It.IsAny <Guid>())).Returns(responseTask);
MoviesController moviesController = new MoviesController(_loggerService.Object, _movieService.Object);
//Act
var result = moviesController.Delete(movieDomainModel.Id).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var objectResult = ((AcceptedResult)result).Value;
var movieDomainModelResult = (MovieDomainModel)objectResult;
//Assert
Assert.IsNotNull(movieDomainModel);
Assert.IsInstanceOfType(result, typeof(AcceptedResult));
Assert.AreEqual(expectedStatusCode, ((AcceptedResult)result).StatusCode);
}
public void Delete_Not_Successful_Return_BadRequest()
{
//Arrange
int expectedStatusCode = 400;
string expectedMessage = Messages.MOVIE_DOES_NOT_EXIST;
Guid g = new Guid();
MovieDomainModel movieDomainModel = null;
Task <MovieDomainModel> responseTask = Task.FromResult(movieDomainModel);
_movieService = new Mock <IMovieService>();
_loggerService = new Mock <ILogger <MoviesController> >();
_movieService.Setup(x => x.DeleteMovie(It.IsAny <Guid>())).Returns(responseTask);
MoviesController moviesController = new MoviesController(_loggerService.Object, _movieService.Object);
//Act
var result = moviesController.Delete(g).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultList = ((BadRequestObjectResult)result).Value;
var errorResponse = (ErrorResponseModel)resultList;
Assert.IsNotNull(errorResponse);
Assert.IsInstanceOfType(result, typeof(BadRequestObjectResult));
Assert.AreEqual(expectedStatusCode, ((BadRequestObjectResult)result).StatusCode);
Assert.AreEqual(expectedMessage, errorResponse.ErrorMessage);
}
public void MoviesControllerDelete()
{
var moviesController = new MoviesController(null, null);
var result = moviesController.Delete(null);
Assert.IsNotNull(result);
}
public void DeleteMovieTest()
{
var repository = MockRepository(r => r.DeleteMovie(It.IsAny <int>()));
var actorsController = new MoviesController(repository.Object);
actorsController.Delete(It.IsAny <int>());
repository.Verify(r => r.DeleteMovie(It.IsAny <int>()));
}
public void MovieStore_Delete_NoId()
{
MoviesController controller = new MoviesController();
//Act
int?movieId = null;
HttpStatusCodeResult result = controller.Delete(movieId) as HttpStatusCodeResult;
//Assert
Assert.AreEqual(HttpStatusCode.BadRequest, (HttpStatusCode)result.StatusCode);
}
public void DeleteForInVaildId()
{
var mockIMovies = new Mock <IWatchListService>();
mockIMovies.Setup(x => x.Delete(It.IsAny <int>())).Returns(false);
var movieController = new MoviesController(mockIMovies.Object);
// Act
var result = movieController.Delete(4) as NotFoundObjectResult;
//Assert
Assert.NotNull(result);
Assert.Equal(404, result.StatusCode);
}
public void MockDeleteFromMovie()
{
var movie = new Movie();
var service = new Mock <IMovieRepository>();
service.Setup(x => x.GetMovieById(1)).Returns(movie);
_moviesController = new MoviesController(service.Object);
var expected = movie;
var result = _moviesController.Delete(1);
var actual = ((ViewResult)result).Model as Movie;
Assert.AreEqual(actual, expected);
}
public void Delete_with_invalid_Id_returns_NotFound()
{
// Arrange
var mockService = new Mock <IMovieService>();
mockService.Setup(service => service.MovieExists(It.IsAny <int>())).Returns(false);
var sut = new MoviesController(mockService.Object);
// Act
var result = sut.Delete(0);
// Assert
Assert.IsType <NotFoundResult>(result);
}
public void DeleteMovieTest()
{
var mockIMovies = new Mock <IWatchListService>();
mockIMovies.Setup(x => x.Delete(It.IsAny <int>())).Returns(true);
var movieController = new MoviesController(mockIMovies.Object);
// Act
var result = movieController.Delete(2) as OkObjectResult;
var actualResult = (bool)result.Value;
//Assert
Assert.NotNull(result);
Assert.Equal(200, result.StatusCode);
Assert.True(actualResult);
}
public async Task DeleteMovie_WhenCalledWithInvalidId_ReturnsBadRequest()
{
getMoviesHelper getMoviesHelper = new getMoviesHelper();
List <TblMovie> movieList = getMoviesHelper.getMovieFromList();
_mockMovieRepository = new Mock <IMovieRepository>();
_mockMovieMapper = new Mock <IMapper>();
_mockMovieRepository.Setup(repo => repo.Delete(It.IsAny <TblMovie>()));
_mockMovieRepository.Setup(repo => repo.GetMovie(It.IsAny <int>())).ReturnsAsync(getMoviesHelper.movieById(15));
_moviesController = new MoviesController(_mockMovieRepository.Object, _mockMovieMapper.Object);
var tblMovie = await _moviesController.Delete(3);
var okResult = tblMovie as OkObjectResult;
Assert.IsInstanceOf <BadRequestObjectResult>(tblMovie);
}
public void MovieStore_Delete_MovieIsNull()
{
// Goal: Query from our own list instead of database
//step 1:
var list = new List <Movie>
{
new Movie {
MovieId = 1, Title = "Animal Crossing XL"
},
new Movie {
MovieId = 2, Title = "Super Mario Bros"
},
}.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(expression: m => m.Find(It.IsAny <Object>())).Returns(list.First());
//this is required for this method to function properly, will not simply take id number
Movie movie = null;
mockSet.Setup(expression: m => m.Find(It.IsAny <Object>())).Returns(movie);
//step 4
mockContext.Setup(expression: db => db.Movies).Returns(mockSet.Object);
//arrange
MoviesController controller = new MoviesController(mockContext.Object);
//act
HttpStatusCodeResult result = controller.Delete(id: 10) as HttpStatusCodeResult;
//assert
Assert.IsNotNull(result);
Assert.AreEqual(expected: HttpStatusCode.NotFound, actual: (HttpStatusCode)result.StatusCode);
}
public void Movies_Controller_Should_Remove_Sucessfully()
{
// Arrange
var isUpdated = true;
int idToRemove = 1;
_movieServiceMock.Setup(c => c.Remove(It.IsAny <long>())).Returns(isUpdated);
// Action
IHttpActionResult callback = _moviesController.Delete(idToRemove);
// Assert
var httpResponse = callback.Should().BeOfType <OkNegotiatedContentResult <bool> >().Subject;
_movieServiceMock.Verify(s => s.Remove(idToRemove), Times.Once);
httpResponse.Content.Should().BeTrue();
}
public void MovieStore_Delete_Success()
{
// Goal: Query from our own list instead of database
//step 1:
var list = new List <Movie>
{
new Movie {
MovieId = 1, Title = "Animal Crossing XL"
},
new Movie {
MovieId = 2, Title = "Super Mario Bros"
},
}.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(expression: m => m.Find(It.IsAny <Object>())).Returns(list.First());
//this is required for this method to function properly, will not simply take id number
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.Delete(id: 1) as ViewResult;
//assert
Assert.IsNotNull(result);
//test that it is recieving correct value?
}
public void Delete_with_valid_Id_calls_DeleteMovie_and_returns_NoContent()
{
// Arrange
var mockService = new Mock <IMovieService>();
mockService.Setup(service => service.MovieExists(It.IsAny <int>())).Returns(true);
var sut = new MoviesController(mockService.Object);
// Act
var result = sut.Delete(1);
// Assert
mockService.Verify(service =>
service.DeleteMovie(It.IsAny <int>()), Times.Once);
Assert.IsType <NoContentResult>(result);
}
public async Task DeleteMovie_WhenCalled_DeleteTheMovieFromDb()
{
getMoviesHelper getMoviesHelper = new getMoviesHelper();
List <TblMovie> movieList = getMoviesHelper.getMovieFromList();
_mockMovieRepository = new Mock <IMovieRepository>();
_mockMovieMapper = new Mock <IMapper>();
_mockMovieRepository.Setup(repo => repo.Delete(It.IsAny <TblMovie>()));
_mockMovieRepository.Setup(repo => repo.GetMovie(It.IsAny <int>())).ReturnsAsync(getMoviesHelper.movieById(3));
_moviesController = new MoviesController(_mockMovieRepository.Object, _mockMovieMapper.Object);
var tblMovie = await _moviesController.Delete(3);
var okResult = tblMovie as OkObjectResult;
Assert.AreEqual(200, okResult.StatusCode);
Assert.NotNull(tblMovie);
Assert.AreEqual("object deleted", okResult.Value);
}
public void MovieStore_Delete_MovieIsNull()
{
// Goal: Query from our own list instead of the database.
// 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);
Movie movie = null;
mockSet.Setup(m => m.Find(It.IsAny <Object>())).Returns(movie);
// Step 4
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 Movies_Delete_Get()
{
// Arrange
Source source = GetTestSource();
var movies = GetTestMovieSet(source);
var db = new Mock <IPersonalInformationManagerContext>();
db.Setup(e => e.Movies).Returns(movies);
db.Setup(e => e.Movies.Find(It.IsAny <int>())).Returns(GetTestMovie(source));
MoviesController controller = new MoviesController(db.Object);
// Act
ViewResult result = controller.Delete(1) as ViewResult;
var model = result.Model as PersonalInformationManager.Models.Movie;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(MOVIE_TITLE, model.Title);
}
public void DeleteReturnsMovieDoesNotExistResponse()
{
// 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 message = "The movie does not exist";
movieRepositoryMock.Setup(repo => repo.Get(movie.Id)).Returns(movie);
// Act
var result = (ObjectResult)controller.Delete(2);
// Assert
Assert.AreEqual(message, result.Value, "Delete movie is not validating non existing movie");
}
public void MovieStore_Delete_IdIsNull()
{
// Goal: query from our own list instead of the database.
// Step 1
var list = new List <Movie>
{
new Movie()
{
MovieId = 1, Title = "Rambo II"
},
new Movie()
{
MovieId = 2, Title = "Rambo III"
}
}.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.As <IQueryable <Movie> >().Setup(expression: m => m.Provider).Returns(list.Provider);
mockSet.As <IQueryable <Movie> >().Setup(expression: m => m.ElementType).Returns(list.ElementType);
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
int?intNullTest = null;
HttpStatusCodeResult result = controller.Delete(intNullTest) as HttpStatusCodeResult;
// Assert
Assert.AreEqual(expected: HttpStatusCode.BadRequest, actual: (HttpStatusCode)result.StatusCode);
}
public void MovieStore_Delete_NullId()
{
var list = new List <Movie>
{
new Movie {
MovieId = 1, Title = "Animal Crossing XL"
},
new Movie {
MovieId = 2, Title = "Super Mario Bros"
},
}.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(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
HttpStatusCodeResult result = controller.Delete(id: null) as HttpStatusCodeResult;
//assert
Assert.IsNotNull(result);
Assert.AreEqual(expected: HttpStatusCode.BadRequest, actual: (HttpStatusCode)result.StatusCode);
}
public void MovieStore_Delete_IdNotFound()
{
#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());
Movie movie = null;
mockSet.Setup(o => o.Find(It.IsAny <object>())).Returns(movie);
mockContext.Setup(o => o.Movies)
.Returns(mockSet.Object);
#endregion
#region Act
MoviesController controller = new MoviesController(mockContext.Object);
HttpStatusCodeResult result = controller.Delete(Int32.MaxValue) as HttpStatusCodeResult;
#endregion
#region Assert
Assert.AreEqual(HttpStatusCode.NotFound, (HttpStatusCode)result.StatusCode);
#endregion
}
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 MovieStore_Delete_TestView()
{
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());
mockSet.Setup(m => m.Find(It.IsAny <object>())).Returns(list.First());
mockContext.Setup(db => db.Movies).Returns(mockSet.Object);
MoviesController controller = new MoviesController(mockContext.Object);
ViewResult result = controller.Delete(1) as ViewResult;
Assert.IsNotNull(result);
}
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
}