public async Task GivenInvalidCohortShouldReturnResponseMessageAndNotCallSearchService()
        {
            // Arrange
            ApprenticeshipSearchQuery searchQuery = new Models.ApprenticeshipSearchQuery
            {
                SearchTerm = "short",
                SearchType = ApprenticeshipSearchType.SearchByCohort
            };

            _mediator.Setup(x => x.SendAsync(It.IsAny <GetCommitmentRequest>()))
            .ReturnsAsync(new GetCommitmentResponse
            {
                Data = new Commitment {
                }
            }).Verifiable();

            var validationFailures = new List <ValidationFailure>
            {
                new ValidationFailure("SearchTerm", "Invalid Cohort")
            };

            var validationResult = new ValidationResult(validationFailures);

            _searchValidator.Setup(x => x.Validate(searchQuery))
            .Returns(validationResult)
            .Verifiable();

            var _orchestrator = new ApprenticeshipsOrchestrator(_logger.Object,
                                                                _mediator.Object,
                                                                _apprenticeshipMapper.Object,
                                                                _searchValidator.Object,
                                                                _hashingService.Object,
                                                                _commitmentMapper.Object);

            // Act
            var result = await _orchestrator.GetCommitmentSummary(searchQuery);

            // Assert
            _searchValidator.VerifyAll();
            _mediator.Verify(x => x.SendAsync(It.IsAny <GetCommitmentRequest>()), Times.Never);

            result.Should().NotBeNull();
            result.Should().BeOfType <CommitmentSummaryViewModel>();

            result.ReponseMessages.Should().NotBeNull();
            result.ReponseMessages.Should().HaveCount(1);
        }
        public async Task CohortFoundShouldReturnCohortCommitmentSummary()
        {
            // Arrange
            const string employerName             = "Employer Name";
            ApprenticeshipSearchQuery searchQuery = new ApprenticeshipSearchQuery
            {
                HashedAccountId = "HASH",
                SearchTerm      = "short",
                SearchType      = ApprenticeshipSearchType.SearchByCohort
            };

            _mediator.Setup(x => x.SendAsync(It.IsAny <GetCommitmentRequest>()))
            .ReturnsAsync(new GetCommitmentResponse
            {
                Data = new Commitment()
            });

            var validationResult = new Mock <ValidationResult>();

            validationResult.SetupGet(x => x.IsValid).Returns(true);

            _searchValidator.Setup(x => x.Validate(searchQuery))
            .Returns(validationResult.Object);

            var _orchestrator = new ApprenticeshipsOrchestrator(_logger.Object,
                                                                _mediator.Object,
                                                                _apprenticeshipMapper.Object,
                                                                _searchValidator.Object,
                                                                _hashingService.Object,
                                                                _commitmentMapper.Object);

            _commitmentMapper.Setup(x => x.MapToCommitmentSummaryViewModel(It.IsAny <Commitment>())).Returns(new CommitmentSummaryViewModel
            {
                EmployerName = employerName
            });

            // Act
            var result = await _orchestrator.GetCommitmentSummary(searchQuery);

            // Assert
            result.Should().NotBeNull();
            result.Should().BeOfType <CommitmentSummaryViewModel>();

            result.ReponseMessages.Should().BeNullOrEmpty();
            result.EmployerName.Should().Be(employerName);
        }
        public async Task GivenInvalidHashedAccountIdShouldReturnResponseMessage()
        {
            // Arrange
            ApprenticeshipSearchQuery searchQuery = new ApprenticeshipSearchQuery
            {
                HashedAccountId = "HASH",
                SearchTerm      = "short",
                SearchType      = ApprenticeshipSearchType.SearchByCohort
            };

            _mediator.Setup(x => x.SendAsync(It.IsAny <GetCommitmentRequest>()))
            .ReturnsAsync(new GetCommitmentResponse
            {
                Data = new Commitment {
                }
            }).Verifiable();

            var validationResult = new Mock <ValidationResult>();

            validationResult.SetupGet(x => x.IsValid).Returns(true);

            _searchValidator.Setup(x => x.Validate(searchQuery))
            .Returns(validationResult.Object);

            _hashingService.Setup(x => x.DecodeValue(It.Is <string>(s => s == searchQuery.SearchTerm))).Returns(1234);
            _hashingService.Setup(x => x.DecodeValue(searchQuery.HashedAccountId)).Throws <Exception>();

            var _orchestrator = new ApprenticeshipsOrchestrator(_logger.Object,
                                                                _mediator.Object,
                                                                _apprenticeshipMapper.Object,
                                                                _searchValidator.Object,
                                                                _hashingService.Object,
                                                                _commitmentMapper.Object);

            // Act
            var result = await _orchestrator.GetCommitmentSummary(searchQuery);

            // Assert
            result.Should().NotBeNull();
            result.Should().BeOfType <CommitmentSummaryViewModel>();

            result.ReponseMessages.Should().NotBeNull();
            result.ReponseMessages.Should().Contain("Problem validating your account Id");
        }
        public async Task QueryThrowsUnauthorizedShouldReturnResponseMessage()
        {
            // Arrange
            ApprenticeshipSearchQuery searchQuery = new ApprenticeshipSearchQuery
            {
                HashedAccountId = "HASH",
                SearchTerm      = "short",
                SearchType      = ApprenticeshipSearchType.SearchByCohort
            };

            _mediator
            .Setup(x => x.SendAsync(It.IsAny <GetCommitmentRequest>()))
            .Throws <UnauthorizedException>();

            var validationResult = new Mock <ValidationResult>();

            validationResult
            .SetupGet(x => x.IsValid)
            .Returns(true);

            _searchValidator
            .Setup(x => x.Validate(searchQuery))
            .Returns(validationResult.Object);

            var _orchestrator = new ApprenticeshipsOrchestrator(
                _logger.Object,
                _mediator.Object,
                _apprenticeshipMapper.Object,
                _searchValidator.Object,
                _hashingService.Object,
                _commitmentMapper.Object);

            // Act
            var result = await _orchestrator.GetCommitmentSummary(searchQuery);

            // Assert
            result.Should().NotBeNull();
            result.Should().BeOfType <CommitmentSummaryViewModel>();

            result.ReponseMessages.Should().NotBeNull();
            result.ReponseMessages.Should().Contain("Account is unauthorised to access this Cohort.");
        }
        public async Task NoCohortFoundShouldReturnResponseMessage(bool responseAsNull)
        {
            // Arrange
            ApprenticeshipSearchQuery searchQuery = new ApprenticeshipSearchQuery
            {
                HashedAccountId = "HASH",
                SearchTerm      = "short",
                SearchType      = ApprenticeshipSearchType.SearchByCohort
            };

            var getComtResponse = responseAsNull ? null : new GetCommitmentResponse {
                Data = null
            };

            _mediator.Setup(x => x.SendAsync(It.IsAny <GetCommitmentRequest>()))
            .ReturnsAsync(getComtResponse);

            var validationResult = new Mock <ValidationResult>();

            validationResult.SetupGet(x => x.IsValid).Returns(true);

            _searchValidator.Setup(x => x.Validate(searchQuery))
            .Returns(validationResult.Object);

            var _orchestrator = new ApprenticeshipsOrchestrator(_logger.Object,
                                                                _mediator.Object,
                                                                _apprenticeshipMapper.Object,
                                                                _searchValidator.Object,
                                                                _hashingService.Object,
                                                                _commitmentMapper.Object);

            // Act
            var result = await _orchestrator.GetCommitmentSummary(searchQuery);

            // Assert
            result.Should().NotBeNull();
            result.Should().BeOfType <CommitmentSummaryViewModel>();

            result.ReponseMessages.Should().NotBeNull();
            result.ReponseMessages.Should().Contain("No record Found");
        }