コード例 #1
0
        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);
        }
コード例 #2
0
        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);
        }
コード例 #3
0
        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);
        }
コード例 #4
0
        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);
        }
コード例 #5
0
        public async Task IntegrationTestOrderAttack()
        {
            // Arrange
            CommandQueue repository       = new CommandQueue(DevelopmentStorageAccountConnectionString);
            Guid         targetRegionGuid = new Guid("8449A25B-363D-4F01-B3D9-7EF8C5D42047");

            // Act
            Guid operationGuid;

            using (IBatchOperationHandle batchOperation = new BatchOperationHandle(CommandTable))
            {
                operationGuid = await repository.OrderAttack(batchOperation, SessionGuid, SessionPhaseGuid, RegionGuid, "DummyEtag", targetRegionGuid, 5U);
            }

            // Assert
            var operation = TableOperation.Retrieve <CommandQueueTableEntry>(SessionGuid.ToString(), "Command_" + RegionGuid.ToString() + "_" + targetRegionGuid.ToString());
            var result    = await CommandTable.ExecuteAsync(operation);

            CommandQueueTableEntry queuedCommand = result.Result as CommandQueueTableEntry;

            Assert.IsNotNull(queuedCommand);
            Assert.AreEqual(operationGuid, queuedCommand.OperationId);
            Assert.AreEqual(SessionGuid, queuedCommand.SessionId);
            Assert.AreEqual(SessionPhaseGuid, queuedCommand.PhaseId);
            Assert.AreEqual(CommandQueueMessageType.Attack, queuedCommand.MessageType);
            Assert.AreEqual(RegionGuid, queuedCommand.SourceRegion);
            Assert.AreEqual("DummyEtag", queuedCommand.SourceRegionEtag);
            Assert.AreEqual(targetRegionGuid, queuedCommand.TargetRegion);
            Assert.AreEqual(5U, queuedCommand.NumberOfTroops);
        }
コード例 #6
0
        public async Task IntegrationTestOrderAttack_MergeWithExisting()
        {
            // Arrange
            CommandQueue           repository         = new CommandQueue(DevelopmentStorageAccountConnectionString);
            Guid                   targetRegionGuid   = new Guid("7E3BCD95-EB8B-4401-A987-F613A3428676");
            Guid                   initialOperationId = Guid.NewGuid();
            CommandQueueTableEntry newCommand         = CommandQueueTableEntry.CreateAttackMessage(initialOperationId, SessionGuid, SessionPhaseGuid, RegionGuid, "DummyEtag", targetRegionGuid, 5U);

            CommandTable.Execute(TableOperation.Insert(newCommand));

            // Act
            Guid operationGuid;

            using (IBatchOperationHandle batchOperation = new BatchOperationHandle(CommandTable))
            {
                operationGuid = await repository.OrderAttack(batchOperation, SessionGuid, SessionPhaseGuid, RegionGuid, "DummyEtag", targetRegionGuid, 4U);
            }

            // Assert
            var operation = TableOperation.Retrieve <CommandQueueTableEntry>(SessionGuid.ToString(), "Command_" + RegionGuid.ToString() + "_" + targetRegionGuid.ToString());
            var result    = await CommandTable.ExecuteAsync(operation);

            CommandQueueTableEntry queuedCommand = result.Result as CommandQueueTableEntry;

            Assert.IsNotNull(queuedCommand);
            Assert.AreEqual(operationGuid, queuedCommand.OperationId);
            Assert.AreNotEqual(operationGuid, initialOperationId);
            Assert.AreEqual(SessionGuid, queuedCommand.SessionId);
            Assert.AreEqual(SessionPhaseGuid, queuedCommand.PhaseId);
            Assert.AreEqual(CommandQueueMessageType.Attack, queuedCommand.MessageType);
            Assert.AreEqual(RegionGuid, queuedCommand.SourceRegion);
            Assert.AreEqual("DummyEtag", queuedCommand.SourceRegionEtag);
            Assert.AreEqual(targetRegionGuid, queuedCommand.TargetRegion);
            Assert.AreEqual(9U, queuedCommand.NumberOfTroops);
        }
コード例 #7
0
        public async Task IntegrationTestGetRegions()
        {
            // Arrange
            RegionRepository repository          = new RegionRepository(DevelopmentStorageAccountConnectionString, String.Empty);
            Guid             dummySessionId      = new Guid("74720766-452A-40AD-8A61-FEF07E8573C9");
            Guid             dummyRegionId       = new Guid("CBDF6EBE-5F91-4ADF-AC30-D149D8E5F8EB");
            Guid             secondDummyRegionId = new Guid("336312D8-F219-4C9B-B3FE-F4B39602E28D");
            Guid             dummyContinentId    = new Guid("DE167712-0CE6-455C-83EA-CB2A6936F1BE");

            TableClient.SetupSessionDataTable(dummySessionId);
            using (IBatchOperationHandle batchOperation = new BatchOperationHandle(SessionRepository.GetTableForSessionData(TableClient, dummySessionId)))
            {
                repository.CreateRegion(batchOperation, dummySessionId, dummyRegionId, dummyContinentId, "DummyRegion", new List <Guid>(), 0);
                repository.CreateRegion(batchOperation, dummySessionId, secondDummyRegionId, dummyContinentId, "DummyRegion2", new List <Guid>(), 0);
            }

            // Act
            IEnumerable <IRegionData> regionData = await repository.GetRegions(dummySessionId);

            // Assert
            Assert.IsNotNull(regionData);
            Assert.IsTrue(regionData.Count() >= 2, "Expected at least two regions");
            Assert.AreEqual(1, regionData.Where(region => region.RegionId == dummyRegionId).Count());
            Assert.AreEqual(1, regionData.Where(region => region.RegionId == secondDummyRegionId).Count());
        }
コード例 #8
0
        public async Task IntegrationTestAddArmyToCombat()
        {
            // Arrange
            WorldRepository  repository         = new WorldRepository(DevelopmentStorageAccountConnectionString);
            Guid             combatId           = new Guid("0DAAF6DD-E1D6-42BA-B3ED-749BB7652C8E");
            Guid             attackingRegionId  = new Guid("5EA3D204-63EA-4683-913E-C5C3609BD893");
            Guid             attacking2RegionId = new Guid("E0675161-4192-4C33-B8BB-3B6D763725E2");
            Guid             attacking3RegionId = new Guid("CA563328-5743-4EC0-AA39-D7978DE44872");
            Guid             defendingRegionId  = new Guid("6DC3039A-CC79-4CAC-B7CE-37E1B1565A6C");
            CombatTableEntry tableEntry         = new CombatTableEntry(SessionId, 1, combatId, CombatType.MassInvasion);

            tableEntry.SetCombatArmy(new List <ICombatArmy>
            {
                new CombatArmy(attackingRegionId, "AttackingUser", Core.CombatArmyMode.Attacking, 5),
                new CombatArmy(defendingRegionId, "DefendingUser", Core.CombatArmyMode.Defending, 4)
            });

            CloudTable testTable = SessionRepository.GetTableForSessionData(TableClient, SessionId);

            testTable.CreateIfNotExists();
            TableOperation insertOperation = TableOperation.Insert(tableEntry);
            await testTable.ExecuteAsync(insertOperation);

            // Act
            using (BatchOperationHandle batchOperation = new BatchOperationHandle(testTable))
            {
                repository.AddArmyToCombat(batchOperation, tableEntry, new List <ICombatArmy>
                {
                    new CombatArmy(attacking2RegionId, "AttackingUser", Core.CombatArmyMode.Attacking, 6),
                    new CombatArmy(attacking3RegionId, "AttackingUser2", Core.CombatArmyMode.Attacking, 3)
                });
            }

            // Assert
            TableOperation operation = TableOperation.Retrieve <CombatTableEntry>(SessionId.ToString(), "Combat_" + combatId.ToString());
            TableResult    result    = await testTable.ExecuteAsync(operation);

            Assert.IsNotNull(result.Result);
            Assert.IsInstanceOfType(result.Result, typeof(CombatTableEntry));
            CombatTableEntry resultStronglyTyped = result.Result as CombatTableEntry;

            Assert.AreEqual(SessionId, resultStronglyTyped.SessionId);
            Assert.AreEqual(combatId, resultStronglyTyped.CombatId);
            Assert.AreEqual(1, resultStronglyTyped.Round);
            Assert.AreEqual(CombatType.MassInvasion, resultStronglyTyped.ResolutionType);
            Assert.AreEqual(4, resultStronglyTyped.InvolvedArmies.Count());

            AssertCombat.IsAttacking(attackingRegionId, 5, "AttackingUser", resultStronglyTyped);
            AssertCombat.IsAttacking(attacking2RegionId, 6, "AttackingUser", resultStronglyTyped);
            AssertCombat.IsAttacking(attacking3RegionId, 3, "AttackingUser2", resultStronglyTyped);
            AssertCombat.IsDefending(defendingRegionId, 4, "DefendingUser", resultStronglyTyped);
        }
コード例 #9
0
        public async Task IntegrationTestCreateRegion()
        {
            // Arrange
            RegionRepository repository       = new RegionRepository(DevelopmentStorageAccountConnectionString, String.Empty);
            Guid             dummySessionId   = new Guid("74720766-452A-40AD-8A61-FEF07E8573C9");
            Guid             dummyRegionId    = new Guid("024D1E45-EF34-4AB1-840D-79229CCDE8C3");
            Guid             dummyContinentId = new Guid("DE167712-0CE6-455C-83EA-CB2A6936F1BE");
            List <Guid>      dummyConnections = new List <Guid> {
                new Guid("0533203F-13F2-4863-B528-17F53D279E19"), new Guid("4A9779D0-0727-4AD9-AD66-17AE9AF9BE02")
            };
            var dataTable = TableClient.SetupSessionDataTable(dummySessionId);

            // Act
            using (IBatchOperationHandle batchOperation = new BatchOperationHandle(SessionRepository.GetTableForSessionData(TableClient, dummySessionId)))
            {
                repository.CreateRegion(batchOperation, dummySessionId, dummyRegionId, dummyContinentId, "DummyRegion", dummyConnections, 3);
            }

            // Assert
            TableOperation operation = TableOperation.Retrieve <RegionTableEntry>(dummySessionId.ToString(), "Region_" + dummyRegionId.ToString());
            TableResult    result    = await dataTable.ExecuteAsync(operation);

            Assert.IsNotNull(result.Result);
            Assert.IsInstanceOfType(result.Result, typeof(RegionTableEntry));
            RegionTableEntry resultStronglyTyped = result.Result as RegionTableEntry;

            Assert.AreEqual(dummySessionId, resultStronglyTyped.SessionId);
            Assert.AreEqual(dummyRegionId, resultStronglyTyped.RegionId);
            Assert.AreEqual(dummyContinentId, resultStronglyTyped.ContinentId);
            Assert.AreEqual("DummyRegion", resultStronglyTyped.Name);
            Assert.AreEqual(String.Empty, resultStronglyTyped.OwnerId);
            Assert.AreEqual(3U, resultStronglyTyped.CardValue);
            Assert.AreEqual(0, resultStronglyTyped.StoredTroopCount);
            Assert.IsTrue(resultStronglyTyped.ETag.Length > 0);
            Assert.IsTrue(resultStronglyTyped.ConnectedRegions.Contains(dummyConnections[0]));

            TableOperation cardOperation = TableOperation.Retrieve <CardTableEntry>(dummySessionId.ToString(), "Card_" + dummyRegionId.ToString());

            result = await dataTable.ExecuteAsync(cardOperation);

            Assert.IsNotNull(result.Result);
            Assert.IsInstanceOfType(result.Result, typeof(CardTableEntry));
            CardTableEntry cardStronglyTyped = result.Result as CardTableEntry;

            Assert.AreEqual(dummySessionId, cardStronglyTyped.SessionId);
            Assert.AreEqual(dummyRegionId, cardStronglyTyped.RegionId);
            Assert.AreEqual(3U, cardStronglyTyped.Value);
            Assert.AreEqual(String.Empty, cardStronglyTyped.OwnerId);
            Assert.AreEqual(CardTableEntry.State.Unowned, cardStronglyTyped.OwnerState);
        }
コード例 #10
0
        public async Task IntegrationTestStressTestAttacks()
        {
            var primaryUser   = new ControllerAzure(DevelopmentStorageAccountConnectionString, @"WorldData\FullWorldDefinition.xml");
            var secondaryUser = new ControllerAzure(DevelopmentStorageAccountConnectionString, @"WorldData\FullWorldDefinition.xml", DummyUserRepository.RegisteredUserIds[1]);

            // Start new session
            var sessionDetails = await primaryUser.GameController.PostStartNewSession(Core.PlayerColour.Black);

            await secondaryUser.GameController.PostJoinSession(sessionDetails.GameId, Core.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)
            sessionDetails = await primaryUser.GameController.GetSession(sessionDetails.GameId);

            await primaryUser.GameController.PostAdvanceNextPhase(sessionDetails.GameId, sessionDetails.PhaseId, true);

            // Ensure primary user has enough troops for the test
            using (IBatchOperationHandle batchOperation = new BatchOperationHandle(primaryUser.AzureSessionRepository.GetTableForSessionData(sessionDetails.GameId)))
            {
                primaryUser.AzureNationRepository.SetAvailableReinforcements(batchOperation, sessionDetails.GameId, primaryUser.OwnerId, "*", 2000);
            }

            // Deploy initial troops for primary user
            await Controllers.IntegrationTest.RandomlyDeployReinforcements(primaryUser.GameController, primaryUser.NationController, primaryUser.WorldController, primaryUser.RegionController, sessionDetails.GameId, primaryUser.OwnerId);

            // Move into combat phase (with primary user)
            sessionDetails = await primaryUser.GameController.GetSession(sessionDetails.GameId);

            await primaryUser.GameController.PostAdvanceNextPhase(sessionDetails.GameId, sessionDetails.PhaseId, true);

            // Attempt to issue 1000 random attack orders for primary user
            UInt32 numberOfAttacks = await Controllers.IntegrationTest.BulkRandomlyAttack(primaryUser.GameController, primaryUser.WorldController, primaryUser.AzureRegionRepository, primaryUser.AzureSessionRepository, sessionDetails.GameId, primaryUser.OwnerId, 1, 1000);

            Assert.AreNotEqual(0, numberOfAttacks);

            // 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 Controllers.IntegrationTest.ResolveAllCombat(primaryUser.GameController, sessionDetails.GameId);
        }
コード例 #11
0
        public async Task IntegrationTestAddCombat()
        {
            // Arrange
            WorldRepository repository        = new WorldRepository(DevelopmentStorageAccountConnectionString);
            Guid            attackingRegionId = new Guid("4CD8D6E1-8FFE-48E1-8FE0-B89BCDD0AA96");
            Guid            defendingRegionId = new Guid("E0FE9A73-4125-4DA1-A113-25ED927EA7B4");

            CloudTable testTable = SessionRepository.GetTableForSessionData(TableClient, SessionId);

            testTable.CreateIfNotExists();

            // Act
            using (IBatchOperationHandle batchOperation = new BatchOperationHandle(testTable))
            {
                repository.AddCombat(batchOperation, SessionId, 2, new List <Tuple <CombatType, IEnumerable <ICombatArmy> > >
                {
                    Tuple.Create <CombatType, IEnumerable <ICombatArmy> >(CombatType.MassInvasion, new List <ICombatArmy>
                    {
                        new CombatArmy(attackingRegionId, "AttackingUser", Core.CombatArmyMode.Attacking, 5),
                        new CombatArmy(defendingRegionId, "DefendingUser", Core.CombatArmyMode.Defending, 4)
                    })
                });
            }

            // Assert
            IEnumerable <ICombat> combatList = await repository.GetCombat(SessionId, 2);

            Assert.IsNotNull(combatList);
            Assert.AreEqual(1, combatList.Count());
            ICombat combat = combatList.First();

            Assert.IsInstanceOfType(combat, typeof(CombatTableEntry));
            CombatTableEntry resultStronglyTyped = combat as CombatTableEntry;

            Assert.AreEqual(SessionId, resultStronglyTyped.SessionId);
            Assert.IsNotNull(resultStronglyTyped.CombatId);
            Assert.AreEqual(CombatType.MassInvasion, resultStronglyTyped.ResolutionType);
            Assert.AreEqual(2, resultStronglyTyped.InvolvedArmies.Count());

            AssertCombat.IsAttacking(attackingRegionId, 5, "AttackingUser", resultStronglyTyped);
            AssertCombat.IsDefending(defendingRegionId, 4, "DefendingUser", resultStronglyTyped);
        }
コード例 #12
0
        public async Task IntegrationTestRemoveCommands()
        {
            // Arrange
            CommandQueue repository         = new CommandQueue(DevelopmentStorageAccountConnectionString);
            Guid         sessionId          = Guid.NewGuid();
            CloudTable   randomCommandTable = CommandQueue.GetCommandQueueTableForSession(TableClient, sessionId);

            randomCommandTable.CreateIfNotExists();
            Guid attackId;
            Guid attackSecondId;
            Guid secondRegionId = Guid.NewGuid();

            using (IBatchOperationHandle batchOperation = new BatchOperationHandle(randomCommandTable))
            {
                attackId = await repository.OrderAttack(batchOperation, sessionId, sessionId, sessionId, String.Empty, sessionId, 0);

                attackSecondId = await repository.OrderAttack(batchOperation, sessionId, sessionId, sessionId, String.Empty, secondRegionId, 0);
            }
            var queuedAttacks = await repository.GetQueuedCommands(sessionId, sessionId);

            // Act
            using (BatchOperationHandle handle = new BatchOperationHandle(randomCommandTable))
            {
                repository.RemoveCommands(handle, new List <ICommandQueueMessage> {
                    queuedAttacks.Where(attack => attack.OperationId == attackId).First()
                });
            }

            // Assert
            var tableQuery = from entity in randomCommandTable.CreateQuery <CommandQueueTableEntry>()
                             select entity;
            var tableData = tableQuery.ToList();

            Assert.AreEqual(1, tableData.Count);
            CommandQueueTableEntry result = tableData.First();

            Assert.AreEqual(attackSecondId, result.OperationId);
        }
コード例 #13
0
        public async Task IntegrationTestAssignRegionOwnership()
        {
            // Arrange
            RegionRepository repository          = new RegionRepository(DevelopmentStorageAccountConnectionString, String.Empty);
            Guid             dummySessionId      = new Guid("7C76A14F-DA7F-4AEC-9AF4-DDC77C6122CD");
            Guid             dummyRegionId       = new Guid("CBDF6EBE-5F91-4ADF-AC30-D149D8E5F8EB");
            Guid             secondDummyRegionId = new Guid("336312D8-F219-4C9B-B3FE-F4B39602E28D");
            Guid             dummyContinentId    = new Guid("DE167712-0CE6-455C-83EA-CB2A6936F1BE");

            TableClient.SetupSessionDataTable(dummySessionId);
            using (IBatchOperationHandle batchOperation = new BatchOperationHandle(SessionRepository.GetTableForSessionData(TableClient, dummySessionId)))
            {
                repository.CreateRegion(batchOperation, dummySessionId, dummyRegionId, dummyContinentId, "DummyRegion", new List <Guid>(), 0);
                repository.CreateRegion(batchOperation, dummySessionId, secondDummyRegionId, dummyContinentId, "DummyRegion2", new List <Guid>(), 0);
            }

            // Act
            using (IBatchOperationHandle batchOperation = new BatchOperationHandle(SessionRepository.GetTableForSessionData(TableClient, dummySessionId)))
            {
                repository.AssignRegionOwnership(batchOperation, dummySessionId, new Dictionary <Guid, OwnershipChange>
                {
                    { dummyRegionId, new OwnershipChange("DummyUser", 10) },
                    { secondDummyRegionId, new OwnershipChange("DummyUser2", 20) }
                });
            }

            // Assert
            IEnumerable <IRegionData> regionData = await repository.GetRegions(dummySessionId);

            Assert.IsNotNull(regionData);
            Assert.AreEqual(2, regionData.Count());
            Assert.AreEqual("DummyUser", regionData.Where(region => region.RegionId == dummyRegionId).First().OwnerId);
            Assert.AreEqual(10U, regionData.Where(region => region.RegionId == dummyRegionId).First().TroopCount);
            Assert.AreEqual(0U, regionData.Where(region => region.RegionId == dummyRegionId).First().TroopsCommittedToPhase);
            Assert.AreEqual("DummyUser2", regionData.Where(region => region.RegionId == secondDummyRegionId).First().OwnerId);
            Assert.AreEqual(20U, regionData.Where(region => region.RegionId == secondDummyRegionId).First().TroopCount);
            Assert.AreEqual(0U, regionData.Where(region => region.RegionId == secondDummyRegionId).First().TroopsCommittedToPhase);
        }
コード例 #14
0
        public async Task IntegrationTestGetRegion()
        {
            // Arrange
            RegionRepository repository       = new RegionRepository(DevelopmentStorageAccountConnectionString, String.Empty);
            Guid             dummySessionId   = new Guid("74720766-452A-40AD-8A61-FEF07E8573C9");
            Guid             dummyRegionId    = new Guid("89B6BDF0-83B7-42F1-B216-7DFFB8D11EA2");
            Guid             dummyContinentId = new Guid("DE167712-0CE6-455C-83EA-CB2A6936F1BE");
            List <Guid>      dummyConnections = new List <Guid> {
                new Guid("0533203F-13F2-4863-B528-17F53D279E19"), new Guid("4A9779D0-0727-4AD9-AD66-17AE9AF9BE02")
            };

            TableClient.SetupSessionDataTable(dummySessionId);
            using (IBatchOperationHandle batchOperation = new BatchOperationHandle(SessionRepository.GetTableForSessionData(TableClient, dummySessionId)))
            {
                repository.CreateRegion(batchOperation, dummySessionId, dummyRegionId, dummyContinentId, "DummyRegion", dummyConnections, 0);
            }

            // Act
            IRegionData regionData = await repository.GetRegion(dummySessionId, dummyRegionId);

            // Assert
            Assert.IsNotNull(regionData);
            Assert.AreEqual(dummySessionId, regionData.SessionId);
        }
コード例 #15
0
ファイル: IntegrationTest.cs プロジェクト: StephenE/DevoLAN
        internal static async Task <UInt32> BulkRandomlyAttack(GameController game, WorldController world, RegionRepository regionRepository, SessionRepository sessionRepository, Guid sessionId, String ownerId, UInt32 troopCount, UInt32 numberOfAttacks)
        {
            ISession session = await game.GetSession(sessionId);

            // Get owned regions
            List <CommandQueueTableEntry> attacksToQueue = new List <CommandQueueTableEntry>();
            IEnumerable <Guid>            ownedRegions   = await GetCurrentlyOwnedRegions(world, sessionId, ownerId);

            IEnumerable <IRegionData> worldRegionList = await regionRepository.GetRegions(sessionId);

            Dictionary <Guid, IRegionData> worldRegionLookup = worldRegionList.ToDictionary(region => region.RegionId);
            UInt32 numberOfRequestedAttacks = numberOfAttacks;

            // Create attack table entries
            foreach (Guid ownedRegionId in ownedRegions)
            {
                IRegionData details = worldRegionLookup[ownedRegionId];
                if (details.TroopCount > 1 && numberOfAttacks > 0)
                {
                    foreach (Guid adjacentRegionId in details.ConnectedRegions)
                    {
                        IRegionData targetDetails = worldRegionLookup[adjacentRegionId];
                        UInt32      troopsInRegionToAttackWith = details.TroopCount - 1;
                        if (targetDetails.OwnerId != ownerId)
                        {
                            UInt32 troopsToAttackWith = Math.Min(details.TroopCount - 1, troopCount);

                            attacksToQueue.Add(CommandQueueTableEntry.CreateAttackMessage(Guid.NewGuid(), session.GameId, session.PhaseId, details.RegionId, details.CurrentEtag, targetDetails.RegionId, troopsToAttackWith));
                            troopsInRegionToAttackWith -= troopsToAttackWith;
                            numberOfAttacks            -= 1;
                        }

                        if (numberOfAttacks == 0 || troopsInRegionToAttackWith == 0)
                        {
                            break;
                        }
                    }
                }

                if (numberOfAttacks == 0)
                {
                    break;
                }
            }

            // Batch insert operations
            using (BatchOperationHandle batchOperation = new BatchOperationHandle(sessionRepository.GetTableForSessionData(sessionId)))
            {
                for (int counter = 0; counter < attacksToQueue.Count; ++counter)
                {
                    batchOperation.BatchOperation.Insert(attacksToQueue[counter]);

                    if (batchOperation.RemainingCapacity == 0)
                    {
                        await batchOperation.CommitBatch();
                    }
                }
            }

            // End attack phase
            await game.PostEndPhase(session.GameId, session.PhaseId);

            return(numberOfRequestedAttacks - numberOfAttacks);
        }