public async Task IntegrationTestResetDiscardedCards()
{
// Arrange
NationRepository repository = new NationRepository(DevelopmentStorageAccountConnectionString);
SessionRepository sessionRepository = new SessionRepository(DevelopmentStorageAccountConnectionString);
Guid validGuid = new Guid("0FC802DC-2F1B-4D0B-B1B4-E6BD88E5550D");
Guid dummyRegionGuid = new Guid("EAB48F5F-F268-45BE-B42D-936DE39CDD09");
String dummyUserId = "DummyUserId";
await sessionRepository.SetupSession(validGuid, dummyUserId);
CardTableEntry ownedCard = await sessionRepository.SetupAddCard(validGuid, dummyRegionGuid, CardTableEntry.State.Discarded, dummyUserId, 3);
var dataTable = SessionRepository.GetTableForSessionData(TableClient, validGuid);
// Act
using (IBatchOperationHandle batchOperation = new BatchOperationHandle(sessionRepository.GetTableForSessionData(validGuid)))
{
await repository.ResetDiscardedCards(batchOperation, validGuid);
}
// Assert
var operation = TableOperation.Retrieve <CardTableEntry>(validGuid.ToString(), "Card_" + dummyRegionGuid);
var result = await dataTable.ExecuteAsync(operation);
CardTableEntry resultStronglyTyped = result.Result as CardTableEntry;
Assert.AreEqual(CardTableEntry.State.Unowned, resultStronglyTyped.OwnerState);
Assert.AreEqual(String.Empty, resultStronglyTyped.OwnerId);
}
public async Task IntegrationTestMarkPlayerCompletedPhase()
{
// Arrange
NationRepository repository = new NationRepository(DevelopmentStorageAccountConnectionString);
SessionRepository sessionRepository = new SessionRepository(DevelopmentStorageAccountConnectionString);
Guid validGuid = new Guid("68E4A0DC-BAB8-4C79-A6E9-D0A7494F3B45");
String dummyUserId = "DummyUserId";
await sessionRepository.SetupSession(validGuid, dummyUserId)
.SetupSessionPhase(sessionRepository, SessionPhase.Reinforcements);
var dataTable = SessionRepository.GetTableForSessionData(TableClient, validGuid);
// Act
await repository.MarkPlayerCompletedPhase(validGuid, dummyUserId, validGuid);
// Assert
var operation = TableOperation.Retrieve <NationTableEntry>(validGuid.ToString(), "Nation_" + dummyUserId);
var result = await dataTable.ExecuteAsync(operation);
Assert.IsNotNull(result.Result);
Assert.IsInstanceOfType(result.Result, typeof(NationTableEntry));
NationTableEntry resultPlayerStronglyTyped = result.Result as NationTableEntry;
Assert.AreEqual(validGuid, resultPlayerStronglyTyped.CompletedPhase);
}
public async Task <Guid> PostDeployTroops(Guid sessionId, Guid regionId, uint numberOfTroops)
{
IRegionData region = await RegionRepository.GetRegionOrThrow(sessionId, regionId)
.IsRegionOwnerOrThrow(User.Identity.GetUserId());
ISession session = await SessionRepository.GetSessionOrThrow(region)
.IsUserIdJoinedOrThrow(NationRepository, User.Identity.GetUserId())
.IsPhaseTypeOrThrow(SessionPhase.Reinforcements);
INationData nation = await NationRepository.GetNation(sessionId, User.Identity.GetUserId());
if (nation.AvailableReinforcements < numberOfTroops)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "You do not have that many troops available to deploy"
});
}
else if (numberOfTroops <= 0)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "You can not deploy less than 1 troop"
});
}
else
{
return(await CommandQueue.DeployReinforcements(session.GameId, session.PhaseId, region.RegionId, region.CurrentEtag, numberOfTroops));
}
}
public async Task IntegrationTestSetCardDiscarded()
{
// CHANGE GUIDS
// Arrange
NationRepository repository = new NationRepository(DevelopmentStorageAccountConnectionString);
SessionRepository sessionRepository = new SessionRepository(DevelopmentStorageAccountConnectionString);
Guid validGuid = new Guid("C6EA373B-63E8-481D-894C-9051F6710771");
Guid dummyRegionGuid = new Guid("7D194EC9-59ED-494F-8F77-9ED4B26F75FA");
String dummyUserId = "DummyUserId";
await sessionRepository.SetupSession(validGuid, dummyUserId);
CardTableEntry ownedCard = await sessionRepository.SetupAddCard(validGuid, dummyRegionGuid, CardTableEntry.State.Owned, dummyUserId, 3);
var dataTable = SessionRepository.GetTableForSessionData(TableClient, validGuid);
// Act
using (IBatchOperationHandle batchOperation = new BatchOperationHandle(sessionRepository.GetTableForSessionData(validGuid)))
{
repository.SetCardDiscarded(batchOperation, validGuid, dummyRegionGuid, ownedCard.CurrentEtag);
}
// Assert
var operation = TableOperation.Retrieve <CardTableEntry>(validGuid.ToString(), "Card_" + dummyRegionGuid);
var result = await dataTable.ExecuteAsync(operation);
CardTableEntry resultStronglyTyped = result.Result as CardTableEntry;
Assert.AreEqual(CardTableEntry.State.Discarded, resultStronglyTyped.OwnerState);
Assert.AreEqual(dummyUserId, resultStronglyTyped.OwnerId);
}
public async Task IntegrationTestGetUnownedCards()
{
// Arrange
NationRepository repository = new NationRepository(DevelopmentStorageAccountConnectionString);
SessionRepository sessionRepository = new SessionRepository(DevelopmentStorageAccountConnectionString);
Guid validGuid = new Guid("03ECAE31-CB33-4537-9E22-FE1A68BFFA08");
Guid dummyRegionAGuid = new Guid("FD28529F-011D-42F5-B9B2-0F7AEA80CB8A");
Guid dummyRegionBGuid = new Guid("A05EBB51-1BAA-4E4E-B43E-7E30EB89F5C7");
Guid dummyRegionCGuid = new Guid("21B47511-8376-44F1-835D-41FF3BD1A860");
String dummyUserId = "DummyUserId";
await sessionRepository.SetupSession(validGuid, dummyUserId);
await sessionRepository.SetupAddCard(validGuid, dummyRegionAGuid, CardTableEntry.State.Owned, dummyUserId, 3);
var unownedCard = await sessionRepository.SetupAddCard(validGuid, dummyRegionBGuid, CardTableEntry.State.Unowned, String.Empty, 5);
await sessionRepository.SetupAddCard(validGuid, dummyRegionCGuid, CardTableEntry.State.Discarded, dummyUserId, 7);
// Act
IEnumerable <ICardData> unownedCards = await repository.GetUnownedCards(validGuid);
// Assert
Assert.IsNotNull(unownedCards);
Assert.AreEqual(1, unownedCards.Count());
Assert.AreEqual(String.Empty, unownedCards.First().OwnerId);
Assert.AreEqual(dummyRegionBGuid, unownedCards.First().RegionId);
Assert.AreEqual(5U, unownedCards.First().Value);
Assert.AreEqual(unownedCard.ETag, unownedCards.First().CurrentEtag);
}
public async Task IntegrationTestSetAvailableReinforcements_WithMultipleUsers()
{
// Arrange
NationRepository repository = new NationRepository(DevelopmentStorageAccountConnectionString);
SessionRepository sessionRepository = new SessionRepository(DevelopmentStorageAccountConnectionString);
Guid validGuid = new Guid("B59C5710-F3B3-4AAB-983D-9899ADEB4F28");
String dummyUserId = "DummyUserId";
String secondDummyUserId = "DummyUserId2";
await sessionRepository.SetupSession(validGuid, dummyUserId);
await sessionRepository.SetupAddPlayer(validGuid, secondDummyUserId);
var dataTable = SessionRepository.GetTableForSessionData(TableClient, validGuid);
// Act
using (IBatchOperationHandle batchOperation = new BatchOperationHandle(sessionRepository.GetTableForSessionData(validGuid)))
{
repository.SetAvailableReinforcements(batchOperation, validGuid, dummyUserId, "*", 10U);
repository.SetAvailableReinforcements(batchOperation, validGuid, secondDummyUserId, "*", 20U);
}
// Assert
var operation = TableOperation.Retrieve <NationTableEntry>(validGuid.ToString(), "Nation_" + dummyUserId);
var result = await dataTable.ExecuteAsync(operation);
NationTableEntry resultPlayerStronglyTyped = result.Result as NationTableEntry;
Assert.AreEqual(10U, resultPlayerStronglyTyped.AvailableReinforcements);
operation = TableOperation.Retrieve <NationTableEntry>(validGuid.ToString(), "Nation_" + secondDummyUserId);
result = await dataTable.ExecuteAsync(operation);
resultPlayerStronglyTyped = result.Result as NationTableEntry;
Assert.AreEqual(20U, resultPlayerStronglyTyped.AvailableReinforcements);
}
public async Task IntegrationTestSetCardOwner()
{
// Arrange
NationRepository repository = new NationRepository(DevelopmentStorageAccountConnectionString);
SessionRepository sessionRepository = new SessionRepository(DevelopmentStorageAccountConnectionString);
Guid validGuid = new Guid("745C4DEB-2C66-4AC5-900E-27BA0C82BB0F");
Guid dummyRegionGuid = new Guid("8C60947F-F7E5-4153-B43C-4B19D8CBE2CF");
String dummyUserId = "DummyUserId";
await sessionRepository.SetupSession(validGuid, dummyUserId);
CardTableEntry ownedCard = await sessionRepository.SetupAddCard(validGuid, dummyRegionGuid, CardTableEntry.State.Unowned, String.Empty, 3);
var dataTable = SessionRepository.GetTableForSessionData(TableClient, validGuid);
// Act
using (IBatchOperationHandle batchOperation = new BatchOperationHandle(sessionRepository.GetTableForSessionData(validGuid)))
{
repository.SetCardOwner(batchOperation, validGuid, dummyRegionGuid, dummyUserId, ownedCard.CurrentEtag);
}
// Assert
var operation = TableOperation.Retrieve <CardTableEntry>(validGuid.ToString(), "Card_" + dummyRegionGuid);
var result = await dataTable.ExecuteAsync(operation);
CardTableEntry resultStronglyTyped = result.Result as CardTableEntry;
Assert.AreEqual(CardTableEntry.State.Owned, resultStronglyTyped.OwnerState);
Assert.AreEqual(dummyUserId, resultStronglyTyped.OwnerId);
}
public async Task <IEnumerable <ICard> > GetCards(Guid sessionId)
{
ISession session = await SessionRepository.GetSessionOrThrow(sessionId)
.IsUserIdJoinedOrThrow(NationRepository, User.Identity.GetUserId());
IEnumerable <ICardData> playerCards = await NationRepository.GetCards(sessionId, User.Identity.GetUserId());
return(playerCards.Select(card => new Card(card)));
}
public async Task <UInt32> GetReinforcements(Guid sessionId)
{
ISession session = await SessionRepository.GetSessionOrThrow(sessionId)
.IsPhaseTypeOrThrow(SessionPhase.Reinforcements);
INationData nation = await NationRepository.GetNationOrThrow(sessionId, User.Identity.GetUserId());
return(nation.AvailableReinforcements);
}
public ControllerAzure(String developmentStorageAccountConnectionString, String worldDefinitionPath, String userId)
{
OwnerId = userId;
UserRepository = new DummyUserRepository();
AzureCommandQueue = new CommandQueue(developmentStorageAccountConnectionString);
AzureNationRepository = new NationRepository(developmentStorageAccountConnectionString);
AzureRegionRepository = new RegionRepository(developmentStorageAccountConnectionString, worldDefinitionPath);
AzureSessionRepository = new SessionRepository(developmentStorageAccountConnectionString);
AzureWorldRepository = new WorldRepository(developmentStorageAccountConnectionString);
CreateControllers();
}
public async Task IntegrationTestGetNation_WithInvalidUserId()
{
// Arrange
NationRepository repository = new NationRepository(DevelopmentStorageAccountConnectionString);
SessionRepository sessionRepository = new SessionRepository(DevelopmentStorageAccountConnectionString);
Guid validGuid = new Guid("228175B0-CB34-453E-AB26-A76984B2FDAF");
String dummyUserId = "DummyUserId";
await sessionRepository.SetupSession(validGuid, dummyUserId);
// Act
INationData sessionPlayer = await repository.GetNation(validGuid, "InvalidUserId");
// Assert
Assert.IsNull(sessionPlayer);
}
public async Task <Guid> PostRedeployTroops(Guid sessionId, Guid regionId, uint numberOfTroops, Guid targetRegionId)
{
IRegionData sourceRegion = await RegionRepository.GetRegionOrThrow(sessionId, regionId)
.IsRegionOwnerOrThrow(User.Identity.GetUserId());
ISession session = await SessionRepository.GetSessionOrThrow(sourceRegion)
.IsUserIdJoinedOrThrow(NationRepository, User.Identity.GetUserId())
.IsPhaseTypeOrThrow(SessionPhase.Redeployment);
IRegionData targetRegion = await RegionRepository.GetRegionOrThrow(session.GameId, targetRegionId)
.IsRegionOwnerOrThrow(User.Identity.GetUserId())
.IsRegionConnectedOrThrow(sourceRegion.RegionId);
INationData nation = await NationRepository.GetNation(sessionId, User.Identity.GetUserId());
if (sourceRegion.TroopCount <= numberOfTroops)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "You do not have that many troops available to redeploy"
});
}
else if (numberOfTroops <= 0)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "You can not redeploy less than 1 troop"
});
}
else if (nation.CompletedPhase == session.PhaseId)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.Conflict, ReasonPhrase = "You may only issue 1 redeployment"
});
}
else
{
Guid redeployOp = await CommandQueue.Redeploy(session.GameId, session.PhaseId, nation.CurrentEtag, sourceRegion.RegionId, targetRegion.RegionId, numberOfTroops);
try
{
await NationRepository.MarkPlayerCompletedPhase(sessionId, User.Identity.GetUserId(), session.PhaseId);
}
catch (ConcurrencyException)
{
// The host has moved onto the next phase while we were waiting. No further action required.
}
return(redeployOp);
}
}
public async Task IntegrationTestGetNation()
{
// Arrange
NationRepository repository = new NationRepository(DevelopmentStorageAccountConnectionString);
SessionRepository sessionRepository = new SessionRepository(DevelopmentStorageAccountConnectionString);
Guid validGuid = new Guid("8B1E3932-71D5-4E29-BCAF-BE67D12C3114");
String dummyUserId = "DummyUserId";
await sessionRepository.SetupSession(validGuid, dummyUserId);
// Act
INationData sessionPlayer = await repository.GetNation(validGuid, dummyUserId);
// Assert
Assert.IsNotNull(sessionPlayer);
Assert.AreEqual(dummyUserId, sessionPlayer.UserId);
Assert.AreEqual(0U, sessionPlayer.AvailableReinforcements);
}
public async Task IntegrationTestGetNations()
{
// Arrange
NationRepository repository = new NationRepository(DevelopmentStorageAccountConnectionString);
SessionRepository sessionRepository = new SessionRepository(DevelopmentStorageAccountConnectionString);
Guid validGuid = new Guid("68C1756F-1ED5-449A-9CD1-F533C3A539A0");
String dummyUserId = "DummyUserId";
await sessionRepository.SetupSession(validGuid, dummyUserId);
// Act
IEnumerable <INationData> sessionPlayers = await repository.GetNations(validGuid);
// Assert
Assert.IsNotNull(sessionPlayers);
Assert.AreEqual(1, sessionPlayers.Count());
Assert.AreEqual(dummyUserId, sessionPlayers.First().UserId);
}
public async Task IntegrationTestGetNationsWithPopulatedTable()
{
// Arrange
NationRepository repository = new NationRepository(DevelopmentStorageAccountConnectionString);
SessionRepository sessionRepository = new SessionRepository(DevelopmentStorageAccountConnectionString);
Guid validGuid = new Guid("3CC9F4E8-BDB9-49F4-B128-268F0E5E9C20");
String dummyUserId = "DummyUserId";
await sessionRepository.SetupSession(validGuid, dummyUserId);
await sessionRepository.SetupAddRegion(validGuid, Guid.NewGuid(), Guid.NewGuid(), "DummyRegion", 3U);
// Act
IEnumerable <INationData> sessionPlayers = await repository.GetNations(validGuid);
// Assert
Assert.IsNotNull(sessionPlayers);
Assert.AreEqual(1, sessionPlayers.Count());
Assert.AreEqual(dummyUserId, sessionPlayers.First().UserId);
}
public async Task PostCards(Guid sessionId, IEnumerable <Guid> cards)
{
ISession session = await SessionRepository.GetSessionOrThrow(sessionId)
.IsUserIdJoinedOrThrow(NationRepository, User.Identity.GetUserId())
.IsPhaseTypeOrThrow(SessionPhase.Reinforcements);
Task <INationData> nationDataTask = NationRepository.GetNationOrThrow(sessionId, User.Identity.GetUserId());
Task <IEnumerable <ICardData> > playerCardsTask = NationRepository.GetCards(sessionId, User.Identity.GetUserId());
if (cards == null)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "Invalid card(s) specified"
});
}
HashSet <Guid> cardRegionIds = new HashSet <Guid>();
foreach (Guid cardRegionId in cards)
{
if (cardRegionIds.Contains(cardRegionId))
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "Duplicate card(s) specified"
});
}
else if (cardRegionIds.Count >= 3)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "Too many card(s) specified"
});
}
else
{
cardRegionIds.Add(cardRegionId);
}
}
if (cardRegionIds.Count != 3)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "Too few card(s) specified"
});
}
using (IBatchOperationHandle batchOperation = SessionRepository.StartBatchOperation(sessionId))
{
IEnumerable <ICardData> playerCards = await playerCardsTask;
HashSet <UInt32> seenValues = new HashSet <UInt32>();
foreach (ICardData card in playerCards)
{
if (cardRegionIds.Contains(card.RegionId))
{
NationRepository.SetCardDiscarded(batchOperation, sessionId, card.RegionId, card.CurrentEtag);
seenValues.Add(card.Value);
}
}
UInt32 additionalReinforcements = 0;
if (seenValues.Count == 1)
{
additionalReinforcements = seenValues.First();
}
else if (seenValues.Count == 3)
{
additionalReinforcements = 9;
}
else
{
await batchOperation.Abort();
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "Invalid combination of card(s) specified"
});
}
INationData nation = await nationDataTask;
NationRepository.SetAvailableReinforcements(batchOperation, sessionId, nation.UserId, nation.CurrentEtag, nation.AvailableReinforcements + additionalReinforcements);
await batchOperation.CommitBatch();
}
}
public NationController(NationRepository nationRepository)
{
this.nationRepository = nationRepository;
}
public StudentController(StudentRepository user, NationRepository nat, ReligionRepository rel)
{
studentRepository = user;
nationRepository = nat;
religionRepository = rel;
}
