public async void ValidSessionTokenAccepted()
{
// Skipping test if auth is disabled.
if (!SagaNetwork.Authorization.IsEnabled)
{
return;
}
var playerId = "Test_ValidSessionTokenAccepted";
// Create test player if it doesn't exist.
await Helpers.CreateTestPlayer(playerId, replace : false);
// Acquiring a valid session token.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}'
}}");
// Execute controller.
var controller = new CheckAuthController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is WrongPassword.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
}
public async void ResourcesAdded()
{
const string playerId = "Test_ResourcesAdded";
var resourcesToAdd = new List <int> {
100, 0, 50, 5000, 1, 0, 999
};
// Create test player.
var player = await Helpers.CreateTestPlayer(playerId);
// Auth player.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
{Helpers.JsonServerCredentials},
'Resources':'{JsonConvert.SerializeObject(resourcesToAdd)}'
}}");
// Execute controller.
var controller = new AddResourcesController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Make sure resources is added.
player = await player.LoadAsync();
Assert.Equal(player.Resources, resourcesToAdd);
}
public async void UnlockingFinished()
{
var wardMetaId = "Test_UnlockingFinished";
var unlockTime = TimeSpan.FromMilliseconds(500);
var playerId = "Test_UnlockingFinished";
// Create test builidng meta if it doesn't exist.
var wardMeta = await new WardMeta(wardMetaId).LoadAsync();
if (wardMeta == null)
{
wardMeta = new WardMeta(wardMetaId);
wardMeta.UnlockTime = unlockTime;
wardMeta.UnlockReward = new Reward()
{
Resources = new List <int> {
100
}, RandomCitizens = 1
};
await wardMeta.InsertAsync();
}
// Create test player and ward.
var ward = new Ward(wardMetaId);
ward.UnlockTask = new TimeTask(wardMeta.UnlockTime);
var player = await Helpers.CreateTestPlayer(playerId, ward : ward);
// Wait for ward to unlock.
Thread.Sleep(unlockTime);
// Auth player.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'WardId':'{ward.Id}'
}}");
// Execute controller.
var controller = new FinishWardUnlockingController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Make sure building is constructed.
player = await player.LoadAsync();
Assert.True(player.GetWardById(ward.Id).IsUnlocked);
// Make sure reward is awarded.
Assert.True(player.Resources.Count > 0);
Assert.False(player.HasFreeCitizenSlot);
}
public async void AvailableCharacterSelected()
{
var buildingMetaId = "Test_AvailableCharacterSelected";
var classMetaId = "Test_AvailableCharacterSelected";
var playerId = "Test_AvailableCharacterSelected";
var characterIndex = 0;
// Create test class meta if it doesn't exist.
var classMeta = await new ClassMeta(classMetaId).LoadAsync();
if (classMeta == null)
{
classMeta = new ClassMeta(classMetaId);
classMeta.Requirement = new Requirement()
{
BuildingMetaIds = new List <string> {
buildingMetaId
}
};
await classMeta.InsertAsync();
}
// Create test player, character and required building.
var building = new Building(buildingMetaId);
building.IsConstructed = true;
var character = new Character(classMetaId);
var player = await Helpers.CreateTestPlayer(playerId, building : building, character : character);
// Auth player.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'CharacterIndex':{characterIndex}
}}");
// Execute controller.
var controller = new SelectCharacterController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Make sure char is selected for the first time (req-free).
player = await player.LoadAsync();
Assert.True(player.SelectedCharacterIndex == characterIndex);
// Make sure char is selected for the second time (with req checked).
responseToken = await controller.HandleHttpRequestAsync(data);
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
}
public async void LevelIncreased()
{
var classMetaId = "Test_LevelIncreased2";
var playerId = "Test_LevelIncreased2";
var expToAdd = 700;
var charIndex = 0;
// Create test class meta if it doesn't exist.
var classMeta = await new ClassMeta(classMetaId).LoadAsync();
if (classMeta == null)
{
classMeta = new ClassMeta(classMetaId);
classMeta.ExpToLevelUp = new List <int>()
{
0, 100, 200, 300, 500
};
await classMeta.InsertAsync();
}
// Create test player.
var player = await Helpers.CreateTestPlayer(playerId);
player.Characters.Add(new Character(classMetaId));
await player.ReplaceAsync();
// Auth player.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
{Helpers.JsonServerCredentials},
'Experience':'{expToAdd}',
'CharacterIndex':'{charIndex}'
}}");
// Execute controller.
var controller = new AddExperienceController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Assert new level is set in response.
Assert.Equal(responseToken["NewLevel"], 3);
// Make sure level is added to character.
player = await player.LoadAsync();
Assert.Equal(player.Characters[0].Level, 3);
// Make sure talent points are added to character.
Assert.Equal(player.Characters[0].TalentPoints, 3);
}
public async void ConstructionOnAvailableSpotStarted()
{
var size = "XXL";
var buildingMetaId = "Test_ConstructionOnAvailableSpotStarted";
var buildingSpotMetaId = "Test_ConstructionOnAvailableSpotStarted";
var playerId = "Test_ConstructionOnAvailableSpotStarted";
// Create test builidng meta if it doesn't exist.
var buildingMeta = await new BuildingMeta(buildingMetaId).LoadAsync();
if (buildingMeta == null)
{
buildingMeta = new BuildingMeta(buildingMetaId);
buildingMeta.Size = size;
await buildingMeta.InsertAsync();
}
// Create test builidng spot meta if it doesn't exist.
var buildingSpotMeta = await new BuildingSpotMeta(buildingSpotMetaId).LoadAsync();
if (buildingSpotMeta == null)
{
buildingSpotMeta = new BuildingSpotMeta(buildingSpotMetaId);
buildingSpotMeta.Size = size;
await buildingSpotMeta.InsertAsync();
}
// Create test player and building spot.
var buildingSpot = new BuildingSpot(buildingSpotMetaId);
var player = await Helpers.CreateTestPlayer(playerId, buildingSpot : buildingSpot);
// Auth player.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'BuildingSpotId':'{buildingSpot.Id}',
'BuildingMetaId':'{buildingMetaId}',
}}");
// Execute controller.
var controller = new StartBuildingConstructionController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Make sure building construction is started.
player = await player.LoadAsync();
Assert.False(player.GetBuildingSpotById(buildingSpot.Id).Building.IsConstructed);
}
public async void RequisitesForAvailableInstanceProvided()
{
var playerId = "Test_RequisitesForAvailableInstanceProvided";
var serverIp = "Test_RequisitesForAvailableInstanceProvided";
var instancePort = "Test_RequisitesForAvailableInstanceProvided";
var arenaMetaId = "Test_RequisitesForAvailableInstanceProvided";
// Create test arena meta if it doesn't exist.
var arenaMeta = await new ArenaMeta(arenaMetaId).LoadAsync();
if (arenaMeta == null)
{
arenaMeta = new ArenaMeta(arenaMetaId);
arenaMeta.MaxPlayers = 10;
await arenaMeta.InsertAsync();
}
// Create test server with test instance.
var instance = new ArenaInstance(arenaMetaId, instancePort);
var server = await Helpers.CreateTestServer(serverIp, instance : instance);
// Create and auth test player.
await Helpers.CreateTestPlayer(playerId);
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'ArenaMetaId':'{arenaMetaId}'
}}");
// Execute controller.
var conrtoller = new RequestInstanceController();
var responseToken = await conrtoller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Assert returned IP and port are valid.
Assert.Equal(responseToken["Ip"], serverIp);
Assert.Equal(responseToken["Port"], instancePort);
// Make sure instance free slot was removed.
server = await server.LoadAsync();
Assert.True(server.ActiveInstances[0].FreeSlots == 9);
}
public async void FinishedConstructionIsConstructed()
{
var buildingMetaId = "Test_FinishedConstructionIsConstructed";
var buildingConstructionTime = TimeSpan.FromMilliseconds(500);
var playerId = "Test_FinishedConstructionIsConstructed";
// Create test builidng meta if it doesn't exist.
var buildingMeta = await new BuildingMeta(buildingMetaId).LoadAsync();
if (buildingMeta == null)
{
buildingMeta = new BuildingMeta(buildingMetaId);
buildingMeta.ConstructionTime = buildingConstructionTime;
await buildingMeta.InsertAsync();
}
// Create test player and building.
var building = new Building(buildingMetaId);
building.IsConstructed = false;
building.ConstructionTask = new TimeTask(buildingMeta.ConstructionTime);
var player = await Helpers.CreateTestPlayer(playerId, building : building);
// Wait for building to construct.
Thread.Sleep(buildingConstructionTime);
// Auth player.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'BuildingId':'{building.Id}'
}}");
// Execute controller.
var controller = new FinishBuildingConstructionController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Make sure building is constructed.
player = await player.LoadAsync();
Assert.True(player.GetBuildingById(building.Id).IsConstructed);
}
public async void ClosedInstanceWontAcceptJoinRequests()
{
var playerId = "Test_ClosedInstanceWontAcceptJoinRequests";
var arenaMetaId = "Test_ClosedInstanceWontAcceptJoinRequests";
var serverIp = "Test_ClosedInstanceWontAcceptJoinRequests";
var instancePort = "Test_ClosedInstanceWontAcceptJoinRequests";
// Create test arena meta if it doesn't exist.
var arenaMeta = await new ArenaMeta(arenaMetaId).LoadAsync();
if (arenaMeta == null)
{
arenaMeta = new ArenaMeta(arenaMetaId);
await arenaMeta.InsertAsync();
}
// Create test server with a closed instance.
var instance = new ArenaInstance(arenaMetaId, instancePort);
instance.FreeSlots = 2;
instance.IsOpen = false;
var server = await Helpers.CreateTestServer(serverIp, instance : instance);
// Create and auth test player.
await Helpers.CreateTestPlayer(playerId);
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'ArenaMetaId':'{arenaMetaId}'
}}");
// Execute controller.
var conrtoller = new RequestInstanceController();
var responseToken = await conrtoller.HandleHttpRequestAsync(data);
// Assert controller response status is Wait.
Assert.Equal(responseToken["Status"], JStatus.Wait.JToken["Status"]);
// Make sure a new instance is requested.
var requestedInstance = await new RequestedInstance(arenaMetaId).LoadAsync();
Assert.NotNull(requestedInstance);
}
public async void UnlockingNotReady()
{
var wardMetaId = "Test_UnlockingNotReady";
var unlockTime = TimeSpan.FromMinutes(10);
var playerId = "Test_UnlockingNotReady";
// Create test builidng meta if it doesn't exist.
var wardMeta = await new WardMeta(wardMetaId).LoadAsync();
if (wardMeta == null)
{
wardMeta = new WardMeta(wardMetaId);
wardMeta.UnlockTime = unlockTime;
await wardMeta.InsertAsync();
}
// Create test player and ward.
var ward = new Ward(wardMetaId);
ward.UnlockTask = new TimeTask(wardMeta.UnlockTime);
var player = await Helpers.CreateTestPlayer(playerId, ward : ward);
// Auth player.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'WardId':'{ward.Id}'
}}");
// Execute controller.
var controller = new FinishWardUnlockingController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is NotReady.
Assert.Equal(responseToken["Status"], JStatus.NotReady.JToken["Status"]);
// Make sure ward is not unlocked.
player = await player.LoadAsync();
Assert.False(player.GetWardById(ward.Id).IsUnlocked);
}
public async void UnlockingStarted()
{
var wardMetaId = "Test_UnlockingStarted";
var playerId = "Test_UnlockingStarted";
// Create test ward meta if it doesn't exist.
var wardMeta = await new WardMeta(wardMetaId).LoadAsync();
if (wardMeta == null)
{
wardMeta = new WardMeta(wardMetaId);
await wardMeta.InsertAsync();
}
// Create test player and ward.
var ward = new Ward(wardMetaId);
var player = await Helpers.CreateTestPlayer(playerId, ward : ward);
// Auth player.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'WardId':'{ward.Id}',
}}");
// Execute controller.
var controller = new StartWardUnlockingController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Make sure unlock is started.
player = await player.LoadAsync();
Assert.False(player.GetWardById(ward.Id).IsUnlocked);
Assert.True(player.GetWardById(ward.Id)?.UnlockTask != null);
}
public async void UnavailableInstanceRequested()
{
var playerId = "Test_UnavailableInstanceRequested";
var arenaMetaId = "Test_UnavailableInstanceRequested";
// Create test arena meta if it doesn't exist.
var arenaMeta = await new ArenaMeta(arenaMetaId).LoadAsync();
if (arenaMeta == null)
{
arenaMeta = new ArenaMeta(arenaMetaId);
await arenaMeta.InsertAsync();
}
// Create and auth test player.
await Helpers.CreateTestPlayer(playerId);
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'ArenaMetaId':'{arenaMetaId}'
}}");
// Execute controller.
var conrtoller = new RequestInstanceController();
var responseToken = await conrtoller.HandleHttpRequestAsync(data);
// Assert controller response status is Wait.
Assert.Equal(responseToken["Status"], JStatus.Wait.JToken["Status"]);
// Make sure instance is requested.
var requestedInstance = await new RequestedInstance(arenaMetaId).LoadAsync();
Assert.NotNull(requestedInstance);
}
public async void RandomCitizenGenerated()
{
var testId = "Test_RandomCitizenGenerated";
// Create test rarity group meta if it doesn't exist.
var rarityGroup = await new RarenessGroup(testId).LoadAsync();
if (rarityGroup == null)
{
rarityGroup = new RarenessGroup(testId);
rarityGroup.AbilityLimit = 1;
rarityGroup.AbilityMaxLevel = 5;
rarityGroup.ProbabilityWeight = 50;
await rarityGroup.InsertAsync();
}
// Create test appearance meta if it doesn't exist.
var appearance = await new AppearanceElementMeta(testId).LoadAsync();
if (appearance == null)
{
appearance = new AppearanceElementMeta(testId);
appearance.AppearanceGroup = AppearanceGroup.Face;
await appearance.InsertAsync();
}
// Create test citizen ability meta if it doesn't exist.
var abilityMeta = await new CitizenAbilityMeta(testId).LoadAsync();
if (abilityMeta == null)
{
abilityMeta = new CitizenAbilityMeta(testId);
abilityMeta.ProbabilityWeight = 50;
abilityMeta.ExpToLevelUp = new List <int>()
{
10, 30, 80
};
await abilityMeta.InsertAsync();
}
// Create test player.
var player = await Helpers.CreateTestPlayer(testId);
// Auth player.
var sessionToken = Helpers.GetSessionToken(testId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{testId}',
{Helpers.JsonServerCredentials}
}}");
// Execute controller.
var controller = new AddRandomCitizenController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Assert citizen is generated and added.
player = await new Player(testId).LoadAsync();
Assert.True(player.Citizens.Count > 0);
Assert.True(player.Citizens[0].RarenessGroupId == testId);
Assert.True(player.Citizens[0].Appearance[0].MetaId == testId);
}
public async void UnavailableContractNotSelected()
{
var requiredBuildingMetaId = "Test_UnavailableContractNotSelected_Required";
var buildingMetaId = "Test_UnavailableContractNotSelected";
var contractMetaId = "Test_UnavailableContractNotSelected";
var playerId = "Test_UnavailableContractNotSelected";
// Create required test building meta if it doesn't exist.
var requiredBuildingMeta = await new BuildingMeta(requiredBuildingMetaId).LoadAsync();
if (requiredBuildingMeta == null)
{
requiredBuildingMeta = new BuildingMeta(requiredBuildingMetaId);
await requiredBuildingMeta.InsertAsync();
}
// Create 'wrong' test building meta if it doesn't exist.
var buildingMeta = await new BuildingMeta(buildingMetaId).LoadAsync();
if (buildingMeta == null)
{
buildingMeta = new BuildingMeta(buildingMetaId);
buildingMeta.AvailableContractMetaIds = new List <string> {
contractMetaId
};
await buildingMeta.InsertAsync();
}
// Create test contract meta if it doesn't exist.
var contractMeta = await new ContractMeta(contractMetaId).LoadAsync();
if (contractMeta == null)
{
contractMeta = new ContractMeta(contractMetaId);
contractMeta.Requirement = new Requirement()
{
BuildingMetaIds = new List <string> {
requiredBuildingMetaId
}
};
await contractMeta.InsertAsync();
}
// Create test player with 'wrong' building.
var building = new Building(buildingMetaId);
building.IsConstructed = true;
var player = await Helpers.CreateTestPlayer(playerId, building : building);
// Auth player.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'BuildingId':'{building.Id}',
'ContractMetaId':'{contractMetaId}'
}}");
// Execute controller.
var controller = new StartProductionController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is RequirementNotFulfilled.
Assert.Equal(responseToken["Status"], JStatus.RequirementNotFulfilled.JToken["Status"]);
// Make sure contract is not selected.
player = await player.LoadAsync();
Assert.Null(player.GetBuildingById(building.Id).ProductionTask);
}
public async void RewardForNotCompletedContractNotCollected()
{
var contractMetaId = "Test_RewardForNotCompletedContractNotCollected";
var contractReward = new Reward()
{
Resources = new List <int> {
0, 0, 111
}
};
var contractProductionTime = TimeSpan.FromMinutes(10);
var buildingMetaId = "Test_RewardForNotCompletedContractNotCollected";
var playerId = "Test_RewardForNotCompletedContractNotCollected";
// Create test contract meta if it doesn't exist.
var contractMeta = await new ContractMeta(contractMetaId).LoadAsync();
if (contractMeta == null)
{
contractMeta = new ContractMeta(contractMetaId);
contractMeta.Rewards.Add(contractReward);
contractMeta.ProductionTime = contractProductionTime;
await contractMeta.InsertAsync();
}
// Create test building meta if it doesn't exist.
var buildingMeta = await new BuildingMeta(buildingMetaId).LoadAsync();
if (buildingMeta == null)
{
buildingMeta = new BuildingMeta(buildingMetaId);
buildingMeta.StorageLimit = 1000;
await buildingMeta.InsertAsync();
}
// Create test player and building.
var building = new Building(buildingMetaId);
building.IsConstructed = true;
building.ProductionTask = new ProductionTask(contractMeta);
var player = await Helpers.CreateTestPlayer(playerId, building : building);
// Auth player.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'BuildingId':'{building.Id}'
}}");
// Execute controller.
var controller = new CheckProductionController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is ContractNotReady.
Assert.Equal(responseToken["Status"], JStatus.NotReady.JToken["Status"]);
// Make sure reward is not collected.
var collectController = new CollectProductionRewardsController();
responseToken = await collectController.HandleHttpRequestAsync(data);
player = await player.LoadAsync();
Assert.True(player.Resources.Count == 0);
}
public async void AvailableItemEquipped()
{
var itemMetaId = "Test_AvailableItemEquipped";
var itemSlot = "Test_AvailableItemEquipped";
var classMetaId = "Test_AvailableItemEquipped";
var playerId = "Test_AvailableItemEquipped";
// Create test class meta if it doesn't exist.
var classMeta = await new ClassMeta(classMetaId).LoadAsync();
if (classMeta == null)
{
classMeta = new ClassMeta(classMetaId);
await classMeta.InsertAsync();
}
// Create test item meta if it doesn't exist.
var itemMeta = await new ItemMeta(itemMetaId).LoadAsync();
if (itemMeta == null)
{
itemMeta = new ItemMeta(itemMetaId);
itemMeta.ClassMetaId = classMetaId;
itemMeta.EquipmentSlot = itemSlot;
await itemMeta.InsertAsync();
}
// Create test player with a character and item.
var player = await Helpers.CreateTestPlayer(playerId);
var character = new Character(classMetaId);
player.Characters.Add(character);
var item = new Item(itemMetaId);
player.AddItem(item);
await player.ReplaceAsync();
// Auth player.
var sessionToken = Helpers.GetSessionToken(playerId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{playerId}',
'SessionToken':'{sessionToken}',
'CharacterId':'{character.Id}',
'ItemId':'{item.Id}'
}}");
// Execute controller.
var controller = new EquipItemController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Make sure item is equiped.
player = await player.LoadAsync();
Assert.True(player.GetItemById(item.Id).IsOwnedByCharacter);
Assert.True(player.GetItemById(item.Id).OwningCharacterId == character.Id);
}
public async void TalentNotLearnedWhenNotEnoughPoints()
{
string testId = $"Test_TalentNotLearnedWhenNotEnoughPoints";
var talentsToLearn = new List <string> {
testId
};
// Create test ability meta if it doesn't exist.
var abilityMeta = await new AbilityMeta(testId).LoadAsync();
if (abilityMeta == null)
{
abilityMeta = new AbilityMeta(testId);
await abilityMeta.InsertAsync();
}
// Create test class meta if it doesn't exist.
var classMeta = await new ClassMeta(testId).LoadAsync();
if (classMeta == null)
{
classMeta = new ClassMeta(testId);
classMeta.Abilities.Add(abilityMeta.Id);
await classMeta.InsertAsync();
}
// Create test talent meta if it doesn't exist.
await CreateTestTalentMetaOfTier(testId, testId, 1);
// Create test player with zero talent points.
var player = await Helpers.CreateTestPlayer(testId);
var character = new Character(testId);
character.TalentPoints = 0;
player.Characters.Add(character);
await player.ReplaceAsync();
// Auth player.
var sessionToken = Helpers.GetSessionToken(testId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{testId}',
'SessionToken':'{sessionToken}',
'TalentMetaIds':'{JsonConvert.SerializeObject(talentsToLearn)}',
'CharacterId':'{character.Id}'
}}");
// Execute controller.
var controller = new LearnTalentsController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is RequirementNotFulfilled.
Assert.Equal(responseToken["Status"], JStatus.RequirementNotFulfilled.JToken["Status"]);
// Make sure talent is not learned.
player = await player.LoadAsync();
Assert.False(player.GetCharacterById(character.Id).IsTalentLearned(testId));
}
private async Task PerformAccessibleTalentLearnedTestForTier(int tier)
{
string testId = $"Test_Accessible{tier}TierTalentLearned";
var talentsToLearn = new List <string> {
testId
};
// Create test ability meta if it doesn't exist.
var abilityMeta = await new AbilityMeta(testId).LoadAsync();
if (abilityMeta == null)
{
abilityMeta = new AbilityMeta(testId);
await abilityMeta.InsertAsync();
}
// Create test class meta if it doesn't exist.
var classMeta = await new ClassMeta(testId).LoadAsync();
if (classMeta == null)
{
classMeta = new ClassMeta(testId);
classMeta.Abilities.Add(abilityMeta.Id);
await classMeta.InsertAsync();
}
// Create test talent meta if it doesn't exist.
await CreateTestTalentMetaOfTier(testId, testId, tier);
// Create test player.
var player = await Helpers.CreateTestPlayer(testId);
var character = new Character(testId);
character.TalentPoints = 1;
// Create prereq metas for and add talents from previous tiers.
if (tier > 0)
{
for (int i = 1; i < tier; i++)
{
var ic = i;
var prereqTalentMetaId = testId + ic;
await CreateTestTalentMetaOfTier(prereqTalentMetaId, testId, ic);
character.LearnedTalentMetaIds.Add(prereqTalentMetaId);
}
}
else if (tier < 0)
{
for (int i = -1; i > tier; i--)
{
var ic = i;
var prereqTalentMetaId = testId + ic;
await CreateTestTalentMetaOfTier(prereqTalentMetaId, testId, ic);
character.LearnedTalentMetaIds.Add(prereqTalentMetaId);
}
}
player.Characters.Add(character);
await player.ReplaceAsync();
// Auth player.
var sessionToken = Helpers.GetSessionToken(testId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{testId}',
'SessionToken':'{sessionToken}',
'TalentMetaIds':'{JsonConvert.SerializeObject(talentsToLearn)}',
'CharacterId':'{character.Id}'
}}");
// Execute controller.
var controller = new LearnTalentsController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Make sure talent is learned.
player = await player.LoadAsync();
Assert.True(player.GetCharacterById(character.Id).IsTalentLearned(testId));
}
public async void CitizenAbilityModifiedProduction()
{
var testId = "Test_CitizenAbilityModifiedProduction";
var contractReward = new Reward()
{
Resources = new List <int> {
0, 0, 111
}
};
var contractProductionTime = TimeSpan.FromSeconds(10);
// Create test contract meta if it doesn't exist.
var contractMeta = await new ContractMeta(testId).LoadAsync();
if (contractMeta == null)
{
contractMeta = new ContractMeta(testId);
contractMeta.Rewards.Add(contractReward);
contractMeta.ProductionTime = contractProductionTime;
await contractMeta.InsertAsync();
}
// Create test building meta if it doesn't exist.
var buildingMeta = await new BuildingMeta(testId).LoadAsync();
if (buildingMeta == null)
{
buildingMeta = new BuildingMeta(testId);
buildingMeta.StorageLimit = 1000;
await buildingMeta.InsertAsync();
}
// Create test citizen ability meta if it doesn't exist.
var abilityMeta = await new CitizenAbilityMeta(testId).LoadAsync();
if (abilityMeta == null)
{
abilityMeta = new CitizenAbilityMeta(testId);
abilityMeta.ReduceTaskDuration = new List <TimeSpan> {
TimeSpan.FromSeconds(9)
};
await abilityMeta.InsertAsync();
}
// Create test player, building and citizen.
var building = new Building(testId);
building.IsConstructed = true;
building.ProductionTask = new ProductionTask(contractMeta);
var player = await Helpers.CreateTestPlayer(testId, building : building);
var citizen = new Citizen();
citizen.Abilities.Add(new CitizenAbility(testId));
player.Citizens.Add(citizen);
building.AssignedCitizenIds.Add(citizen.Id);
await player.ReplaceAsync();
// Wait for contract to complete (contractProductionTime - ReduceTaskDuration + .5f).
Thread.Sleep(TimeSpan.FromSeconds(1.5f));
// Auth player.
var sessionToken = Helpers.GetSessionToken(testId);
// Mock data.
var data = JToken.Parse($@"{{
'PlayerId':'{testId}',
'SessionToken':'{sessionToken}',
'BuildingId':'{building.Id}'
}}");
// Execute controller.
var controller = new CheckProductionController();
var responseToken = await controller.HandleHttpRequestAsync(data);
// Assert controller response status is OK.
Assert.Equal(responseToken["Status"], JStatus.Ok.JToken["Status"]);
// Test reward collection.
var collectController = new CollectProductionRewardsController();
var collectResponseToken = await collectController.HandleHttpRequestAsync(data);
Assert.Equal(collectResponseToken["Status"], JStatus.Ok.JToken["Status"]);
// Make sure reward is added.
player = await player.LoadAsync();
Assert.True(player.Resources[2] > 0);
}
