Firesphere\SolrSearch\Tests\SolrCoreServiceTest

Complexity

Total Complexity

13

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Importance

Changes	13
Bugs	2	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	tearDown()	0	9	1
A	testGetSolrVersion()	0	22	1
A	testGetSetClient()	0	6	1
A	testCoreStatus()	0	9	1
A	testWrongUpdateItems()	0	5	1
A	testUpdateItemsFailWrongCall()	0	3	1
A	setUp()	0	5	1
A	testUpdateItemsFail()	0	3	1
A	testUpdateItems()	0	12	1
A	setUpBeforeClass()	0	10	1
A	testUpdateItemsEmptyArray()	0	6	1
A	testCoreUnload()	0	7	1
A	testIndexes()	0	12	1

<?php


namespace Firesphere\SolrSearch\Tests;

use CircleCITestIndex;
use Firesphere\SolrSearch\Queries\BaseQuery;
use Firesphere\SolrSearch\Services\SolrCoreService;
use Firesphere\SolrSearch\Tasks\SolrConfigureTask;
use Firesphere\SolrSearch\Tasks\SolrIndexTask;
use GuzzleHttp\Handler\MockHandler;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Psr7\Response;
use SilverStripe\CMS\Model\SiteTree;
use SilverStripe\Control\HTTPRequestBuilder;
use SilverStripe\Control\NullHTTPRequest;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DatabaseAdmin;
use SilverStripe\ORM\DB;
use Solarium\Core\Client\Client;

class SolrCoreServiceTest extends SapphireTest
{
    /**
     * @var SolrCoreService
     */
    protected $service;

    public static function setUpBeforeClass()
    {
        parent::setUpBeforeClass();
        // This is a hack on my local dev to make fixtures populate temporary database
        $conn = DB::get_conn();
        $dbName = self::tempDB()->build();
        $conn->selectDatabase($dbName);
        $dbAdmin = new DatabaseAdmin();
        $dbAdmin->setRequest(HTTPRequestBuilder::createFromEnvironment());
        $dbAdmin->doBuild(true, true, true);
    }

    public function testIndexes()
    {
        $service = new SolrCoreService();

        $expected = [
            CircleCITestIndex::class,
            TestIndex::class,
            TestIndexTwo::class,
        ];

        $this->assertEquals($expected, $service->getValidIndexes());
        $this->assertEquals([CircleCITestIndex::class], $service->getValidIndexes(CircleCITestIndex::class));
    }


    /**
     * @expectedException \LogicException
     */
    public function testUpdateItemsFail()
    {
        $this->service->updateItems(null, SolrCoreService::CREATE_TYPE);
    }

    /**
     * @expectedException \LogicException
     */
    public function testUpdateItemsFailWrongCall()
    {
        $this->service->updateItems(['test'], SolrCoreService::DELETE_TYPE_ALL);
    }

    public function testUpdateItems()
    {
        $index = new CircleCITestIndex();
        $query = new BaseQuery();
        $query->addTerm('*:*');
        $items = SiteTree::get();

        $result = $this->service->updateItems($items, SolrCoreService::UPDATE_TYPE, CircleCITestIndex::class);
        $this->assertEquals(200, $result->getResponse()->getStatusCode());

        $this->service->updateItems($items, SolrCoreService::DELETE_TYPE, CircleCITestIndex::class);
        $this->assertEquals(0, $index->doSearch($query)->getTotalItems());
    }

    public function testUpdateItemsEmptyArray()
    {
        $index = new CircleCITestIndex();
        $query = new BaseQuery();
        $this->service->doManipulate(ArrayList::create(), SolrCoreService::DELETE_TYPE_ALL, $index);
        $this->assertEquals(0, $index->doSearch($query)->getTotalItems());
    }

    /**
     * @expectedException \LogicException
     */
    public function testWrongUpdateItems()
    {
        $items = SiteTree::get();

        $this->service->updateItems($items, SolrCoreService::UPDATE_TYPE, 'NonExisting');
    }

    public function testCoreStatus()
    {
        $status = $this->service->coreStatus(CircleCITestIndex::class);
        $deprecatedStatus = $this->service->coreIsActive(CircleCITestIndex::class);
        $this->assertEquals($status->getVersion(), $deprecatedStatus->getVersion());
        $this->assertEquals($status->getNumberOfDocuments(), $deprecatedStatus->getNumberOfDocuments());
        $this->assertEquals($status->getCoreName(), $deprecatedStatus->getCoreName());

        $this->assertEquals('CircleCITestIndex', $status->getCoreName());
    }

    public function testCoreUnload()
    {
        $status1 = $this->service->coreStatus(CircleCITestIndex::class);
        $this->service->coreUnload(CircleCITestIndex::class);
        $status2 = $this->service->coreStatus(CircleCITestIndex::class);
        $this->assertEquals(0, $status2->getUptime());
        $this->assertNotEquals($status1->getUptime(), $status2->getUptime());
    }

    public function testGetSetClient()
    {
        $client = $this->service->getClient();
        $this->assertInstanceOf(Client::class, $client);
        $service = $this->service->setClient($client);
        $this->assertInstanceOf(SolrCoreService::class, $service);
    }

    public function testGetSolrVersion()
    {
        $this->assertEquals(5, $this->service->getSolrVersion());
        $version4 = [
            'responseHeader' =>
                [
                    'status' => 0,
                    'QTime'  => 10,
                ],
            'mode'           => 'std',
            'solr_home'      => '/var/solr/data',
            'lucene'         =>
                [
                    'solr-spec-version' => '4.3.2',
                ]
        ];
        $mock = new MockHandler([
            new Response(200, ['X-Foo' => 'Bar'], json_encode($version4)),
        ]);
        $handler = HandlerStack::create($mock);

        $this->assertEquals(4, $this->service->getSolrVersion($handler));
    }

    protected function setUp()
    {
        $this->service = new SolrCoreService();

        return parent::setUp();
    }

    protected function tearDown()
    {
        /** @var SolrConfigureTask $task */
        $task = Injector::inst()->get(SolrConfigureTask::class);
        $task->run(new NullHTTPRequest());
        /** @var SolrIndexTask $task */
        $task = Injector::inst()->get(SolrIndexTask::class);
        $task->run(new NullHTTPRequest());
        parent::tearDown();
    }
}