protected async Task<Action> CreateTestAction(string verb = "Created for test goal and activity")
        {
            var session = await Login();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id.ToString());
                var action = new Action
                {
                    Verb = verb,
                    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 actionResponse = await client.PostAsJsonAsync("/api/actions", action);
                Assert.Equal(HttpStatusCode.Created, actionResponse.StatusCode);

                var created = await actionResponse.Content.ReadAsJsonAsync<Action>();

                return created;
            }
        }
        public async Task AddActivityGoal()
        {
            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 Activity { Name = $"Name.{currentSeed}", Description = $"Description.{currentSeed}" };

                // Add Activity with valid data
                var activityResponse = await client.PostAsJsonAsync($"/api/activities", form);
                Assert.Equal(HttpStatusCode.Created, activityResponse.StatusCode);

                var activity = await activityResponse.Content.ReadAsJsonAsync<Activity>();
                Assert.Equal($"Name.{currentSeed}", activity.Name);

                var goalForm = new ActivityGoalForm { Description = $"Description.{currentSeed}" };
                activityResponse = await client.PutAsJsonAsync($"/api/activities/{activity.Id}/goal", goalForm);
                Assert.Equal(HttpStatusCode.OK, activityResponse.StatusCode);

                activity = await activityResponse.Content.ReadAsJsonAsync<Activity>();
                Assert.Equal(1, activity.Goals.Count);
            }
        }
        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 GetMyGroups_WithValidSession()
        {
            var session = await Login();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id);

                // Get My Groups with valid session header
                var groupResponse = await client.GetAsync("/api/groups");
                Assert.Equal(HttpStatusCode.OK, groupResponse.StatusCode);

                var groups = await groupResponse.Content.ReadAsJsonAsync<IList<Group>>();
                Assert.IsType(typeof(List<Group>), groups);
            }
        }
        public async Task GetPlayerWithInvalidSession()
        {
            var sessionId = "unknown";

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(sessionId);

                // Get Player with invalid session header
                var playerResponse = await client.GetAsync("/api/players");
                Assert.Equal(HttpStatusCode.Unauthorized, playerResponse.StatusCode);

                var fetched = await playerResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal($"Invalid {SessionAuthorizeFilter.SessionHeaderName} Header.", fetched.Error);
            }
        }
        public async Task GetPlayerWithNonExistingSession()
        {
            var sessionId = Guid.NewGuid();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(sessionId);

                // Get Player with non-existing session header
                var playerResponse = await client.GetAsync("/api/players");
                Assert.Equal(HttpStatusCode.NotFound, playerResponse.StatusCode);

                var fetched = await playerResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal($"Session {sessionId} is Invalid.", fetched.Error);
            }
        }
        public async Task GetActorGroups_WithInvalidActor()
        {
            var session = await Login();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id);

                // Get Actor's Groups with invalid Actor
                var invalidId = Guid.NewGuid();
                var groupResponse = await client.GetAsync($"/api/groups/actor/{invalidId}");
                Assert.Equal(HttpStatusCode.NotFound, groupResponse.StatusCode);

                var fetched = await groupResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal($"No such Player found.", fetched.Error);
            }
        }
        protected async Task<Session> Login(string username = "******", string password = "******")
        {
            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson();

                // login 
                var loginForm = new UserForm { Username = username, Password = password };

                var loginResponse = await client.PostAsJsonAsync("/api/sessions", loginForm);
                Assert.True(loginResponse.IsSuccessStatusCode);

                var created = await loginResponse.Content.ReadAsJsonAsync<Session>();

                return created;
            }
        }
        public async Task GetInvalidAction()
        {
            var session = await Login();
            var invalidId = Guid.NewGuid();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id.ToString());

                // Get action with Invalid Id
                var actionResponse = await client.GetAsync($"/api/actions/{invalidId}");
                Assert.Equal(HttpStatusCode.NotFound, actionResponse.StatusCode);

                var content = await actionResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal($"No Action found.", content.Error);
            }
        }
        public async Task AddActivityGoal_InvalidId()
        {
            var session = await Login();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id);

                var form = new UserForm();

                // Add Activity Goal with invalid Id
                var invalidId = Guid.NewGuid();
                var activityResponse = await client.PutAsJsonAsync($"/api/activities/{invalidId}/goal", form);
                Assert.Equal(HttpStatusCode.NotFound, activityResponse.StatusCode);

                var content = await activityResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal("No such Activity found.", content.Error);
            }
        }
        protected async Task<Goal> CreateTestGoal()
        {
            var session = await Login();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id.ToString());
                var 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"
                };
                var goalResponse = await client.PostAsJsonAsync("/api/goals", goal);
                Assert.Equal(HttpStatusCode.Created, goalResponse.StatusCode);

                var created = await goalResponse.Content.ReadAsJsonAsync<Goal>();

                return created;
            }
        }
        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 UpdateRewardByInvalidAction()
        {
            var session = await Login();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id.ToString());

                var actionForm = new Action { Verb = "invalidVerb" };

                var actionResponse = await client.PostAsJsonAsync("/api/actions/send", actionForm);
                Assert.Equal(HttpStatusCode.NotFound, actionResponse.StatusCode);

                var content = await actionResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal($"Invalid action verb.", content.Error);
            }
        }
        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 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 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 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 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 GetAllActions()
        {
            var session = await Login();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id.ToString());

                // Get actions
                var actionResponse = await client.GetAsync($"/api/actions");
                Assert.Equal(HttpStatusCode.OK, actionResponse.StatusCode);

                var actions = await actionResponse.Content.ReadAsJsonAsync<IList<Action>>();
                Assert.IsType(typeof(List<Action>), actions);
            }
        }
        public async Task UpdateGroupPlayer_WithInvalidGroup()
        {
            var session = await Login();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id);

                var form = new GroupFrom();

                // Update Group Players with Invalid Group Id
                var invalidId = Guid.NewGuid();
                var groupResponse = await client.PutAsJsonAsync($"/api/groups/{invalidId}/players/{invalidId}", form);
                Assert.Equal(HttpStatusCode.NotFound, groupResponse.StatusCode);

                var content = await groupResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal("No Group found.", content.Error);
            }
        }
        public async Task DeleteValidPlayer()
        {
            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);

                // Delete Player
                playerResponse = await client.DeleteAsync($"/api/players/{player.Id}");
                Assert.Equal(HttpStatusCode.OK, playerResponse.StatusCode);

                player = await playerResponse.Content.ReadAsJsonAsync<Player>();
                Assert.False(player.IsEnabled);
            }
        }
        public async Task UpdateGroupPlayer_RemoveExistingPlayer()
        {
            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 Existing Player
                groupResponse =
                    await client.PutAsJsonAsync($"/api/groups/{group.Id}/players/{matt.Player.Id}/remove", 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(1, response.Players.Count);
            }
        }
        public async Task UpdateGroupPlayer_ExistingAdmin()
        {
            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 Same Admin
                groupResponse =
                    await client.PutAsJsonAsync($"/api/groups/{group.Id}/players/{mayur.Player.Id}/admin", updateForm);
                Assert.Equal(HttpStatusCode.BadRequest, groupResponse.StatusCode);

                var content = await groupResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal($"You are already Admin of this Group.", content.Error);
            }
        }
        public async Task UpdateRewardByValidAction()
        {
            var session = await Login();
            var newAction = await CreateTestAction("Verb test" + Guid.NewGuid());

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id.ToString());

                var newAT = new AttributeType { Name = "testAttribute", DefaultValue = 0f, Type = 0 };
                var atResponse = await client.PostAsJsonAsync("/api/attributes/types", newAT);
                Assert.Equal(HttpStatusCode.Created, atResponse.StatusCode);
                var attribute = await atResponse.Content.ReadAsJsonAsync<AttributeType>();
                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 arReturn = await arResponse.Content.ReadAsJsonAsync<ActionRelation>();
                Assert.IsType(typeof(ActionRelation), arReturn);
                var newReward = new Reward
                {
                    AttributeTypeId = attribute.Id,
                    TypeReward = RewardType.Store,
                    Value = 1.5f,
                    Status = 0,
                    GoalId = newAction.GoalId
                };
                var rewardResponse = await client.PostAsJsonAsync("/api/rewards", newReward);
                Assert.Equal(HttpStatusCode.Created, rewardResponse.StatusCode);
                var newReward2 = new Reward
                {
                    AttributeTypeId = attribute.Id,
                    TypeReward = RewardType.Modify,
                    Value = 1f,
                    Status = 0,
                    GoalId = newAction.GoalId,
                    ActionRelationId = arReturn.Id
                };
                var rewardResponse2 = await client.PostAsJsonAsync("/api/rewards", newReward2);
                Assert.Equal(HttpStatusCode.Created, rewardResponse2.StatusCode);

                var actionForm = new Action { Verb = newAction.Verb };

                var actionResponse = await client.PostAsJsonAsync("/api/actions/send", actionForm);
                Assert.Equal(HttpStatusCode.OK, actionResponse.StatusCode);

                var rewardReturn = await actionResponse.Content.ReadAsJsonAsync<Reward>();
                Assert.IsType(typeof(Reward), rewardReturn);
            }
        }
        public async Task DisableGroup()
        {
            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);

                // Get Group with valid id
                groupResponse = await client.DeleteAsync($"/api/groups/{group.Id}");
                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.False(response.IsEnabled);
            }
        }
        public async Task DisableGroup_InvalidGroup()
        {
            var session = await Login();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id);

                // Create Group with No Player
                var invalidId = Guid.NewGuid();
                var groupResponse = await client.DeleteAsync($"/api/groups/{invalidId}");
                Assert.Equal(HttpStatusCode.NotFound, groupResponse.StatusCode);

                var content = await groupResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal("No Group found.", content.Error);
            }
        }
        public async Task DeleteValidAction()
        {
            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);

                var actionResponse2 = await client.DeleteAsync($"/api/actions/{action.Id}");
                Assert.Equal(HttpStatusCode.OK, actionResponse2.StatusCode);

                var actions = await actionResponse2.Content.ReadAsJsonAsync<Action>();
                Assert.IsType(typeof(Action), actions);
            }
        }
        public async Task UpdatePlayerWithExistingEmail()
        {
            var session = await Login();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id);

                var form = new UserForm { Email = "*****@*****.**" };

                // Update Player with existing Email
                var playerResponse = await client.PutAsJsonAsync($"/api/players/{session.Player.Id}", form);
                Assert.Equal(HttpStatusCode.BadRequest, playerResponse.StatusCode);

                var content = await playerResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal("Player with this Email already exists.", content.Error);
            }
        }
        public async Task GetInvalidActionRelationWithNonExistingSession()
        {
            var sessionId = Guid.NewGuid();
            var invalidId = Guid.NewGuid();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(sessionId.ToString());

                // Get action with Invalid Id
                var actionResponse = await client.GetAsync($"/api/actions/{invalidId}/relations");
                Assert.Equal(HttpStatusCode.NotFound, actionResponse.StatusCode);

                var fetched = await actionResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal($"Session {sessionId} is Invalid.", fetched.Error);
            }
        }
        public async Task DeleteInvalidPlayer()
        {
            var session = await Login();

            using (var client = new HttpClient { BaseAddress = new Uri(ServerUrl) })
            {
                client.AcceptJson().AddSessionHeader(session.Id);

                // Delete Player with Invalid Id
                var invalidPlayerId = Guid.NewGuid();
                var playerResponse = await client.DeleteAsync($"/api/players/{invalidPlayerId}");
                Assert.Equal(HttpStatusCode.NotFound, playerResponse.StatusCode);

                var content = await playerResponse.Content.ReadAsJsonAsync<ApiError>();
                Assert.Equal($"No such Player found.", content.Error);
            }
        }