public async Task IfAnswerIsValidMovesToNextQuestion()
        {
            var answerRequest = new QuestionPostRequestViewModel()
            {
                QuestionNumber = 3, AssessmentType = "short", Answer = "answer1"
            };
            var currentQuestion = new GetQuestionResponse()
            {
                MaxQuestionsCount = 10, CurrentQuestionNumber = 3, NextQuestionNumber = 4
            };
            var answerResponse = new PostAnswerResponse()
            {
                IsSuccess = true, NextQuestionNumber = 4
            };

            A.CallTo(() => Session.HasValidSession()).Returns(true);
            A.CallTo(() => ApiService.GetQuestion(answerRequest.AssessmentType, answerRequest.QuestionNumber)).Returns(currentQuestion);
            A.CallTo(() => ApiService.AnswerQuestion(answerRequest.AssessmentType, answerRequest.QuestionNumber, answerRequest.QuestionNumber, answerRequest.Answer)).Returns(answerResponse);

            var actionResponse = await AssessmentController.Index(answerRequest).ConfigureAwait(false);

            Assert.IsType <RedirectResult>(actionResponse);
            var redirectResult = actionResponse as RedirectResult;

            Assert.Equal($"~/{RouteName.Prefix}/assessment/short/4", redirectResult.Url);
        }
        public async Task NullViewModelReturnsBadRequest()
        {
            QuestionPostRequestViewModel viewModel = null;
            var actionResponse = await AssessmentController.Index(viewModel).ConfigureAwait(false);

            Assert.IsType <BadRequestResult>(actionResponse);
        }
        public async Task IfNoAnswerIsProvidedReturnsView()
        {
            var viewModel = new QuestionPostRequestViewModel()
            {
                QuestionNumber = 3, AssessmentType = "short"
            };

            A.CallTo(() => Session.HasValidSession()).Returns(true);

            var actionResponse = await AssessmentController.Index(viewModel).ConfigureAwait(false);

            Assert.IsType <ViewResult>(actionResponse);
        }
        public async Task IfQuestionDoesNotExistReturnsBadRequest()
        {
            var viewModel = new QuestionPostRequestViewModel()
            {
                QuestionNumber = 3, AssessmentType = "name1"
            };
            GetQuestionResponse question = null;

            A.CallTo(() => Session.HasValidSession()).Returns(true);
            A.CallTo(() => ApiService.GetQuestion(viewModel.AssessmentType, viewModel.QuestionNumber)).Returns(question);

            var actionResponse = await AssessmentController.Index(viewModel).ConfigureAwait(false);

            Assert.IsType <BadRequestResult>(actionResponse);
        }
        public async Task <IActionResult> Index(QuestionPostRequestViewModel requestViewModel)
        {
            if (requestViewModel == null)
            {
                return(BadRequest());
            }

            var hasSessionId = await HasSessionId().ConfigureAwait(false);

            if (!hasSessionId)
            {
                return(RedirectToRoot());
            }

            var question = await GetQuestion(requestViewModel.AssessmentType, requestViewModel.QuestionNumber).ConfigureAwait(false);

            if (question == null)
            {
                return(BadRequest());
            }

            var result = mapper.Map <QuestionGetResponseViewModel>(question);

            if (!ModelState.IsValid)
            {
                return(View(result));
            }

            var answerResponse = await apiService.AnswerQuestion(requestViewModel.AssessmentType, requestViewModel.QuestionNumber, requestViewModel.QuestionNumber, requestViewModel.Answer).ConfigureAwait(false);

            if (answerResponse.IsSuccess)
            {
                if (answerResponse.IsComplete)
                {
                    return(RedirectTo("assessment/complete"));
                }
                else
                {
                    var assessmentTypeName = GetAssessmentTypeName(requestViewModel.AssessmentType);
                    return(RedirectTo($"assessment/{assessmentTypeName}/{answerResponse.NextQuestionNumber}"));
                }
            }
            else
            {
                ModelState.AddModelError("Answer", "Failed to record answer");
                return(View(result));
            }
        }
        public async Task WhenAllAnswersAreProvidedAssessmentIsCompleted()
        {
            var answerRequest = new QuestionPostRequestViewModel()
            {
                QuestionNumber = 3, AssessmentType = "name1", Answer = "answer1"
            };
            var currentQuestion = new GetQuestionResponse();
            var answerResponse  = new PostAnswerResponse()
            {
                IsSuccess = true, IsComplete = true
            };

            A.CallTo(() => Session.HasValidSession()).Returns(true);
            A.CallTo(() => ApiService.GetQuestion(answerRequest.AssessmentType, answerRequest.QuestionNumber)).Returns(currentQuestion);
            A.CallTo(() => ApiService.AnswerQuestion(answerRequest.AssessmentType, answerRequest.QuestionNumber, answerRequest.QuestionNumber, answerRequest.Answer)).Returns(answerResponse);

            var actionResponse = await AssessmentController.Index(answerRequest).ConfigureAwait(false);

            Assert.IsType <RedirectResult>(actionResponse);
            var redirectResult = actionResponse as RedirectResult;

            Assert.Equal($"~/{RouteName.Prefix}/assessment/complete", redirectResult.Url);
        }