public async Task DeleteGame_WhenCurrentGameIsNotFound_ShouldReturnNotFoundResult()
{
// Arrange
var gameRepository = A.Fake <IGameRepository>();
Game?game = null;
A.CallTo(() => gameRepository.GetGameAsync(A <int> .Ignored)).Returns(game);
var sharedRepository = A.Fake <ISharedRepository>();
var mapper = A.Fake <IMapper>();
var linkGenerator = A.Fake <LinkGenerator>();
var gameService = A.Fake <IGameService>();
var testController =
new GamesController(gameRepository, sharedRepository, mapper, linkGenerator, gameService);
int id = 1;
// Act
var result = await testController.DeleteGame(id);
// Assert
A.CallTo(() => gameRepository.GetGameAsync(id)).MustHaveHappenedOnceExactly();
result.Result.ShouldBeOfType <NotFoundObjectResult>();
((NotFoundObjectResult)result.Result).Value.ShouldBe($"Could not find game with ID of {id}");
}
public async Task DeleteGame_WhenCurrentGameIsFoundAndNotDeleted_ShouldReturnBadRequest()
{
// Arrange
var gameRepository = A.Fake <IGameRepository>();
Game?game = new Game();
A.CallTo(() => gameRepository.GetGameAsync(A <int> .Ignored)).Returns(game);
var sharedRepository = A.Fake <ISharedRepository>();
A.CallTo(() => sharedRepository.SaveChangesAsync()).Returns(0);
var mapper = A.Fake <IMapper>();
var linkGenerator = A.Fake <LinkGenerator>();
var gameService = A.Fake <IGameService>();
var testController =
new GamesController(gameRepository, sharedRepository, mapper, linkGenerator, gameService);
int id = 1;
// Act
var result = await testController.DeleteGame(id);
// Assert
A.CallTo(() => gameRepository.GetGameAsync(id)).MustHaveHappenedOnceExactly();
A.CallTo(() => gameService.DeleteGameAsync(id)).MustHaveHappenedOnceExactly();
A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedOnceExactly();
result.Result.ShouldBeOfType <BadRequestResult>();
}
public async Task RateVideoGame_RatingHigherThenAllowedValueAndGameId_ReturnsNotFoundResult()
{
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>();
optionsBuilder.UseInMemoryDatabase("test");
var _dbContext = new ApplicationDbContext(optionsBuilder.Options);
var c = new GamesController(_dbContext, _hostingEnv);
Games game = new Games();
game.Id = 1;
game.Title = "test";
game.Genre = "rock";
game.Description = "loud stuff";
game.Publisher = "da";
game.Developer = "EA";
game.ESRB_Ratings = "lalaalaa";
game.ReleaseDate = new System.DateTime();
game.Price = 2;
game.GameLink = "dsa";
game.Available = "dsadas";
game.EntryDate = new System.DateTime();
await c.Create(game);
var sf = new StoreFrontController(_dbContext);
var result = await sf.RateGame(9, 2);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task GetGame_WhenGameIsNotNull_ShouldReturnGameModelOfDesiredGame()
{
// Arrange
var gameRepository = A.Fake <IGameRepository>();
Game?game = new Game();
A.CallTo(() => gameRepository.GetGameAsync(A <int> .Ignored)).Returns(game);
var sharedRepository = A.Fake <ISharedRepository>();
var mapper = A.Fake <IMapper>();
GameModel?gameModel = new GameModel();
A.CallTo(() => mapper.Map <GameModel>(A <Game> .Ignored)).Returns(gameModel);
var linkGenerator = A.Fake <LinkGenerator>();
var gameService = A.Fake <IGameService>();
var testController =
new GamesController(gameRepository, sharedRepository, mapper, linkGenerator, gameService);
int id = 1;
// Act
var result = await testController.GetGame(id);
// Assert
A.CallTo(() => gameRepository.GetGameAsync(id)).MustHaveHappenedOnceExactly();
A.CallTo(() => mapper.Map <GameModel>(game)).MustHaveHappenedOnceExactly();
result.Value.ShouldBeOfType <GameModel>();
}
public async Task PostGame_CorrectGameWithCorrectValuesExceptNegativeDeveloperIdAndIdNotSet_BadRequestResult()
{
// Arrange
InitializeInmemoryDatabase(out DbContextOptions <GameReviewsContext> options, GetFakeList());
Game gameToCreate = new Game()
{
Name = "NewGame",
Description = "NewDescription",
PublisherId = 2,
DeveloperId = -1,
AnnouncementDate = DateTime.Parse("10-05-2015"),
ReleaseDate = DateTime.Parse("27-12-2018")
};
// Act
using (var context = new GameReviewsContext(options))
{
GamesController gamesController = new GamesController(context);
var result = (await gamesController.PostGame(gameToCreate)).Result;
// Assert
Assert.IsType <BadRequestResult>(result);
}
}
internal void Start()
{
var games = new GamesController();
var loop = true;
while (loop)
{
UI.PrintMainMenu();
var input = Console.ReadKey(true).Key;
switch (input)
{
case ConsoleKey.D1:
games.CreateGame();
break;
case ConsoleKey.D2:
games.RemoveGame();
break;
case ConsoleKey.D3:
games.PrintGameList();
break;
case ConsoleKey.D4:
games.EditGame();
break;
case ConsoleKey.D5:
loop = false;
break;
}
}
}
public async Task PutGame_ExistingIdCorrectGameWithPublisherIdChangedToNegative_NoContentResultPublisherIdDoesntChanged()
{
// Arrange
const int gameId = 3, publisherId = -1;
InitializeInmemoryDatabase(out DbContextOptions <GameReviewsContext> options, GetFakeList());
Game gameToUpdate = GetFakeList().Where(d => d.ID == gameId).FirstOrDefault(),
// Should use ICopyable interface here
expectedGame = GetFakeList().Where(d => d.ID == gameId).FirstOrDefault();
// Act
using (var context = new GameReviewsContext(options))
{
gameToUpdate.PublisherId = publisherId;
GamesController gamesController = new GamesController(context);
var result = (await gamesController.PutGame(gameId, gameToUpdate));
Game actualGame = await context.Games.Where(d => d.ID == gameId).FirstOrDefaultAsync();
// Assert
Assert.IsType <BadRequestResult>(result);
}
}
public void GetAllShouldWorkCorrectly()
{
var fakeGamesService = A.Fake <IGamesService>();
var fakeGenresService = A.Fake <IGenresService>();
var fakeLanguagesService = A.Fake <ILanguagesService>();
var fakePublishersService = A.Fake <IPublishersService>();
var fakeTagsService = A.Fake <ITagsService>();
var fakeEnvironment = A.Fake <IWebHostEnvironment>();
var fakeWishlistService = A.Fake <IWishlistService>();
var fakeOrdersService = A.Fake <IOrdersService>();
var fakeCartService = A.Fake <ICartService>();
var fakeCache = A.Fake <IMemoryCache>();
A.CallTo(() => fakeGamesService.All <GameInListViewModel>(1, 16))
.Returns(A.CollectionOfFake <GameInListViewModel>(20));
var gamesController = new GamesController(
fakeGamesService,
fakeGenresService,
fakeLanguagesService,
fakeTagsService,
fakePublishersService,
fakeEnvironment,
fakeWishlistService,
fakeOrdersService,
fakeCartService,
fakeCache);
var result = gamesController.All();
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <GamesListViewModel>(viewResult.Model);
Assert.Equal(20, model.Games.Count());
}
public void GetAllGames_GetAllIsCalledAndAndJsonResultIsCorrect()
{
// Arrange
var expectedGames = new List <GameDataModel>
{
new GameDataModel {
Id = 1, Name = "BBB", Key = "k1"
},
new GameDataModel {
Id = 2, Name = "ZZZ", Key = "k2"
},
new GameDataModel {
Id = 3, Name = "AAA", Key = "k3"
},
};
var mock = new Mock <IGameRepository>();
mock.Setup(m => m.GetAll()).Returns(expectedGames);
var controller = new GamesController(mock.Object);
// Act
var result = controller.GetAllGames() as JsonResult;
// Assert
Assert.IsNotNull(result);
mock.Verify(a => a.GetAll(), Times.Once);
Assert.AreEqual(expectedGames, result.Data);
}
public async Task PutGame_ExistingIdCorrectGameWithDeveloperIdChangedToExisting_NoContentResultDeveloperIdChanged()
{
// Arrange
const int gameId = 3, developerId = 7;
InitializeInmemoryDatabase(out DbContextOptions <GameReviewsContext> options, GetFakeList());
Game gameToUpdate = GetFakeList().Where(d => d.ID == gameId).FirstOrDefault(),
// Should use ICopyable interface here
expectedGame = GetFakeList().Where(d => d.ID == gameId).FirstOrDefault();
// Act
using (var context = new GameReviewsContext(options))
{
gameToUpdate.DeveloperId = developerId;
expectedGame.DeveloperId = developerId;
GamesController gamesController = new GamesController(context);
var result = (await gamesController.PutGame(gameId, gameToUpdate));
Game actualGame = await context.Games.Where(d => d.ID == gameId).FirstOrDefaultAsync();
// Assert
Assert.True(AreEqual(expectedGame, actualGame));
Assert.IsType <NoContentResult>(result);
}
}
public void Remove_RemoveForRepositoryIsCalledAndRedirectWorks()
{
//ToDo it doesn't works! bacause of Helpers in controller
// Arrange
var mock = new Mock <IGameRepository>();
////var request = new Mock<HttpRequestBase>();
////var context = new Mock<HttpContextBase>();
////context.SetupGet(x => x.Request).Returns(request.Object); //Set up request base for the httpcontext
//context
int gameId = 1;
var expectedResult = new JsonResult();//Url.Action("Index", "Games"
var controller = new GamesController(mock.Object);
////controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);
// Act
var result = controller.Remove(gameId) as JsonResult;
// Assert
Assert.IsNotNull(result);
mock.Verify(a => a.Remove(gameId), Times.Once);
//Assert.AreEqual(expectedResult, result.Data);
}
//[Test]
public void GetGameFromGameController()
{
GamesController controller = new GamesController();
var result = controller.Details(1) as ViewResult;
Assert.AreEqual("Details", result.ViewName);
}
public void GamesControllerReturnsCorrectView()
{
var answerSheet = new AnswerSheet {
Id = 1, UserId = "1", UserName = "******"
};
var data = new List <AnswerSheet> {
answerSheet
}.AsQueryable();
var mockSet = new Mock <DbSet <AnswerSheet> >();
mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock <Brainzzler_DBContext>();
mockContext.Setup(set => set.AnswerSheet).Returns(mockSet.Object);
var mockIdenityProvider = new Mock <IUserIdenityProvider>();
mockIdenityProvider.Setup(s => s.GetCurrentUserId()).Returns("2");
//Act
var service = new GamesController(mockContext.Object, mockIdenityProvider.Object);
var gamesResult = service.Index() as ViewResult;
Assert.AreEqual("Index", gamesResult.ViewName);
}
public void GamesControllerReturns0pointsWhenNull()
{
var answerSheet = new AnswerSheet {
Id = 1, UserId = "1", UserName = "******"
};
var data = new List <AnswerSheet> {
answerSheet
}.AsQueryable();
var mockSet = new Mock <DbSet <AnswerSheet> >();
mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <AnswerSheet> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock <Brainzzler_DBContext>();
mockContext.Setup(set => set.AnswerSheet).Returns(mockSet.Object);
var mockIdenityProvider = new Mock <IUserIdenityProvider>();
mockIdenityProvider.Setup(s => s.GetCurrentUserId()).Returns("2");
//Act
var service = new GamesController(mockContext.Object, mockIdenityProvider.Object);
var points = service.Points();
//Assert
Assert.AreEqual(0, points);
}
public async Task PostGame_CorrectGameWithCorrectValuesAndZeroIdSetted_CreatedAtActionResultWithGeneratedId()
{
// Arrange
const int idToSet = 0;
InitializeInmemoryDatabase(out DbContextOptions <GameReviewsContext> options, GetFakeList());
Game gameToCreate = new Game()
{
Name = "NewGame",
Description = "NewDescription",
PublisherId = 1,
DeveloperId = 2,
AnnouncementDate = DateTime.Parse("10-05-2015"),
ReleaseDate = DateTime.Parse("27-12-2018"),
ID = idToSet
};
// Act
using (var context = new GameReviewsContext(options))
{
GamesController gamesController = new GamesController(context);
var result = (await gamesController.PostGame(gameToCreate)).Result;
// Assert
Assert.True(gameToCreate.ID != idToSet);
Assert.IsType <CreatedAtActionResult>(result);
}
}
public async Task GetGame_WhenExceptionIsCaught_ShouldReturnInternalServerError()
{
// Arrange
var gameRepository = A.Fake <IGameRepository>();
Game?game = new Game();
A.CallTo(() => gameRepository.GetGameAsync(A <int> .Ignored)).Throws <Exception>();
var sharedRepository = A.Fake <ISharedRepository>();
var mapper = A.Fake <IMapper>();
GameModel?gameModel = new GameModel();
A.CallTo(() => mapper.Map <GameModel>(A <Game> .Ignored)).Returns(gameModel);
var linkGenerator = A.Fake <LinkGenerator>();
var gameService = A.Fake <IGameService>();
var testController =
new GamesController(gameRepository, sharedRepository, mapper, linkGenerator, gameService);
int id = 1;
// Act
var result = await testController.GetGame(id);
// Assert
result.Result.ShouldBeOfType <ObjectResult>();
((ObjectResult)result.Result).StatusCode.ShouldBe(StatusCodes.Status500InternalServerError);
((ObjectResult)result.Result).Value.ShouldBe("Database failure");
}
public async Task GetGames_WhenNoExceptionIsCaught_ShouldGetGames()
{
// Arrange
var gameRepository = A.Fake <IGameRepository>();
var games = new List <Game>();
A.CallTo(() => gameRepository.GetGamesAsync()).Returns(games);
var sharedRepository = A.Fake <ISharedRepository>();
var mapper = A.Fake <IMapper>();
var linkGenerator = A.Fake <LinkGenerator>();
var gameService = A.Fake <IGameService>();
var testController =
new GamesController(gameRepository, sharedRepository, mapper, linkGenerator, gameService);
// Act
var result = await testController.GetGames();
// Assert
A.CallTo(() => gameRepository.GetGamesAsync()).MustHaveHappenedOnceExactly();
A.CallTo(() => mapper.Map <GameModel[]>(games)).MustHaveHappenedOnceExactly();
result.ShouldBeOfType <ActionResult <GameModel[]> >();
result.Value.ShouldBe(mapper.Map <GameModel[]>(games));
}
public async Task Setup()
{
context = await TestDatabase.GetDatabaseContext();
mockGamesService = new MockGamesService(context);
mockAppsService = new MockAppsService(context);
baseRequest = new BaseRequest();
createGameRequest = new CreateGameRequest();
getMyGameRequest = new GamesRequest()
{
UserId = 1,
License = TestObjects.GetLicense(),
RequestorId = 1,
Paginator = new Paginator()
};
updateGameRequest = TestObjects.GetUpdateGameRequest();
sutSuccess = new GamesController(
mockGamesService.GamesServiceSuccessfulRequest.Object,
mockAppsService.AppsServiceSuccessfulRequest.Object);
sutFailure = new GamesController(
mockGamesService.GamesServiceFailedRequest.Object,
mockAppsService.AppsServiceSuccessfulRequest.Object);
}
public async Task Details_WhenIdIsNotNullAndGameFound_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.Details(id.Value);
// Assert
A.CallTo(() => gameRepository.GetGameAsync(id.Value)).MustHaveHappenedOnceExactly();
gamesDetailsViewModel.Game.ShouldBe(game);
result.ShouldBeOfType <ViewResult>();
((ViewResult)result).Model.ShouldBe(gamesDetailsViewModel);
}
private void TestGameLeave(GameModel game)
{
// remove everyone from game, player[0] is the host
GamesController controller = new GamesController();
// Add Authorization
var context = new HttpControllerContext();
var request = new HttpRequestMessage();
controller.ControllerContext = context;
controller.Request = request;
var players = TestHelpers.TestData.getAuthorizedPlayers();
// verify other players can leave game, but cannot leave a second time
for (int i = players.Count - 1; i >= 0; i--)
{
var testPlayer = players[i];
request.Headers.Remove("Authorization");
request.Headers.Add("Authorization", testPlayer.AuthCode);
// can leave
var result = controller.LeaveGame(game.Id);
Assert.IsInstanceOfType(result, typeof(OkResult));
// cannot leave again
result = controller.LeaveGame(game.Id);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
// verify game no longer exists
var getResult = controller.GetGame(game.Id);
Assert.IsInstanceOfType(getResult, typeof(NotFoundResult));
}
public void GetAll_WhenScoresInDb_ShouldReturnScores()
{
var repo = Mock.Create <IRepository <Game> >();
Mock.Arrange(() => repo.All())
.Returns(() => new List <Game>().AsQueryable());
var data = Mock.Create <IBullsAndCowsData>();
Mock.Arrange(() => data.Games)
.Returns(() => repo);
var controller = new GamesController(data, null, null, null);
this.SetupController(controller);
var actionResult = controller.Get();
var response = actionResult.ExecuteAsync(CancellationToken.None).Result;
var actual = response.Content.ReadAsStringAsync().Result;
var expected = "[]"; //empty array
Assert.AreEqual(actual, expected);
}
public void Delete_IdIsNull_ReturnsNotFoundResult()
{
var controller = new GamesController(new FakeGamesRepository(), new FakeLogger());
var result = controller.Delete(null);
Assert.IsType <NotFoundResult>(result);
}
public void GetById_IdDoesNotExists_ReturnsNotFoundResult()
{
var controller = new GamesController(new FakeGamesRepository(), new FakeLogger());
var result = controller.GetById("some-id");
Assert.IsType <NotFoundResult>(result.Result);
}
public void Delete_IdExists_ReturnsOkResult()
{
var controller = new GamesController(new FakeGamesRepository(), new FakeLogger());
var result = controller.Delete("existing");
Assert.IsType <OkResult>(result);
}
public void GamesControllerDeleteConfirmed()
{
var gamesController = new GamesController(null);
var result = gamesController.DeleteConfirmed(1);
Assert.IsNotNull(result);
}
public void GamesControllerEdit()
{
var gamesController = new GamesController(null);
var result = gamesController.Edit(null);
Assert.IsNotNull(result);
}
public void GamesControllerDetails()
{
var gamesController = new GamesController(null);
var result = gamesController.Details(null);
Assert.IsNotNull(result);
}
public void GamesControllerCreate()
{
var gamesController = new GamesController(null);
var result = gamesController.Create();
Assert.IsNotNull(result);
}
public void GamesControllerIndex()
{
var gamesController = new GamesController(null);
var result = gamesController.Index("aaa");
Assert.IsNotNull(result);
}
public void GamesControllerReturnNull()
{
var gamesController = new GamesController(null);
var result = gamesController.HttpContext;
Assert.IsNull(result);
}
public GamesControllerTests()
{
this.fakeGames = this.GenerateFakeCollectionOfGames();
this.gamesRepo = new MockIGenericRepository<Game>(this.fakeGames);
this.gamesController = new GamesController(this.gamesRepo.MockedRepo.Object);
}
