public async Task CreateQuickMatchActors()
{
var mayur = await Login();
var matt = await Login("matt", "matt");
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(mayur.Id);
var quickMatch = new QuickMatchActors
{
Actors = new List <Guid>(new[] { mayur.Player.Id, matt.Player.Id })
};
var matchResponse = await client.PostAsJsonAsync("/api/matches/actors", quickMatch);
Assert.Equal(HttpStatusCode.Created, matchResponse.StatusCode);
var matchGet = await matchResponse.Content.ReadAsStringAsync();
var match = JsonConvert.DeserializeObject <Match>(matchGet, Actor.JsonSerializerSettings());
Assert.Equal(mayur.Player.Id, match.Tournament.OwnerId);
Assert.False(match.IsFinished);
Assert.False(match.IsDeleted);
}
}
public async Task CreateQuickMatchWithAlliance()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id);
var quickMatch = new QuickMatch {
AlliancesOnly = true
};
var matchResponse = await client.PostAsJsonAsync("/api/matches", quickMatch);
Assert.Equal(HttpStatusCode.Created, matchResponse.StatusCode);
var matchGet = await matchResponse.Content.ReadAsStringAsync();
var match = JsonConvert.DeserializeObject <Match>(matchGet, Actor.JsonSerializerSettings());
Assert.Equal(session.Player.Id, match.Tournament.OwnerId);
Assert.False(match.IsFinished);
Assert.False(match.IsDeleted);
}
}
public async Task GetOwnedMatches()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id);
// Get Matches that Player Own
var matchesResponse = await client.GetAsync("/api/matches/owned");
Assert.Equal(HttpStatusCode.OK, matchesResponse.StatusCode);
var matches = await matchesResponse.Content.ReadAsJsonAsync <IList <Match> >();
Assert.IsType(typeof(List <Match>), matches);
foreach (var match in matches)
{
Assert.True(match.Tournament.OwnerId.Equals(session.Player.Id));
}
}
}
public async Task CreateQuickMatchActorsInvalidActor()
{
var session = await Login();
var invalidId = Guid.NewGuid();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id);
var quickMatch = new QuickMatchActors
{
Actors = new List <Guid>(new[] { session.Player.Id, invalidId })
};
var matchResponse = await client.PostAsJsonAsync("/api/matches/actors", quickMatch);
Assert.Equal(HttpStatusCode.NotFound, matchResponse.StatusCode);
var content = await matchResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"No Player with Id {invalidId} exists.", content.Error);
}
}
public async Task CreateActionRelationWithInvalidActionId()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
var newAR = new ActionRelation
{
ActionId = new Guid(),
Relationship = 0,
ConcernChange = new Matrix {
X = 0, Y = 0
},
RewardResourceChange = new Matrix {
X = 0, Y = 0
}
};
var arResponse = await client.PostAsJsonAsync("/api/actions/relations", newAR);
Assert.Equal(HttpStatusCode.NotFound, arResponse.StatusCode);
var content = await arResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"No Action found", content.Error);
}
}
public async Task CreateValidActionRelation()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
var newAction = await CreateTestAction();
var newAR = new ActionRelation
{
ActionId = newAction.Id,
Relationship = 0,
ConcernChange = new Matrix {
X = 0, Y = 0
},
RewardResourceChange = new Matrix {
X = 0, Y = 0
}
};
var arResponse = await client.PostAsJsonAsync("/api/actions/relations", newAR);
Assert.Equal(HttpStatusCode.Created, arResponse.StatusCode);
var action = await arResponse.Content.ReadAsJsonAsync <ActionRelation>();
Assert.IsType(typeof(ActionRelation), action);
}
}
public async Task CreateValidAction()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
var newAction = await CreateTestAction();
var actionForm = new Action
{
Verb = "testerVerb",
ActivityId = newAction.ActivityId,
GoalId = newAction.GoalId
};
var actionResponse = await client.PostAsJsonAsync("/api/actions", actionForm);
Assert.Equal(HttpStatusCode.Created, actionResponse.StatusCode);
var action = await actionResponse.Content.ReadAsJsonAsync <Action>();
Assert.IsType(typeof(Action), action);
}
}
public async Task CreateActionWithInvalidGoalId()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
var newAction = await CreateTestAction();
var actionForm = new Action
{
Verb = "testerVerb",
ActivityId = newAction.ActivityId,
GoalId = new Guid()
};
var actionResponse = await client.PostAsJsonAsync("/api/actions", actionForm);
Assert.Equal(HttpStatusCode.NotFound, actionResponse.StatusCode);
var content = await actionResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"No Goal found", content.Error);
}
}
public async Task UpdateInvalidAction()
{
var session = await Login();
var invalidId = Guid.NewGuid();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
var newAction = await CreateTestAction();
var actionForm = new Action
{
Verb = "testerVerb",
ActivityId = newAction.ActivityId,
GoalId = newAction.GoalId
};
// Get action with Invalid Id
var actionResponse = await client.PutAsJsonAsync($"/api/actions/{invalidId}", actionForm);
Assert.Equal(HttpStatusCode.NotFound, actionResponse.StatusCode);
var content = await actionResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"No such Action found.", content.Error);
}
}
public async Task UpdateMatchRoundScoreInvalidMatch()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id);
// Update Round Score Match with Invalid Id
var invalidMatchId = Guid.NewGuid();
var matchRoundForm = new MatchRoundForm {
ActorId = session.Player.Id, RoundNumber = 1, Score = 10
};
var response = await client.PutAsJsonAsync($"/api/matches/{invalidMatchId}/rounds", matchRoundForm);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
var content = await response.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"No such Match found.", content.Error);
}
}
public async Task CreateGroup_WithNoPlayer()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id);
var currentSeed = Guid.NewGuid();
var form = new GroupFrom {
Name = $"Test.{currentSeed}", Players = new List <Guid>()
};
// Create Group with No Player
var groupResponse = await client.PostAsJsonAsync($"/api/groups", form);
Assert.Equal(HttpStatusCode.BadRequest, groupResponse.StatusCode);
var content = await groupResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal("Group requires minimum 1 Player.", content.Error);
}
}
public async Task CreateActorGoalInvalidActor()
{
var session = await Login();
var invalidId = Guid.NewGuid();
var role = await CreateTestRole();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
var newerGoal = new ActorGoal
{
ActorId = invalidId,
GoalId = role.Goal.Id,
Status = 0,
ConcernOutcomeId = role.Goal.ConcernId,
RewardResourceOutcomeId = role.Goal.RewardResourceId,
ActivityId = role.ActivityId,
RoleId = role.Id
};
var goalResponse = await client.PostAsJsonAsync("/api/goals/actors", newerGoal);
Assert.Equal(HttpStatusCode.NotFound, goalResponse.StatusCode);
var content = await goalResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"No Actor found for the passed ID", content.Error);
}
}
public async Task UpdateGoalValid()
{
var newGoal = await CreateTestGoal();
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
// Update Goal with Valid Id
var goalForm = new Goal {
Description = "updated"
};
var goalUpdateResponse = await client.PutAsJsonAsync($"/api/goals/{newGoal.Id}", goalForm);
Assert.Equal(HttpStatusCode.OK, goalUpdateResponse.StatusCode);
var content = await goalUpdateResponse.Content.ReadAsJsonAsync <Goal>();
Assert.Equal(newGoal.Id, content.Id);
Assert.Equal("updated", content.Description);
}
}
public async Task GetActorGoalValidGoal()
{
var session = await Login();
var role = await CreateTestRole();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
var newerGoal = new ActorGoal
{
ActorId = session.PlayerId,
GoalId = role.Goal.Id,
Status = 0,
ConcernOutcomeId = role.Goal.ConcernId,
RewardResourceOutcomeId = role.Goal.RewardResourceId,
ActivityId = role.ActivityId,
RoleId = role.Id
};
var actorgoalResponse = await client.PostAsJsonAsync("/api/goals/actors", newerGoal);
Assert.Equal(HttpStatusCode.Created, actorgoalResponse.StatusCode);
var goalsResponse = await client.GetAsync($"/api/goals/{role.Goal.Id}/actor");
Assert.Equal(HttpStatusCode.OK, goalsResponse.StatusCode);
var goalGet = await goalsResponse.Content.ReadAsJsonAsync <ActorGoal>();
Assert.IsType(typeof(ActorGoal), goalGet);
}
}
public async Task CreateGoalInvalidRewardResource()
{
var newGoal = await CreateTestGoal();
var session = await Login();
var invalidId = Guid.NewGuid();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
var newerGoal = new Goal
{
ConcernId = invalidId,
RewardResourceId = newGoal.RewardResourceId,
FeedbackId = newGoal.FeedbackId
};
var goalResponse = await client.PostAsJsonAsync("/api/goals", newerGoal);
Assert.Equal(HttpStatusCode.NotFound, goalResponse.StatusCode);
var content = await goalResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"No Concern found for the passed ID", content.Error);
}
}
public async Task CreateActorGoal()
{
var session = await Login();
var role = await CreateTestRole();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
var newerGoal = new ActorGoal
{
ActorId = session.PlayerId,
GoalId = role.Goal.Id,
Status = 0,
ConcernOutcomeId = role.Goal.ConcernId,
RewardResourceOutcomeId = role.Goal.RewardResourceId,
ActivityId = role.ActivityId,
RoleId = role.Id
};
var goalResponse = await client.PostAsJsonAsync("/api/goals/actors", newerGoal);
Assert.Equal(HttpStatusCode.Created, goalResponse.StatusCode);
var actorgoal = await goalResponse.Content.ReadAsJsonAsync <ActorGoal>();
Assert.Equal(1, actorgoal.Goal.Concern.Coordinates.X);
Assert.Equal(role.Description, actorgoal.Role.Description);
Assert.Equal(role.Goal.Description, actorgoal.Goal.Description);
}
}
public async Task CreateGroup_WithValidPlayers()
{
var mayur = await Login();
var matt = await Login("matt", "matt");
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(mayur.Id);
var currentSeed = Guid.NewGuid();
var form = new GroupFrom
{
Name = $"Test.{currentSeed}",
Type = GroupVisibility.Invisible,
Players = new List <Guid> {
mayur.Player.Id, matt.Player.Id
}
};
// Create Group with valid Players
var groupResponse = await client.PostAsJsonAsync($"/api/groups", form);
Assert.Equal(HttpStatusCode.Created, groupResponse.StatusCode);
var group = await groupResponse.Content.ReadAsJsonAsync <Group>();
Assert.IsType(typeof(Group), group);
Assert.Equal(GroupVisibility.Invisible, group.Type);
Assert.Equal(mayur.Player.Id, group.AdminId);
Assert.Equal(2, group.Players.Count);
}
}
public async Task CreateGroup_WithInvalidPlayers()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id);
var currentSeed = Guid.NewGuid();
var invalidPlayer = Guid.NewGuid();
var form = new GroupFrom
{
Name = $"Test.{currentSeed}",
Players = new List <Guid> {
session.Player.Id, invalidPlayer
}
};
// Create Group with Invalid Players
var groupResponse = await client.PostAsJsonAsync($"/api/groups", form);
Assert.Equal(HttpStatusCode.NotFound, groupResponse.StatusCode);
var content = await groupResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"No Player with Id {invalidPlayer} exists.", content.Error);
}
}
public async Task UpdateMatchRoundScore()
{
var mayur = await Login();
var matt = await Login("matt", "matt");
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(mayur.Id);
var quickMatch = new QuickMatchActors
{
Actors = new List <Guid>(new[] { mayur.Player.Id, matt.Player.Id })
};
var matchResponse = await client.PostAsJsonAsync("/api/matches/actors", quickMatch);
Assert.Equal(HttpStatusCode.Created, matchResponse.StatusCode);
var matchReturn = await matchResponse.Content.ReadAsStringAsync();
var match = JsonConvert.DeserializeObject <Match>(matchReturn, Actor.JsonSerializerSettings());
Assert.Equal(mayur.Player.Id, match.Tournament.OwnerId);
Assert.False(match.IsFinished);
Assert.False(match.IsDeleted);
// Update Match Round Score with Valid Id
// Player 1
var matchRoundForm = new MatchRoundForm {
ActorId = mayur.Player.Id, RoundNumber = 1, Score = 10
};
var matchRoundsResponse = await client.PutAsJsonAsync($"/api/matches/{match.Id}/rounds", matchRoundForm);
Assert.Equal(HttpStatusCode.OK, matchRoundsResponse.StatusCode);
var matchRoundScore = await matchRoundsResponse.Content.ReadAsJsonAsync <MatchRoundScoreResponse>();
Assert.Equal(matchRoundForm.Score, matchRoundScore.Score);
Assert.Equal(matchRoundForm.ActorId, matchRoundScore.ActorId);
// Player 2
var matchRoundForm2 = new MatchRoundForm {
ActorId = matt.Player.Id, RoundNumber = 1, Score = 5
};
matchRoundsResponse = await client.PutAsJsonAsync($"/api/matches/{match.Id}/rounds", matchRoundForm2);
matchRoundScore = await matchRoundsResponse.Content.ReadAsJsonAsync <MatchRoundScoreResponse>();
Assert.Equal(matchRoundForm2.Score, matchRoundScore.Score);
Assert.Equal(matchRoundForm2.ActorId, matchRoundScore.ActorId);
}
}
public async Task UpdateGroupPlayer_AddNewPlayer()
{
var mayur = await Login();
var matt = await Login("matt", "matt");
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(mayur.Id);
var currentSeed = Guid.NewGuid();
var form = new GroupFrom
{
Name = $"Test.{currentSeed}",
Type = GroupVisibility.Invisible,
Players = new List <Guid> {
mayur.Player.Id, matt.Player.Id
}
};
// Create Group with valid Players
var groupResponse = await client.PostAsJsonAsync($"/api/groups", form);
Assert.Equal(HttpStatusCode.Created, groupResponse.StatusCode);
var group = await groupResponse.Content.ReadAsJsonAsync <Group>();
Assert.IsType(typeof(Group), group);
Assert.Equal(mayur.Player.Id, group.AdminId);
var updateForm = new GroupFrom();
// Update Group Players with Add New Player
var jack = await Login("jack", "jack");
groupResponse =
await client.PutAsJsonAsync($"/api/groups/{group.Id}/players/{jack.Player.Id}/add", updateForm);
Assert.Equal(HttpStatusCode.OK, groupResponse.StatusCode);
var response = await groupResponse.Content.ReadAsJsonAsync <Group>();
Assert.IsType(typeof(Group), response);
Assert.Equal(group.Id, response.Id);
Assert.Equal($"Test.{currentSeed}", response.Username);
Assert.Equal(3, response.Players.Count);
}
}
public async Task UpdateMatchRoundScoreFinishedMatch()
{
var mayur = await Login();
var matt = await Login("matt", "matt");
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(mayur.Id);
var quickMatch = new QuickMatchActors
{
Actors = new List <Guid>(new[] { mayur.Player.Id, matt.Player.Id })
};
var matchResponse = await client.PostAsJsonAsync("/api/matches/actors", quickMatch);
Assert.Equal(HttpStatusCode.Created, matchResponse.StatusCode);
var matchReturn = await matchResponse.Content.ReadAsStringAsync();
var match = JsonConvert.DeserializeObject <Match>(matchReturn, Actor.JsonSerializerSettings());
Assert.Equal(mayur.Player.Id, match.Tournament.OwnerId);
Assert.False(match.IsFinished);
Assert.False(match.IsDeleted);
// Finish Match with Valid Id
var response = await client.DeleteAsync($"/api/matches/{match.Id}");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var finishedMatch = await response.Content.ReadAsJsonAsync <Match>();
Assert.True(finishedMatch.IsFinished);
// Update Finished Match Round Score with Valid Id
var matchRoundForm = new MatchRoundForm {
ActorId = mayur.Player.Id, RoundNumber = 1, Score = 10
};
var matchRoundsResponse = await client.PutAsJsonAsync($"/api/matches/{match.Id}/rounds", matchRoundForm);
Assert.Equal(HttpStatusCode.BadRequest, matchRoundsResponse.StatusCode);
var content = await matchRoundsResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"This match is already finished.", content.Error);
}
}
public async Task UpdateGroupPlayer_RemoveNonExistingPlayer()
{
var mayur = await Login();
var matt = await Login("matt", "matt");
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(mayur.Id);
var currentSeed = Guid.NewGuid();
var form = new GroupFrom
{
Name = $"Test.{currentSeed}",
Type = GroupVisibility.Invisible,
Players = new List <Guid> {
mayur.Player.Id, matt.Player.Id
}
};
// Create Group with valid Players
var groupResponse = await client.PostAsJsonAsync($"/api/groups", form);
Assert.Equal(HttpStatusCode.Created, groupResponse.StatusCode);
var group = await groupResponse.Content.ReadAsJsonAsync <Group>();
Assert.IsType(typeof(Group), group);
Assert.Equal(mayur.Player.Id, group.AdminId);
var updateForm = new GroupFrom();
// Update Group Players with Remove Non-existing Player
var jack = await Login("jack", "jack");
groupResponse =
await client.PutAsJsonAsync($"/api/groups/{group.Id}/players/{jack.Player.Id}/remove", updateForm);
Assert.Equal(HttpStatusCode.BadRequest, groupResponse.StatusCode);
var content = await groupResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"No Player with Id {jack.Player.Id} exists in the Group.", content.Error);
}
}
public async Task UpdateGroup_WithInvalidName()
{
var mayur = await Login();
var matt = await Login("matt", "matt");
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(mayur.Id);
var currentSeed = Guid.NewGuid();
var form = new GroupFrom
{
Name = $"Test.{currentSeed}",
Type = GroupVisibility.Invisible,
Players = new List <Guid> {
mayur.Player.Id, matt.Player.Id
}
};
// Create Group with valid Players
var groupResponse = await client.PostAsJsonAsync($"/api/groups", form);
Assert.Equal(HttpStatusCode.Created, groupResponse.StatusCode);
var group = await groupResponse.Content.ReadAsJsonAsync <Group>();
Assert.IsType(typeof(Group), group);
Assert.Equal(mayur.Player.Id, group.AdminId);
var updateForm = new GroupFrom {
Name = ""
};
// Update Group with empty Name
groupResponse = await client.PutAsJsonAsync($"/api/groups/{group.Id}", updateForm);
Assert.Equal(HttpStatusCode.BadRequest, groupResponse.StatusCode);
var content = await groupResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal("Group name is required.", content.Error);
}
}
protected async Task <Role> CreateTestRole()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
var role = new Role
{
Name = "Testing" + Guid.NewGuid(),
Goal =
new Goal
{
Concern = new ConcernMatrix {
Coordinates = new Matrix {
X = 1, Y = 1
}, Category = 0
},
RewardResource =
new RewardResourceMatrix {
Coordinates = new Matrix {
X = 2, Y = 2
}, Category = 0
},
Feedback = new GoalFeedback {
Threshold = 0, Target = 0, Direction = 0
},
Description = "Created for test cases"
},
Activity = new Activity {
Name = "Testing"
}
};
var roleResponse = await client.PostAsJsonAsync("/api/roles", role);
Assert.Equal(HttpStatusCode.Created, roleResponse.StatusCode);
var created = await roleResponse.Content.ReadAsJsonAsync <Role>();
return(created);
}
}
public async Task GetActorGoalWithNonExistingSession()
{
var sessionId = Guid.NewGuid();
var newGoal = await CreateTestGoal();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(sessionId.ToString());
var goalsResponse = await client.GetAsync($"/api/goals/{newGoal.Id}/actor");
Assert.Equal(HttpStatusCode.NotFound, goalsResponse.StatusCode);
var fetched = await goalsResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"Session {sessionId} is Invalid.", fetched.Error);
}
}
public async Task UpdatePlayer()
{
var session = await Login();
var currentSeed = Guid.NewGuid();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id);
var form = new UserForm
{
Username = $"Test.{currentSeed}",
Email = $"test.{currentSeed}@playgen.com",
Password = "******"
};
// Add Player with valid data
var playerResponse = await client.PostAsJsonAsync($"/api/players", form);
Assert.Equal(HttpStatusCode.Created, playerResponse.StatusCode);
var player = await playerResponse.Content.ReadAsJsonAsync <Player>();
Assert.Equal($"Test.{currentSeed}", player.Username);
// Update Player with new data
var newSeed = Guid.NewGuid();
form.Username = $"Test.{newSeed}";
form.Email = $"test.{newSeed}@playgen.com";
playerResponse = await client.PutAsJsonAsync($"/api/players/{player.Id}", form);
Assert.Equal(HttpStatusCode.OK, playerResponse.StatusCode);
player = await playerResponse.Content.ReadAsJsonAsync <Player>();
Assert.Equal($"Test.{newSeed}", player.Username);
Assert.Equal($"test.{newSeed}@playgen.com", player.Email);
}
}
public async Task WhoAmIWithValidSession()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id);
var playerResponse = await client.GetAsync("/api/players");
Assert.Equal(HttpStatusCode.OK, playerResponse.StatusCode);
var player = await playerResponse.Content.ReadAsJsonAsync <Player>();
Assert.Equal(session.Player.Id, player.Id);
}
}
public async Task GetActorGoalWithInvalidSession()
{
var sessionId = "unknown";
var newGoal = await CreateTestGoal();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(sessionId);
var goalsResponse = await client.GetAsync($"/api/goals/{newGoal.Id}/actor");
Assert.Equal(HttpStatusCode.Unauthorized, goalsResponse.StatusCode);
var fetched = await goalsResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"Invalid {SessionAuthorizeFilter.SessionHeaderName} Header.", fetched.Error);
}
}
public async Task UpdateMatchRoundScoreInvalidRound()
{
var mayur = await Login();
var matt = await Login("matt", "matt");
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(mayur.Id);
var quickMatch = new QuickMatchActors
{
Actors = new List <Guid>(new[] { mayur.Player.Id, matt.Player.Id })
};
var matchResponse = await client.PostAsJsonAsync("/api/matches/actors", quickMatch);
Assert.Equal(HttpStatusCode.Created, matchResponse.StatusCode);
var matchReturn = await matchResponse.Content.ReadAsStringAsync();
var match = JsonConvert.DeserializeObject <Match>(matchReturn, Actor.JsonSerializerSettings());
Assert.Equal(mayur.Player.Id, match.Tournament.OwnerId);
Assert.False(match.IsFinished);
Assert.False(match.IsDeleted);
// Update Match Round Score with Invalid Round
var invalidActorId = Guid.NewGuid();
var matchRoundForm = new MatchRoundForm {
ActorId = invalidActorId, RoundNumber = 1, Score = 10
};
var matchRoundsResponse = await client.PutAsJsonAsync($"/api/matches/{match.Id}/rounds", matchRoundForm);
Assert.Equal(HttpStatusCode.NotFound, matchRoundsResponse.StatusCode);
var content = await matchRoundsResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal($"No Actor {invalidActorId} found for this Match.", content.Error);
}
}
public async Task GetGoalValidDetailed()
{
var newGoal = await CreateTestGoal();
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id.ToString());
var goalsResponse = await client.GetAsync($"/api/goals/{newGoal.Id}/detailed");
Assert.Equal(HttpStatusCode.OK, goalsResponse.StatusCode);
var goalGet = await goalsResponse.Content.ReadAsJsonAsync <Goal>();
Assert.Equal(newGoal.Id, goalGet.Id);
}
}
