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