示例#1
0
        public async Task SearchResultsShouldReturnViewResultWhenFrameworkSearchIsSuccessful()
        {
            var stubSearchResponse = new ProviderSearchResponse {
                Success = true, StatusCode = ProviderSearchResponseCodes.Success
            };

            var stubViewModel = new ProviderFrameworkSearchResultViewModel {
                Title = "title1"
            };

            ProviderController controller =
                new ProviderControllerBuilder().SetupMappingService(
                    x => x.Map(It.IsAny <ProviderSearchResponse>(), It.IsAny <Action <IMappingOperationOptions <ProviderSearchResponse, ProviderFrameworkSearchResultViewModel> > >()),
                    stubViewModel).SetupMediator(x => x.Send <ProviderSearchResponse>(It.IsAny <ProviderSearchQuery>(), default(CancellationToken)), Task.FromResult(stubSearchResponse));

            var searchCriteria = new ProviderSearchQuery {
                ApprenticeshipId = "123", PostCode = "AB3 1SD"
            };

            var result = await controller.FrameworkResults(searchCriteria);

            result.Should().BeOfType <ViewResult>();

            var viewResult = (ViewResult)result;

            viewResult.Model.Should().Be(stubViewModel);
        }
        public async Task ShouldReturnSuccessWhenSearchIsSuccessful()
        {
            var message = new ProviderSearchQuery {
                ApprenticeshipId = "1", PostCode = "AB23 0BB"
            };

            var response = await _handler.Handle(message, default(CancellationToken));

            response.Success.Should().BeTrue();
        }
        public async Task ShouldReturnShowAllProvidersFlag()
        {
            var message = new ProviderSearchQuery {
                ApprenticeshipId = "1", PostCode = "GU21 6DB", ShowAll = true
            };

            var response = await _handler.Handle(message, default(CancellationToken));

            response.ShowAllProviders.Should().BeTrue();
        }
        public async Task ShouldReturnSearchTerms()
        {
            var message = new ProviderSearchQuery {
                ApprenticeshipId = "1", PostCode = "GU21 6DB", Keywords = "abba 42"
            };

            var response = await _handler.Handle(message, default(CancellationToken));

            response.SearchTerms.Should().Be("abba 42");
        }
        public async Task ShouldReturnPageNumberFromRequestIfPageNumberInRequestIsGreaterThanZero(int page)
        {
            var message = new ProviderSearchQuery {
                ApprenticeshipId = "1", PostCode = "GU21 6DB", Page = page
            };

            var response = await _handler.Handle(message, default(CancellationToken));

            response.CurrentPage.Should().Be(page);
        }
        public void GenerateSearchQuery_WithNullSize_ReturnsQueryWithSize20()
        {
            var query = new ProviderSearchQuery
            {
                SearchText = "TestSearchText"
            };

            var result = query.GenerateSearchQuery();

            result.Options.Size.Should().Be(20);
        }
        public void GenerateSearchQuery_ReturnsQueryWithSearchModeAll()
        {
            var query = new ProviderSearchQuery
            {
                SearchText = "TestSearchText"
            };

            var result = query.GenerateSearchQuery();

            result.Options.SearchMode.Should().Be(SearchMode.All);
        }
        public async Task ShouldSignalFailureWhenPostCodeIsInvalidFormat()
        {
            var message = new ProviderSearchQuery {
                ApprenticeshipId = "1", PostCode = "gfsgfdgds"
            };

            var response = await _handler.Handle(message, default(CancellationToken));

            response.Success.Should().BeFalse();
            response.StatusCode.ShouldBeEquivalentTo(ProviderSearchResponseCodes.PostCodeInvalidFormat);
        }
        public void GenerateSearchQuery_WithNullTowns_ReturnsQueryWithEmptyFilter()
        {
            var query = new ProviderSearchQuery
            {
                SearchText = "TestSearchText"
            };

            var result = query.GenerateSearchQuery();

            result.Options.Filter.Should().Be(string.Empty);
        }
 private static RouteValueDictionary GenerateProviderResultsRouteValues(ProviderSearchQuery criteria, int currentPage)
 {
     return(new RouteValueDictionary()
            .AddValue("page", currentPage)
            .AddValue("postcode", criteria?.PostCode ?? string.Empty)
            .AddValue("apprenticeshipId", criteria?.ApprenticeshipId)
            .AddValue("showall", criteria?.ShowAll)
            .AddValue("isLevyPayingEmployer", criteria?.IsLevyPayingEmployer)
            .AddValue("keywords", criteria?.Keywords ?? string.Empty)
            .AddList("deliverymodes", criteria?.DeliveryModes));
 }
        public void GenerateSearchQuery_WithSearchText_ReturnsQueryWithExpectedSearchText(string searchText, string expectedResult)
        {
            var query = new ProviderSearchQuery
            {
                SearchText = searchText
            };

            var result = query.GenerateSearchQuery();

            result.SearchText.Should().Be(expectedResult);
        }
        public void GenerateSearchQuery_WithSingleTown_ReturnsQueryWithExpectedSearchInFilter()
        {
            var query = new ProviderSearchQuery
            {
                SearchText = "TestSearchText",
                Towns      = new[] { "TestTown1" }
            };

            var result = query.GenerateSearchQuery();

            result.Options.Filter.Should().Be("search.in(Town, 'TestTown1', '|')");
        }
        public async Task ShouldReturnResultOfSearch()
        {
            var providerStandardSearchResults = new ProviderSearchResults();

            _mockSearchService.Setup(x => x.SearchProviders(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Pagination>(), It.IsAny <IEnumerable <string> >(), It.IsAny <bool>(), It.IsAny <bool>(), 0)).Returns(Task.FromResult(providerStandardSearchResults));
            var message = new ProviderSearchQuery {
                ApprenticeshipId = "1", PostCode = "GU21 6DB", Page = 0
            };

            var response = await _handler.Handle(message, default(CancellationToken));

            response.Results.Should().BeSameAs(providerStandardSearchResults);
        }
        public async Task ShouldSignalFailureWhenPostCodeIsEmpty()
        {
            var message = new ProviderSearchQuery {
                ApprenticeshipId = "1", PostCode = string.Empty
            };

            _mockPostcodeIoService.Setup(x => x.GetPostcodeStatus(It.IsAny <string>()))
            .ReturnsAsync("Error");
            var response = await _handler.Handle(message, default(CancellationToken));

            response.Success.Should().BeFalse();
            response.StatusCode.ShouldBeEquivalentTo(ProviderSearchResponseCodes.PostCodeInvalidFormat);
        }
        public async Task ShouldNotValidateThePostCode(string returnCode, ProviderSearchResponseCodes expected)
        {
            var message = new ProviderSearchQuery {
                ApprenticeshipId = "1", PostCode = "nw67xt"
            };

            _mockPostcodeIoService.Setup(m => m.GetPostcodeStatus(It.IsAny <string>()))
            .ReturnsAsync(returnCode);

            var response = await _handler.Handle(message, default(CancellationToken));

            response.Success.Should().BeFalse();
            response.StatusCode.ShouldBeEquivalentTo(expected);
        }
        public async Task ShouldSignalFailureWhenApprenticeshipIsNotFound()
        {
            var providerStandardSearchResults = new ProviderSearchResults {
                ResponseCode = ProviderSearchResponseCodes.ApprenticeshipNotFound.ToString()
            };

            _mockSearchService.Setup(x => x.SearchProviders(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Pagination>(), It.IsAny <IEnumerable <string> >(), It.IsAny <bool>(), It.IsAny <bool>(), 0)).Returns(Task.FromResult(providerStandardSearchResults));
            var message = new ProviderSearchQuery {
                ApprenticeshipId = "1", PostCode = "GU21 6DB", Page = 0
            };

            var response = await _handler.Handle(message, default(CancellationToken));

            response.Success.Should().BeFalse();
            response.StatusCode.ShouldBeEquivalentTo(ProviderSearchResponseCodes.ApprenticeshipNotFound);
        }
        public void GenerateSearchQuery_GeneratesExpectedSearchQuery()
        {
            var query = new ProviderSearchQuery
            {
                SearchText = "TestSearchText",
                Towns      = new[] { "TestTown1", "TestTown2", "TestTown3" },
                Size       = 123
            };

            var result = query.GenerateSearchQuery();

            result.SearchText.Should().Be("TestSearchText*");
            result.Options.SearchMode.Should().Be(SearchMode.All);
            result.Options.Filter.Should().Be("search.in(Town, 'TestTown1|TestTown2|TestTown3', '|')");
            result.Options.Size.Should().Be(123);
        }
        public async Task <ActionResult> StandardResults(ProviderSearchQuery criteria)
        {
            var response = await _mediator.Send(criteria);

            switch (response.StatusCode)
            {
            case ProviderSearchResponseCodes.InvalidApprenticeshipId:
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));

            case ProviderSearchResponseCodes.ApprenticeshipNotFound:
                return(new HttpStatusCodeResult(HttpStatusCode.NotFound));

            case ProviderSearchResponseCodes.ServerError:
                return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError));

            case ProviderSearchResponseCodes.LocationServiceUnavailable:
            case ProviderSearchResponseCodes.PostCodeInvalidFormat:
            case ProviderSearchResponseCodes.WalesPostcode:
            case ProviderSearchResponseCodes.ScotlandPostcode:
            case ProviderSearchResponseCodes.NorthernIrelandPostcode:
            case ProviderSearchResponseCodes.PostCodeTerminated:
                var postCodeUrl = Url.Action(
                    "SearchForStandardProviders",
                    "Apprenticeship",
                    new { standardId = criteria?.ApprenticeshipId, statusCode = response.StatusCode, postCode = criteria?.PostCode, isLevyPayingEmployer = criteria?.IsLevyPayingEmployer });
                return(new RedirectResult(postCodeUrl));

            case ProviderSearchResponseCodes.PageNumberOutOfUpperBound:
                var url = Url.Action(
                    "StandardResults",
                    "Provider",
                    GenerateProviderResultsRouteValues(criteria, response.CurrentPage));
                return(new RedirectResult(url));
            }

            var viewModel = _mappingService.Map <ProviderSearchResponse, ProviderStandardSearchResultViewModel>(response, opt => opt
                                                                                                                .AfterMap((src, dest) =>
            {
                dest.AbsolutePath              = Request?.Url?.AbsolutePath;
                dest.IsLevyPayingEmployer      = criteria.IsLevyPayingEmployer;
                dest.ManageApprenticeshipFunds = new ManageApprenticeshipFundsViewModel(dest.IsLevyPayingEmployer, _settings.ManageApprenticeshipFundsUrl);
                dest.SortOrder = criteria.Order.ToString();
            }));

            return(View(viewModel));
        }
        public async Task ShouldReturnLastPageIfCurrentPageExtendsUpperBound()
        {
            _mockPaginationSettings.Setup(x => x.DefaultResultsAmount).Returns(10);
            var providerStandardSearchResults = new ProviderSearchResults()
            {
                TotalResults = 42, Hits = new List <ProviderSearchResultItem>()
            };

            _mockSearchService.Setup(x => x.SearchProviders(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Pagination>(), It.IsAny <IEnumerable <string> >(), It.IsAny <bool>(), It.IsAny <bool>(), 0)).Returns(Task.FromResult(providerStandardSearchResults));

            var message = new ProviderSearchQuery {
                ApprenticeshipId = "1", PostCode = "GU21 6DB", Page = 8
            };

            var response = await _handler.Handle(message, default(CancellationToken));

            response.CurrentPage.Should().Be(5);
            response.StatusCode.ShouldBeEquivalentTo(ProviderSearchResponseCodes.PageNumberOutOfUpperBound);
        }