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);
}
}
