public void DeleteGame_ExpectOne()
{
int id = 1;
int result = _controller.Delete(id);
Assert.Equal(1, result);
}
public async Task Delete_WhenIdIsNotNullAndGameIsFound_ShouldReturnNotFound()
{
// Arrange
var gamesIndexViewModel = A.Fake <IGamesIndexViewModel>();
var gamesDetailsViewModel = A.Fake <IGamesDetailsViewModel>();
var gameService = A.Fake <IGameService>();
var gameRepository = A.Fake <IGameRepository>();
Game?game = new Game();
A.CallTo(() => gameRepository.GetGameAsync(A <int> .Ignored)).Returns(game);
var teamRepository = A.Fake <ITeamRepository>();
var seasonRepository = A.Fake <ISeasonRepository>();
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new GamesController(gamesIndexViewModel, gamesDetailsViewModel, gameService,
gameRepository, teamRepository, seasonRepository, sharedRepository);
int?id = 1;
// Act
var result = await testController.Delete(id);
// Assert
A.CallTo(() => gameRepository.GetGameAsync(id.Value)).MustHaveHappenedOnceExactly();
result.ShouldBeOfType <ViewResult>();
((ViewResult)result).Model.ShouldBe(game);
}
public void Delete_IdExists_ReturnsOkResult()
{
var controller = new GamesController(new FakeGamesRepository(), new FakeLogger());
var result = controller.Delete("existing");
Assert.IsType <OkResult>(result);
}
public void Delete_IdDoesNotExists_ReturnsNotFoundResult()
{
var controller = new GamesController(new FakeGamesRepository(), new FakeLogger());
var result = controller.Delete("some-id");
Assert.IsType <NotFoundResult>(result);
}
public void GamesControllerDelete()
{
var gamesController = new GamesController(null);
var result = gamesController.Delete(null);
Assert.IsNotNull(result);
}
public void Delete_IdIsNull_ReturnsNotFoundResult()
{
var controller = new GamesController(new FakeGamesRepository(), new FakeLogger());
var result = controller.Delete(null);
Assert.IsType <NotFoundResult>(result);
}
public async Task Delete_CorrectValues_Returns200()
{
//arrange
BLGame game = new BLGame {
Name = "Name", Description = "Description", PublisherId = 1
};
_gameService.Setup(cs => cs.DeleteAsync(1)).Returns(Task.FromResult(true)).Verifiable();
_gameService.Setup(cs => cs.GetAsync(1)).Returns(Task.FromResult(game));
//act
var result = await _gamesController.Delete(1);
//assert
_gameService.Verify(cs => cs.DeleteAsync(1));
_gameService.Verify(cs => cs.GetAsync(1));
Assert.AreEqual(result.GetType(), typeof(OkResult));
}
public void DeleteTest()
{
// Arrange
GamesController controller = new GamesController();
// Act
var result = controller.Delete(0);
// Assert
Assert.IsNotNull(result);
}
public async void CrudFriend()
{
//CREATE
var gamePost = new Game {
Title = "Game Test",
Description = "Description Test",
Genre = "Genre Test"
};
var postResult = await gamesController.Post(gamePost);
var okPostResult = (OkObjectResult)postResult.Result;
var game = okPostResult.Value as Game;
Assert.NotEmpty(game.Id);
//UPDATE
gamePost.Title = "Test2";
var putResult = await gamesController.Put(game.Id, gamePost);
var okPutResult = (OkObjectResult)putResult.Result;
game = okPutResult.Value as Game;
Assert.Equal("Test2", game.Title);
//LIST
var getLResult = await gamesController.Get();
var okGetLResult = (ObjectResult)getLResult.Result;
var lgame = okGetLResult.Value as IEnumerable <Game>;
Assert.NotEmpty(lgame.Where(a => a.Title == "Test2"));
//GET
var getResult = await gamesController.Get(game.Id);
var okGetResult = (ObjectResult)getResult.Result;
game = okGetResult.Value as Game;
Assert.Equal("Test2", game.Title);
//REMOVE
var deleteResult = await gamesController.Delete(game.Id);
Assert.IsType <OkResult>(deleteResult);
}
public void DeleteGet_ExceptionCaught_RethrowsException()
{
// Arrange
var controller = new GamesController(_service, _sharedService);
int?id = 1;
A.CallTo(() => _service.FindEntityAsync(A <int> .Ignored, null)).Throws <Exception>();
// Act
// Assert
Assert.ThrowsAsync <Exception>(async() => await controller.Delete(id));
}
public async Task Delete_IdAsParam_ReturnConfirmDeleteView()
{
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>();
optionsBuilder.UseInMemoryDatabase("test");
var _dbContext = new ApplicationDbContext(optionsBuilder.Options);
var c = new GamesController(_dbContext, _hostingEnv);
var result = await c.Delete(1);
Assert.IsInstanceOfType(result, typeof(ViewResult));
}
public async Task DeleteGet_IdNull_ReturnsBadHttpRequest()
{
// Arrange
var controller = new GamesController(_service, _sharedService);
int?id = null;
// Act
var result = await controller.Delete(id);
// Assert
Assert.IsInstanceOf <HttpStatusCodeResult>(result);
Assert.AreEqual((int)HttpStatusCode.BadRequest, (result as HttpStatusCodeResult).StatusCode);
}
public async Task IsAbleToRemoveGameAsync()
{
await InsertGame();
var count = GetGamesList().Count;
var existingGame = GetGamesList()[0];
var deleteResult = _sut.Delete(existingGame.Id);
Assert.AreEqual(count, GetGamesList().Count);
_repositoryStub.Delete(existingGame);
Assert.AreEqual(count - 1, GetGamesList().Count);
}
public async void GamesController_Delete_Game()
{
//Arrange
var mockGame = new Game()
{
GameId = 1
};
var mockGameRepository = new MockGameRepository().MockGetGameByID(mockGame);
var controller = new GamesController(mockGameRepository.Object);
//act
var result = await controller.Delete(1);
//Assert
Assert.IsAssignableFrom <ActionResult <Game> >(result);
mockGameRepository.VerifyGetGameByID(Times.Once());
}
public async Task Quando_Requisitar_Delete_BadRequest()
{
// Arrange
var serviceMock = new Mock <IGameService>();
var id = Guid.NewGuid();
serviceMock.Setup(m => m.Delete(It.IsAny <Guid>())).ReturnsAsync(false);
_controller = new GamesController(serviceMock.Object);
_controller.ModelState.AddModelError("Id", "Id não informado.");
// Act
var result = await _controller.Delete(id);
// Assert
Assert.True(result is BadRequestObjectResult);
Assert.False(_controller.ModelState.IsValid);
}
public async Task DeleteGet_IdNotNullAndGameViewModelNull_ReturnsHttpNotFound()
{
// Arrange
var controller = new GamesController(_service, _sharedService);
int?id = 1;
GameViewModel gameViewModel = null;
A.CallTo(() => _service.FindEntityAsync(A <int> .Ignored, null)).Returns(gameViewModel);
// Act
var result = await controller.Delete(id);
// Assert
A.CallTo(() => _service.FindEntityAsync((int)id, null)).MustHaveHappenedOnceExactly();
Assert.IsInstanceOf <HttpNotFoundResult>(result);
}
public void Delete_DeleteGame_ServiceMethodWereCalled()
{
//Arrange
Guid guid1 = Guid.NewGuid();
string GameName1 = "Name1";
GameViewModel Game = new GameViewModel {
GameGuid = guid1, Name = GameName1
};
//Service.Setup(x => x.GetGames()).Returns(Game);
GamesController controller = new GamesController(Service.Object, Mapper);
//Act
var result = controller.Delete(guid1) as ViewResult;
//Assert
Service.Verify(x => x.DeleteGame(guid1));
}
public async Task Quando_Requisitar_Delete()
{
// Arrange
var serviceMock = new Mock <IGameService>();
var id = Guid.NewGuid();
serviceMock.Setup(m => m.Delete(It.IsAny <Guid>())).ReturnsAsync(true);
_controller = new GamesController(serviceMock.Object);
// Act
var result = await _controller.Delete(id);
// Assert
Assert.NotNull(result);
Assert.True(result is OkObjectResult);
var resultType = Assert.IsType <OkObjectResult>(result);
Assert.Equal(200, resultType.StatusCode);
}
public async Task Delete_WhenIdIsNull_ShouldReturnNotFound()
{
// Arrange
var gamesIndexViewModel = A.Fake <IGamesIndexViewModel>();
var gamesDetailsViewModel = A.Fake <IGamesDetailsViewModel>();
var gameService = A.Fake <IGameService>();
var gameRepository = A.Fake <IGameRepository>();
var teamRepository = A.Fake <ITeamRepository>();
var seasonRepository = A.Fake <ISeasonRepository>();
var sharedRepository = A.Fake <ISharedRepository>();
var testController = new GamesController(gamesIndexViewModel, gamesDetailsViewModel, gameService,
gameRepository, teamRepository, seasonRepository, sharedRepository);
int?id = null;
// Act
var result = await testController.Delete(id);
// Assert
result.ShouldBeOfType <NotFoundResult>();
}
