public async Task CharacterController_OnRequestingAbilityRollOnValidCharacterDraft_UpdatesCharacterDraft()
        {
            var requestBody = JsonSerializer.Serialize(new CreateCharacterDraftRequest {
                PlayerId = Guid.NewGuid()
            });
            var responseContent = await GetPostResponse <CreateCharacterDraftResponse>(ApiRoot, requestBody);

            var rollAbilitiesRequest = new RollAbilityScoresRequest
            {
                DraftId      = responseContent.DraftId,
                Strength     = 10,
                Wisdom       = 15,
                Intelligence = 7,
                Charisma     = 18,
                Constitution = 14,
                Dexterity    = 15
            };

            var rollAbilitiesRequestBody = JsonSerializer.Serialize(rollAbilitiesRequest);

            var putResponse = await client.PutAsync(
                $"{ApiRoot}/abilityScores",
                new StringContent(rollAbilitiesRequestBody, Encoding.UTF8, ContentType));

            putResponse.EnsureSuccessStatusCode();

            var savedCharacterDto = await GetCharacterDto(responseContent.DraftId);

            Assert.Equal(rollAbilitiesRequest.Strength, savedCharacterDto.Strength);
            Assert.Equal(rollAbilitiesRequest.Dexterity, savedCharacterDto.Dexterity);
            Assert.Equal(rollAbilitiesRequest.Charisma, savedCharacterDto.Charisma);
            Assert.Equal(rollAbilitiesRequest.Constitution, savedCharacterDto.Constitution);
            Assert.Equal(rollAbilitiesRequest.Wisdom, savedCharacterDto.Wisdom);
            Assert.Equal(rollAbilitiesRequest.Intelligence, savedCharacterDto.Intelligence);
        }
        public async Task CharacterController_OnRequestingAbilitiesRollOnWithEmptyId_ReturnsBadRequest()
        {
            var rollAbilitiesRequest = new RollAbilityScoresRequest {
                DraftId = Guid.Empty
            };
            var rollAbilitiesRequestBody = JsonSerializer.Serialize(rollAbilitiesRequest);
            var response = await client.PutAsync(
                $"{ApiRoot}/abilityScores",
                new StringContent(rollAbilitiesRequestBody, Encoding.UTF8, ContentType));

            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
        }
        public async Task CharacterController_OnRequestingAbilitiesRollOnNonExistingDraft_ReturnsNotFound()
        {
            var rollAbilitiesRequest = new RollAbilityScoresRequest {
                DraftId = Guid.NewGuid()
            };
            var rollAbilitiesRequestBody = JsonSerializer.Serialize(rollAbilitiesRequest);
            var response = await client.PutAsync(
                $"{ApiRoot}/abilityScores",
                new StringContent(rollAbilitiesRequestBody, Encoding.UTF8, ContentType));

            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
        }
        public async Task CharacterController_AfterCompletingCharacterDetails_CompletesCharacter()
        {
            var requestBody = JsonSerializer.Serialize(new CreateCharacterDraftRequest {
                PlayerId = Guid.NewGuid()
            });
            var responseContent = await GetPostResponse <CreateCharacterDraftResponse>(ApiRoot, requestBody);

            var rollAbilitiesRequest = new RollAbilityScoresRequest
            {
                DraftId      = responseContent.DraftId,
                Strength     = 10,
                Wisdom       = 15,
                Intelligence = 7,
                Charisma     = 18,
                Constitution = 14,
                Dexterity    = 15
            };

            var rollAbilitiesRequestBody = JsonSerializer.Serialize(rollAbilitiesRequest);
            var chooseRaceRequest        = JsonSerializer.Serialize(new ChooseRaceRequest {
                DraftId = responseContent.DraftId, Race = "Dwarf"
            });
            var chooseNameRequest = JsonSerializer.Serialize(new ChooseNameRequest {
                DraftId = responseContent.DraftId, Name = "Beczka"
            });

            var abilityScoresResponse = await client.PutAsync(
                $"{ApiRoot}/abilityScores",
                new StringContent(rollAbilitiesRequestBody, Encoding.UTF8, ContentType));

            abilityScoresResponse.EnsureSuccessStatusCode();

            var raceChosenResponse = await client.PutAsync(
                $"{ApiRoot}/race",
                new StringContent(chooseRaceRequest, Encoding.UTF8, ContentType));

            raceChosenResponse.EnsureSuccessStatusCode();

            var nameChosenResponse = await client.PutAsync(
                $"{ApiRoot}/name",
                new StringContent(chooseNameRequest, Encoding.UTF8, ContentType));

            nameChosenResponse.EnsureSuccessStatusCode();

            var characterDto = await GetCharacterDto(responseContent.DraftId);

            Assert.Equal("Completed", characterDto.Stage);
        }
Ejemplo n.º 5
0
        public IActionResult AddAbilities([FromBody] RollAbilityScoresRequest request)
        {
            if (request == null || request.DraftId == Guid.Empty)
            {
                return(BadRequest("Not enough information provided to roll ability scores"));
            }

            var command = new RollAbilityScoresCommand
            {
                CharacterUiD = request.DraftId,
                Dexterity    = request.Dexterity,
                Charisma     = request.Charisma,
                Constitution = request.Constitution,
                Intelligence = request.Intelligence,
                Wisdom       = request.Wisdom,
                Strength     = request.Strength
            };

            IActionResult result;

            try
            {
                rollAbilitiesScoresHandler.Handle(command);
                result = Ok();
            }
            catch (InvalidOperationException ex)
            {
                result = BadRequest(ex.Message);
            }
            catch (ArgumentOutOfRangeException ex)
            {
                result = BadRequest(ex.Message);
            }
            catch (CharacterNotFoundException ex)
            {
                result = NotFound(ex.Message);
            }
            catch (InvalidCharacterStateException ex)
            {
                result = BadRequest(ex.Message);
            }

            return(result);
        }