ApacheSolrForTypo3\Solr\Tests\Unit\Domain\Search\ResultSet\SearchResultSetTest

Complexity

Total Complexity

12

Size/Duplication

Total Lines	250
Duplicated Lines	4.4 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes	3
Bugs	1	Features	0

<?php
class SearchResultSetTest extends UnitTest
{

    /**
     * @var TypoScriptConfiguration
     */
    protected $configurationMock;

    /**
     * @var Search
     */
    protected $searchMock;

    /**
     * @var AbstractPlugin
     */
    protected $pluginMock;

    /**
     * @var SearchResultSetService
     */
    protected $searchResultSetService;

    /**
     * @return void
     */
    public function setUp()
    {
        $this->configurationMock = $this->getDumbMock('ApacheSolrForTypo3\Solr\System\Configuration\TypoScriptConfiguration');
        $this->searchMock = $this->getDumbMock('ApacheSolrForTypo3\Solr\Search');
        $this->pluginMock = $this->getDumbMock('TYPO3\CMS\Frontend\Plugin\AbstractPlugin');

        $this->searchResultSetService = $this->getMockBuilder(SearchResultSetService::class)
            ->setMethods(['setPerPageInSession', 'getPerPageFromSession', 'getRegisteredSearchComponents'])
            ->setConstructorArgs([$this->configurationMock, $this->searchMock, $this->pluginMock])
            ->getMock();
    }

    /**
     * @param $fakedRegisteredComponents
     */
    protected function fakeRegisteredSearchComponents(array $fakedRegisteredComponents)
    {
        $this->searchResultSetService->expects($this->once())->method('getRegisteredSearchComponents')->will(
            $this->returnValue($fakedRegisteredComponents)
        );
    }

    /**
     * @test
     */
    public function testSearchIfFiredWithInitializedQuery()
    {
        $this->fakeRegisteredSearchComponents(array());

            // we expect the the ->search method on the Search object will be called once
            // and we pass the response that should be returned when it was call to compare
            // later if we retrieve the expected result
        $fakeResponse = $this->getDumbMock('\Apache_Solr_Response');
        $this->assertOneSearchWillBeTriggeredWithQueryAndShouldReturnFakeResponse('my search', 0, $fakeResponse);

        $fakeRequest = new SearchRequest(array('q' => 'my search'));

        $this->assertPerPageInSessionWillNotBeChanged();
        $resultSet = $this->searchResultSetService->search($fakeRequest);
        $this->assertSame($resultSet->getResponse(), $fakeResponse, 'Did not get the expected fakeResponse');
    }

     /**
     * @test
     */
    public function testOffsetIsPassedAsExpectedWhenSearchWasPaginated()
    {
        $this->fakeRegisteredSearchComponents(array());

        $fakeResponse = $this->getDumbMock('\Apache_Solr_Response');
        $this->assertOneSearchWillBeTriggeredWithQueryAndShouldReturnFakeResponse('my 2. search', 50, $fakeResponse);
        $this->configurationMock->expects($this->once())->method('getSearchResultsPerPage')->will($this->returnValue(25));

        $fakeRequest = new SearchRequest(array('q' => 'my 2. search', 'tx_solr' => array('page' => 2)));

        $this->assertPerPageInSessionWillNotBeChanged();
        $resultSet = $this->searchResultSetService->search($fakeRequest);
        $this->assertSame($resultSet->getResponse(), $fakeResponse, 'Did not get the expected fakeResponse');
    }

    /**
     * @test
     */
    public function testQueryAwareComponentGetsInitialized()
    {
        $this->configurationMock->expects($this->once())->method('getSearchConfiguration')->will($this->returnValue(array()));

            // we expect that the initialize method of our component will be called
        $fakeQueryAwareSpellChecker = $this->getDumbMock('\ApacheSolrForTypo3\Solr\Search\SpellcheckingComponent');
        $fakeQueryAwareSpellChecker->expects($this->once())->method('initializeSearchComponent');
        $fakeQueryAwareSpellChecker->expects($this->once())->method('setQuery');


        $this->fakeRegisteredSearchComponents(array($fakeQueryAwareSpellChecker));
        $fakeResponse = $this->getDumbMock('\Apache_Solr_Response');
        $this->assertOneSearchWillBeTriggeredWithQueryAndShouldReturnFakeResponse('my 3. search', 0, $fakeResponse);

        $fakeRequest = new SearchRequest(array('q' => 'my 3. search'));

        $this->assertPerPageInSessionWillNotBeChanged();
        $resultSet = $this->searchResultSetService->search($fakeRequest);
        $this->assertSame($resultSet->getResponse(), $fakeResponse, 'Did not get the expected fakeResponse');
    }

    /**
     * @test
     */
    public function canRegisterSearchResponseProcessor()
    {
        $processSearchResponseBackup = $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['processSearchResponse'];

        $testProcessor = 'ApacheSolrForTypo3\\Solr\\Tests\\Unit\\Domain\\Search\\ResultSet\\TestSearchResponseProcessor';
        $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['processSearchResponse']['testProcessor'] = $testProcessor;
        $this->fakeRegisteredSearchComponents(array());

        $fakedSolrResponse = $this->getFixtureContent("fakeResponse.json");
        $fakeHttpResponse = $this->getDumbMock('\Apache_Solr_HttpTransport_Response');
        $fakeHttpResponse->expects($this->once())->method('getBody')->will($this->returnValue($fakedSolrResponse));

        $fakeResponse =new \Apache_Solr_Response($fakeHttpResponse);
        $this->assertOneSearchWillBeTriggeredWithQueryAndShouldReturnFakeResponse('my 4. search', 0, $fakeResponse);

        $fakeRequest = new SearchRequest(array('q' => 'my 4. search'));
        $this->assertPerPageInSessionWillNotBeChanged();
        $resultSet  = $this->searchResultSetService->search($fakeRequest);

        $response   = $resultSet->getResponse();
        $documents  = $response->response->docs;

        $this->assertSame(3, count($documents), 'Did not get 3 documents from fake response');
        $firstResult = $documents[0];
        $this->assertSame("PAGES", $firstResult->type, 'Could not get modified type from result');

        $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['solr']['processSearchResponse'] = $processSearchResponseBackup;
    }


    /**
     * @test
     */
    public function testGoingToFirstPageWhenResultPerPageWasChanged()
    {
        $this->fakeRegisteredSearchComponents(array());
        $this->configurationMock->expects($this->once())->method('getSearchResultsPerPageSwitchOptionsAsArray')
                                ->will($this->returnValue(array(10, 25)));

        $fakeRequest = new SearchRequest(
            array(
                'q' => 'test',
                'tx_solr' => array('page' => 5, 'resultsPerPage' => 25)
            )
        );

            // we expect that still an offset of 0 is passed because page was 5 AND perPageWas passed which means
            // that the perPage value has changed.
        $fakeResponse = $this->getDumbMock('\Apache_Solr_Response');
        $this->assertOneSearchWillBeTriggeredWithQueryAndShouldReturnFakeResponse('test', 0, $fakeResponse);
        $this->assertPerPageInSessionWillBeChanged();

        $resultSet = $this->searchResultSetService->search($fakeRequest);
        $this->assertSame($resultSet->getResponse(), $fakeResponse, 'Did not get the expected fakeResponse');
    }

    /**
     * @test
     */
    public function testAdditionalFiltersGetPassedToTheQuery()
    {
        $this->fakeRegisteredSearchComponents(array());
        $fakeResponse = $this->getDumbMock('\Apache_Solr_Response');

        $this->assertOneSearchWillBeTriggeredWithQueryAndShouldReturnFakeResponse('test', 0, $fakeResponse);

        $this->configurationMock->expects($this->any())->method('getSearchQueryFilterConfiguration')->will(
            $this->returnValue(array('type:pages'))
        );
        $fakeRequest = new SearchRequest(array('q' => 'test'));

        $this->assertOneSearchWillBeTriggeredWithQueryAndShouldReturnFakeResponse('test', 0, $fakeResponse);
        $this->assertPerPageInSessionWillNotBeChanged();

        $resultSet = $this->searchResultSetService->search($fakeRequest);

        $this->assertSame($resultSet->getResponse(), $fakeResponse, 'Did not get the expected fakeResponse');
        $this->assertSame(count($resultSet->getUsedQuery()->getFilters()), 1, 'There should be one registered filter in the query');
    }

    /**
     * @test
     */
    public function testExpandedDocumentsGetAddedWhenVariantsAreConfigured()
    {
        // we fake that collapsing is enabled
        $this->configurationMock->expects($this->atLeastOnce())->method('getSearchVariants')->will($this->returnValue(true));

            // in this case we collapse on the type field
        $this->configurationMock->expects($this->atLeastOnce())->method('getSearchVariantsField')->will($this->returnValue('type'));

        $this->fakeRegisteredSearchComponents(array());
        $fakedSolrResponse = $this->getFixtureContent("fakeCollapsedResponse.json");
        $fakeHttpResponse = $this->getDumbMock('\Apache_Solr_HttpTransport_Response');
        $fakeHttpResponse->expects($this->once())->method('getBody')->will($this->returnValue($fakedSolrResponse));

        $fakeResponse =new \Apache_Solr_Response($fakeHttpResponse);
        $this->assertOneSearchWillBeTriggeredWithQueryAndShouldReturnFakeResponse('variantsSearch', 0, $fakeResponse);

        $fakeRequest = new SearchRequest(array('q' => 'variantsSearch'));

        $resultSet = $this->searchResultSetService->search($fakeRequest);
        $this->assertSame(1, count($resultSet->getResponse()->response->docs), 'Unexpected amount of document');

            /** @var  $fistResult SearchResult */
        $fistResult = $resultSet->getResponse()->response->docs[0];
        $this->assertSame(5, count($fistResult->getVariants()), 'Unexpected amount of expanded result');
    }

    /**
     * @param string $expextedQueryString
     * @param integer $expectedOffset
     * @param \Apache_Solr_Response $fakeResponse
     */
    public function assertOneSearchWillBeTriggeredWithQueryAndShouldReturnFakeResponse($expextedQueryString, $expectedOffset, \Apache_Solr_Response $fakeResponse)
    {
        $this->searchMock->expects($this->once())->method('search')->with($expextedQueryString, $expectedOffset, null)->will(
            $this->returnValue($fakeResponse)
        );
    }

    /**
     * @return void
     */
    private function assertPerPageInSessionWillBeChanged()
    {
        $this->searchResultSetService->expects($this->once())->method('setPerPageInSession');
    }

    /**
     * @return void
     */
    private function assertPerPageInSessionWillNotBeChanged()
    {
        $this->searchResultSetService->expects($this->never())->method('setPerPageInSession');
    }
}