public async Task TestGetCombat_WithSpoilsOfWar() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupDummyWorldAsTree() .SetupSessionPhase(SessionPhase.SpoilsOfWar) .SetupRegionOwnership(ControllerMockRegionRepositoryExtensions.DummyWorldRegionB, DummyUserRepository.RegisteredUserIds[1]) .SetupRegionOwnership(ControllerMockRegionRepositoryExtensions.DummyWorldRegionD, DummyUserRepository.RegisteredUserIds[2]) .SetupSpoilsOfWar(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, ControllerMockRegionRepositoryExtensions.DummyWorldRegionB, 5, ControllerMockRegionRepositoryExtensions.DummyWorldRegionD, 1); // Act IEnumerable <ICombat> result = await primaryUser.WorldController.GetCombat(SessionGuid); // Assert Assert.IsNotNull(result); Assert.AreEqual(1, result.Count()); Assert.AreEqual(CombatType.SpoilsOfWar, result.First().ResolutionType); Assert.AreEqual(3, result.First().InvolvedArmies.Count()); AssertCombat.IsAttacking(ControllerMockRegionRepositoryExtensions.DummyWorldRegionB, 5, DummyUserRepository.RegisteredUserIds[1], result.First()); AssertCombat.IsAttacking(ControllerMockRegionRepositoryExtensions.DummyWorldRegionD, 1, DummyUserRepository.RegisteredUserIds[2], result.First()); AssertCombat.IsDefending(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, 0, primaryUser.OwnerId, result.First()); }
public async Task TestPostRedeploy_WithTwoRedeployments() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupSessionPhase(SessionPhase.Redeployment) .SetupDummyWorldAsTree() .SetupRegionTroops(OwnedRegionGuid, 10); // Act await primaryUser.RegionController.PostRedeployTroops(SessionGuid, OwnedRegionGuid, 5, OwnedAdjacentRegionGuid); Task result = primaryUser.RegionController.PostRedeployTroops(SessionGuid, OwnedRegionGuid, 4, OwnedAdjacentRegionGuid); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.Conflict, exception.Response.StatusCode); } }
public async Task TestGetCards_WithValidSession() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupAddPlayer(DummyUserRepository.RegisteredUserIds[1], PlayerColour.Yellow) .SetupDummyWorldAsTree() .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA) .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionB) .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionC) .SetupCardOwner(DummyUserRepository.RegisteredUserIds[1], ControllerMockRegionRepositoryExtensions.DummyWorldRegionD); // Act IEnumerable <ICard> result = await primaryUser.NationController.GetCards(SessionGuid); // Assert Assert.IsNotNull(result); List <ICard> cards = result.ToList(); Assert.AreEqual(3, cards.Count()); Assert.AreEqual(1, cards.Count(card => ControllerMockRegionRepositoryExtensions.DummyWorldRegionA == card.RegionId)); Assert.AreEqual(3U, cards.First(card => ControllerMockRegionRepositoryExtensions.DummyWorldRegionA == card.RegionId).Value); Assert.AreEqual(1, cards.Count(card => ControllerMockRegionRepositoryExtensions.DummyWorldRegionB == card.RegionId)); Assert.AreEqual(5U, cards.First(card => ControllerMockRegionRepositoryExtensions.DummyWorldRegionB == card.RegionId).Value); Assert.AreEqual(1, cards.Count(card => ControllerMockRegionRepositoryExtensions.DummyWorldRegionC == card.RegionId)); Assert.AreEqual(7U, cards.First(card => ControllerMockRegionRepositoryExtensions.DummyWorldRegionC == card.RegionId).Value); }
public async Task TestPostCards_WithIncorrectSessionPhase() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupAddPlayer(DummyUserRepository.RegisteredUserIds[1], PlayerColour.Yellow) .SetupDummyWorldAsTree() .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA) .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionB) .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionC) .SetupCardOwner(DummyUserRepository.RegisteredUserIds[1], ControllerMockRegionRepositoryExtensions.DummyWorldRegionD) .SetupSessionPhase(SessionPhase.CombatOrders); // Act Task result = primaryUser.NationController.PostCards(SessionGuid, new List <Guid> { ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, ControllerMockRegionRepositoryExtensions.DummyWorldRegionB, ControllerMockRegionRepositoryExtensions.DummyWorldRegionC }); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.ExpectationFailed, exception.Response.StatusCode); } }
public async Task TestPostCards_WithInvalidCombinationOfCard() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupDummyWorldAsTree() .SetupSessionPhase(SessionPhase.Reinforcements) .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA) .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionB) .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionC) .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionD); // Act Task result = primaryUser.NationController.PostCards(SessionGuid, new List <Guid> { ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, ControllerMockRegionRepositoryExtensions.DummyWorldRegionB, ControllerMockRegionRepositoryExtensions.DummyWorldRegionD }); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.BadRequest, exception.Response.StatusCode); } }
public async Task TestPostAttack_WithDuplicateRegion_WithInvalidTroops() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupSessionPhase(SessionPhase.CombatOrders) .SetupDummyWorldAsTree() .SetupRegionOwnership(UnownedAdjacentRegionGuid, DummyUserRepository.RegisteredUserIds[1]) .SetupRegionTroops(OwnedRegionGuid, 10); // Act Task result = primaryUser.RegionController.PostAttack(SessionGuid, OwnedRegionGuid, 9, UnownedAdjacentRegionGuid); Task result2 = primaryUser.RegionController.PostAttack(SessionGuid, OwnedRegionGuid, 1, UnownedAdjacentRegionGuid); // Assert await result; try { await result2; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.BadRequest, exception.Response.StatusCode); } }
public async Task TestPostRedeploy_WithValidRegion_WithUnownedTargetRegion() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupSessionPhase(SessionPhase.Redeployment) .SetupDummyWorldAsTree() .SetupRegionTroops(OwnedRegionGuid, 2) .SetupRegionOwnership(UnownedAdjacentRegionGuid, DummyUserRepository.RegisteredUserIds[1]); // Act Task result = primaryUser.RegionController.PostRedeployTroops(SessionGuid, OwnedRegionGuid, 1, UnownedAdjacentRegionGuid); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.NotAcceptable, exception.Response.StatusCode); } }
public async Task IntegrationTestStartAndPlayOneRound_WithTwoUsers() { ControllerMock primaryUser = new ControllerMock(); primaryUser.RegionRepository.WorldDefinitionPath = @"WorldData\ValidWorldDefinition.xml"; ControllerMock secondaryUser = new ControllerMock(DummyUserRepository.RegisteredUserIds[1], primaryUser); // Create session using primary user ISession sessionDetails = await primaryUser.GameController.PostStartNewSession(PlayerColour.Black); Assert.IsNotNull(sessionDetails); // Join session using secondary user await secondaryUser.GameController.PostJoinSession(sessionDetails.GameId, PlayerColour.Green); // Assert all players in session var playersInSession = await primaryUser.GameController.GetPlayers(sessionDetails.GameId); Assert.AreEqual(2, playersInSession.Count()); // Start game (with primary user) await primaryUser.GameController.PostAdvanceNextPhase(sessionDetails.GameId, sessionDetails.PhaseId, true); // Deploy initial troops await RandomlyDeployReinforcements(primaryUser, sessionDetails.GameId); await RandomlyDeployReinforcements(secondaryUser, sessionDetails.GameId); // Move into combat phase (with primary user) sessionDetails = await primaryUser.GameController.GetSession(sessionDetails.GameId); await primaryUser.GameController.PostAdvanceNextPhase(sessionDetails.GameId, sessionDetails.PhaseId, true); // Issue random attack orders await RandomlyAttack(primaryUser, sessionDetails.GameId); await RandomlyAttack(secondaryUser, sessionDetails.GameId); // Move into resolution phase (with primary user) sessionDetails = await primaryUser.GameController.GetSession(sessionDetails.GameId); await primaryUser.GameController.PostAdvanceNextPhase(sessionDetails.GameId, sessionDetails.PhaseId, true); // Resolve combat await ResolveAllCombat(primaryUser, sessionDetails.GameId); // Issue random deployment order await RandomlyRedeployTroops(primaryUser, sessionDetails.GameId); await RandomlyRedeployTroops(secondaryUser, sessionDetails.GameId); // Move into victory phase (with primary user) sessionDetails = await primaryUser.GameController.GetSession(sessionDetails.GameId); await primaryUser.GameController.PostAdvanceNextPhase(sessionDetails.GameId, sessionDetails.PhaseId, true); }
public ControllerMock(String userId, ControllerMock linkedData) { OwnerId = userId; CommandQueue = linkedData.CommandQueue; NationRepository = linkedData.NationRepository; RegionRepository = linkedData.RegionRepository; SessionRepository = linkedData.SessionRepository; UserRepository = linkedData.UserRepository; WorldRepository = linkedData.WorldRepository; CreateControllers(); }
public async Task TestGetRegionList_WithNoRegions() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid); // Act IEnumerable <IRegion> result = await primaryUser.WorldController.GetRegionList(SessionGuid); // Assert Assert.IsNotNull(result); Assert.AreEqual(0, result.Count()); }
public async Task TestGetDetails_WithValidRegion() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupDummyWorldAsTree(); // Act IRegion result = await primaryUser.RegionController.GetDetails(SessionGuid, OwnedRegionGuid); // Assert Assert.IsNotNull(result); Assert.AreEqual(OwnedRegionGuid, result.RegionId); }
public async Task TestGetReinforcements_WithValidSession() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupSessionPhase(SessionPhase.Reinforcements) .SetupAvailableReinforcements(10); // Act UInt32 result = await primaryUser.NationController.GetReinforcements(SessionGuid); // Assert Assert.AreEqual(10U, result); }
public async Task TestPostRedeploy_WithValidRegion_WithValidTroops() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupSessionPhase(SessionPhase.Redeployment) .SetupDummyWorldAsTree() .SetupRegionTroops(OwnedRegionGuid, 2); // Act Guid operationId = await primaryUser.RegionController.PostRedeployTroops(SessionGuid, OwnedRegionGuid, 1, OwnedAdjacentRegionGuid); // Assert Assert.AreEqual(1, primaryUser.CommandQueue.DummyRedeployQueue.Count()); Assert.AreEqual(operationId, primaryUser.CommandQueue.DummyRedeployQueue.First().OperationId); Assert.AreEqual(OwnedAdjacentRegionGuid, primaryUser.CommandQueue.DummyRedeployQueue.First().TargetRegion); Assert.AreEqual(1U, primaryUser.CommandQueue.DummyRedeployQueue.First().NumberOfTroops); }
public async Task TestGetRegionList_WithInvalidSession() { // Arrange ControllerMock primaryUser = new ControllerMock(); // Act Task <IEnumerable <IRegion> > result = primaryUser.WorldController.GetRegionList(SessionGuid); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.NotFound, exception.Response.StatusCode); } }
public async Task TestPostDeployTroops_WithValidRegion_WithValidTroops() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupSessionPhase(SessionPhase.Reinforcements) .SetupAvailableReinforcements(1) .SetupDummyWorldAsTree(); // Act Guid operationId = await primaryUser.RegionController.PostDeployTroops(SessionGuid, OwnedRegionGuid, 1); // Assert Assert.AreEqual(1, primaryUser.CommandQueue.DummyDeployReinforcementsQueue.Count()); Assert.AreEqual(operationId, primaryUser.CommandQueue.DummyDeployReinforcementsQueue.First().OperationId); Assert.AreEqual(OwnedRegionGuid, primaryUser.CommandQueue.DummyDeployReinforcementsQueue.First().TargetRegion); Assert.AreEqual(1U, primaryUser.CommandQueue.DummyDeployReinforcementsQueue.First().NumberOfTroops); }
public async Task TestGetReinforcements_WithInvalidSession() { // Arrange ControllerMock primaryUser = new ControllerMock(); // Act Task <UInt32> result = primaryUser.NationController.GetReinforcements(InvalidSessionGuid); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.NotFound, exception.Response.StatusCode); } }
public async Task TestGetCombat_WithExpiredBorderClash() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupDummyWorldAsTree() .SetupSessionPhase(SessionPhase.MassInvasions) .SetupRegionOwnership(ControllerMockRegionRepositoryExtensions.DummyWorldRegionD, DummyUserRepository.RegisteredUserIds[1]) .SetupRegionTroops(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, 7) .SetupRegionTroops(ControllerMockRegionRepositoryExtensions.DummyWorldRegionD, 2) .SetupBorderClash(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, 5, ControllerMockRegionRepositoryExtensions.DummyWorldRegionD, 1); // Act IEnumerable <ICombat> result = await primaryUser.WorldController.GetCombat(SessionGuid); // Assert Assert.IsNotNull(result); Assert.AreEqual(2, result.Count()); }
public async Task TestPostCards_WithInvalidSession() { // Arrange ControllerMock primaryUser = new ControllerMock(); // Act Task result = primaryUser.NationController.PostCards(InvalidSessionGuid, new List <Guid> { }); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.NotFound, exception.Response.StatusCode); } }
public async Task TestGetRegionList_WithNotInSession() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid, DummyUserRepository.RegisteredUserIds[1]); // Act Task <IEnumerable <IRegion> > result = primaryUser.WorldController.GetRegionList(SessionGuid); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.Unauthorized, exception.Response.StatusCode); } }
public async Task TestPostAttack_WithValidRegion_WithValidTroops() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupSessionPhase(SessionPhase.CombatOrders) .SetupDummyWorldAsTree() .SetupRegionOwnership(UnownedAdjacentRegionGuid, DummyUserRepository.RegisteredUserIds[1]) .SetupRegionTroops(OwnedRegionGuid, 2); // Act Guid operationId = await primaryUser.RegionController.PostAttack(SessionGuid, OwnedRegionGuid, 1, UnownedAdjacentRegionGuid); // Assert Assert.AreEqual(1, primaryUser.CommandQueue.DummyOrderAttackQueue.Count()); Assert.AreEqual(operationId, primaryUser.CommandQueue.DummyOrderAttackQueue.First().OperationId); Assert.AreEqual(UnownedAdjacentRegionGuid, primaryUser.CommandQueue.DummyOrderAttackQueue.First().TargetRegion); Assert.AreEqual(1U, primaryUser.CommandQueue.DummyOrderAttackQueue.First().NumberOfTroops); Assert.AreEqual(1U, primaryUser.RegionRepository.RegionData[OwnedRegionGuid].TroopsCommittedToPhase); }
public async Task TestGetDetails_WithUnownedSession() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid, DummyUserRepository.RegisteredUserIds[1]) .SetupDummyWorldAsTree(DummyUserRepository.RegisteredUserIds[1]); // Act Task <IRegion> result = primaryUser.RegionController.GetDetails(SessionGuid, OwnedRegionGuid); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.Unauthorized, exception.Response.StatusCode); } }
public async Task TestPostCards_WithSet() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupDummyWorldAsTree() .SetupSessionPhase(SessionPhase.Reinforcements) .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA) .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionB) .SetupCardOwner(ControllerMockRegionRepositoryExtensions.DummyWorldRegionC); // Act await primaryUser.NationController.PostCards(SessionGuid, new List <Guid> { ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, ControllerMockRegionRepositoryExtensions.DummyWorldRegionB, ControllerMockRegionRepositoryExtensions.DummyWorldRegionC }); // Assert Assert.AreEqual(9U, primaryUser.GetNation(SessionGuid, primaryUser.OwnerId).AvailableReinforcements); }
public async Task TestGetReinforcements_WithUnjoinedSession() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid, DummyUserRepository.RegisteredUserIds[1]) .SetupSessionPhase(SessionPhase.Reinforcements); // Act Task <UInt32> result = primaryUser.NationController.GetReinforcements(SessionGuid); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.Unauthorized, exception.Response.StatusCode); } }
public async Task TestGetCombat_WithBorderClash() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupDummyWorldAsTree() .SetupSessionPhase(SessionPhase.BorderClashes) .SetupRegionOwnership(ControllerMockRegionRepositoryExtensions.DummyWorldRegionD, DummyUserRepository.RegisteredUserIds[1]) .SetupRegionTroops(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, 7) .SetupRegionTroops(ControllerMockRegionRepositoryExtensions.DummyWorldRegionD, 2) .SetupBorderClash(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, 5, ControllerMockRegionRepositoryExtensions.DummyWorldRegionD, 1); // Act IEnumerable <ICombat> result = await primaryUser.WorldController.GetCombat(SessionGuid); // Assert Assert.IsNotNull(result); Assert.AreEqual(3, result.Count()); var borderClash = result.Where(combat => combat.ResolutionType == CombatType.BorderClash).FirstOrDefault(); Assert.IsNotNull(borderClash); Assert.AreEqual(2, borderClash.InvolvedArmies.Count()); AssertCombat.IsAttacking(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, 5, primaryUser.OwnerId, borderClash); AssertCombat.IsAttacking(ControllerMockRegionRepositoryExtensions.DummyWorldRegionD, 1, DummyUserRepository.RegisteredUserIds[1], borderClash); var invasionOfA = result.Where(combat => combat.ResolutionType == CombatType.Invasion && combat.InvolvedArmies.First().OriginRegionId == ControllerMockRegionRepositoryExtensions.DummyWorldRegionA).FirstOrDefault(); Assert.IsNotNull(invasionOfA); Assert.AreEqual(1, invasionOfA.InvolvedArmies.Count()); AssertCombat.IsDefending(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, 2, primaryUser.OwnerId, invasionOfA); var invasionOfD = result.Where(combat => combat.ResolutionType == CombatType.Invasion && combat.InvolvedArmies.First().OriginRegionId == ControllerMockRegionRepositoryExtensions.DummyWorldRegionD).FirstOrDefault(); Assert.IsNotNull(invasionOfD); Assert.AreEqual(1, invasionOfD.InvolvedArmies.Count()); AssertCombat.IsDefending(ControllerMockRegionRepositoryExtensions.DummyWorldRegionD, 1, DummyUserRepository.RegisteredUserIds[1], invasionOfD); }
public async Task TestGetReinforcements_WithIncorrectSessionPhase() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupSessionPhase(SessionPhase.CombatOrders); // Act Task <UInt32> result = primaryUser.NationController.GetReinforcements(SessionGuid); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.ExpectationFailed, exception.Response.StatusCode); } }
public async Task TestPostAttack_WithInvalidRegion() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupDummyWorldAsTree(); // Act Task result = primaryUser.RegionController.PostAttack(SessionGuid, InvalidRegionGuid, 1, InvalidRegionGuid); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.NotFound, exception.Response.StatusCode); } }
public async Task IntegrationTestCombatResolution_WithDirectInvasion() { // Arrange Guid validGuid = new Guid("68E4A0DC-BAB8-4C79-A6E9-D0A7494F3B45"); ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(validGuid) .SetupAddPlayer(DummyUserRepository.RegisteredUserIds[1], PlayerColour.Blue) .SetupDummyWorldAsTree(primaryUser.OwnerId) .SetupRegionOwnership(ControllerMockRegionRepositoryExtensions.DummyWorldRegionB, DummyUserRepository.RegisteredUserIds[1]) .SetupRegionTroops(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, 5) .SetupRegionTroops(ControllerMockRegionRepositoryExtensions.DummyWorldRegionB, 2) .SetupSessionPhase(SessionPhase.CombatOrders) .QueueAttack(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, ControllerMockRegionRepositoryExtensions.DummyWorldRegionB, 4) // Rig dice so that A beats B .SetupRiggedDiceResults(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, 6, 6, 6) .SetupRiggedDiceResults(ControllerMockRegionRepositoryExtensions.DummyWorldRegionB, 1, 1); // Act await ResolveAllCombat(primaryUser, validGuid); // Assert Assert.AreEqual(SessionPhase.Redeployment, primaryUser.SessionRepository.SessionMap[validGuid].PhaseType); var invasion = primaryUser.GetInvasion(ControllerMockRegionRepositoryExtensions.DummyWorldRegionB); var invasionResults = primaryUser.WorldRepository.CombatResults[invasion.CombatId]; AssertCombat.IsResultValid(1, invasion, invasionResults); AssertCombat.IsArmyResult(ControllerMockRegionRepositoryExtensions.DummyWorldRegionA, 1, 0, invasionResults); AssertCombat.IsArmyResult(ControllerMockRegionRepositoryExtensions.DummyWorldRegionB, 1, 2, invasionResults); Assert.AreEqual(primaryUser.OwnerId, primaryUser.RegionRepository.RegionData[ControllerMockRegionRepositoryExtensions.DummyWorldRegionA].OwnerId); Assert.AreEqual(1U, primaryUser.RegionRepository.RegionData[ControllerMockRegionRepositoryExtensions.DummyWorldRegionA].TroopCount); Assert.AreEqual(0U, primaryUser.RegionRepository.RegionData[ControllerMockRegionRepositoryExtensions.DummyWorldRegionA].TroopsCommittedToPhase); Assert.AreEqual(primaryUser.OwnerId, primaryUser.RegionRepository.RegionData[ControllerMockRegionRepositoryExtensions.DummyWorldRegionB].OwnerId); Assert.AreEqual(4U, primaryUser.RegionRepository.RegionData[ControllerMockRegionRepositoryExtensions.DummyWorldRegionB].TroopCount); Assert.AreEqual(0U, primaryUser.RegionRepository.RegionData[ControllerMockRegionRepositoryExtensions.DummyWorldRegionB].TroopsCommittedToPhase); }
public async Task TestPostCards_WithNoCards() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupDummyWorldAsTree() .SetupSessionPhase(SessionPhase.Reinforcements); // Act Task result = primaryUser.NationController.PostCards(SessionGuid, null); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.BadRequest, exception.Response.StatusCode); } }
public async Task TestGetDetails_WithInvalidSession() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(InvalidRegionGuid) .SetupDummyWorldAsTree(); primaryUser.SessionRepository.SessionMap.Clear(); // Act Task <IRegion> result = primaryUser.RegionController.GetDetails(SessionGuid, OwnedRegionGuid); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.NotFound, exception.Response.StatusCode); } }
public async Task TestPostRedeploy_WithValidRegion_WithUnconnectedTarget() { // Arrange ControllerMock primaryUser = new ControllerMock(); primaryUser.SetupDummySession(SessionGuid) .SetupSessionPhase(SessionPhase.Redeployment) .SetupDummyWorldAsTree(); // Act Task result = primaryUser.RegionController.PostRedeployTroops(SessionGuid, OwnedRegionGuid, 1, OwnedNonAdjacentRegionGuid); // Assert try { await result; Assert.Fail("Expected exception to be thrown"); } catch (HttpResponseException exception) { Assert.AreEqual(HttpStatusCode.PaymentRequired, exception.Response.StatusCode); } }