View source
<?php
namespace Drupal\Tests\search_api\Unit\Processor;
use Drupal\Core\Language\Language;
use Drupal\Core\Language\LanguageInterface;
use Drupal\Core\Language\LanguageManagerInterface;
use Drupal\search_api\IndexInterface;
use Drupal\search_api\Item\Field;
use Drupal\search_api\Item\ItemInterface;
use Drupal\search_api\Plugin\search_api\data_type\value\TextValue;
use Drupal\search_api\Plugin\search_api\processor\Stemmer;
use Drupal\search_api\Query\Condition;
use Drupal\search_api\Query\QueryInterface;
use Drupal\Tests\UnitTestCase;
class StemmerTest extends UnitTestCase {
use ProcessorTestTrait;
use TestItemsTrait;
protected function setUp() {
parent::setUp();
$this
->setUpMockContainer();
$this->processor = new Stemmer([], 'string', []);
}
public function testSupportsIndex() {
$index = $this
->createMock(IndexInterface::class);
$language_manager = $this
->createMock(LanguageManagerInterface::class);
$this->container
->set('language_manager', $language_manager);
$language_manager
->method('getLanguages')
->willReturn([
new Language([
'id' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
]),
]);
$this
->assertFalse(Stemmer::supportsIndex($index));
$language_manager = $this
->createMock(LanguageManagerInterface::class);
$this->container
->set('language_manager', $language_manager);
$language_manager
->method('getLanguages')
->willReturn([
new Language([
'id' => 'de',
]),
new Language([
'id' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
]),
new Language([
'id' => 'fr',
]),
]);
$this
->assertFalse(Stemmer::supportsIndex($index));
$language_manager = $this
->createMock(LanguageManagerInterface::class);
$this->container
->set('language_manager', $language_manager);
$language_manager
->method('getLanguages')
->willReturn([
new Language([
'id' => 'en',
]),
new Language([
'id' => 'fr',
]),
new Language([
'id' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
]),
]);
$this
->assertTrue(Stemmer::supportsIndex($index));
$language_manager = $this
->createMock(LanguageManagerInterface::class);
$this->container
->set('language_manager', $language_manager);
$language_manager
->method('getLanguages')
->willReturn([
new Language([
'id' => 'fr',
]),
new Language([
'id' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
]),
new Language([
'id' => 'en-GB',
]),
]);
$this
->assertTrue(Stemmer::supportsIndex($index));
}
public function testPreprocessIndexItems() {
$index = $this
->createMock(IndexInterface::class);
$item_en = $this
->getMockBuilder(ItemInterface::class)
->disableOriginalConstructor()
->getMock();
$item_en
->method('getLanguage')
->willReturn('en');
$field_en = new Field($index, 'foo');
$field_en
->setType('text');
$field_en
->setValues([
new TextValue('ties'),
]);
$item_en
->method('getFields')
->willReturn([
'foo' => $field_en,
]);
$item_de = $this
->getMockBuilder(ItemInterface::class)
->disableOriginalConstructor()
->getMock();
$item_de
->method('getLanguage')
->willReturn('de');
$field_de = new Field($index, 'foo');
$field_de
->setType('text');
$field_de
->setValues([
new TextValue('ties'),
]);
$item_de
->method('getFields')
->willReturn([
'foo' => $field_de,
]);
$items = [
$item_en,
$item_de,
];
$this->processor
->preprocessIndexItems($items);
$value = $field_en
->getValues()[0];
$this
->assertEquals('tie', $value
->toText());
$value = $field_de
->getValues()[0];
$this
->assertEquals('ties', $value
->toText());
}
public function testPreprocessSearchQuery(array $languages = NULL, $should_process) {
$query = $this
->createMock(QueryInterface::class);
$query
->method('getLanguages')
->willReturn($languages);
$query
->method('getKeys')
->willThrowException(new \RuntimeException());
try {
$this->processor
->preprocessSearchQuery($query);
$this
->assertFalse($should_process, "Keys weren't processed but should have been.");
} catch (\RuntimeException $e) {
$this
->assertTrue($should_process, "Keys were processed but shouldn't have been.");
}
}
public function preprocessSearchQueryDataProvider() {
return [
'language-less query' => [
NULL,
TRUE,
],
'English query' => [
[
'en',
],
TRUE,
],
'Non-English query' => [
[
'de',
],
FALSE,
],
'Multilingual query (including English)' => [
[
'en',
'fr',
'es',
],
TRUE,
],
'Multilingual query (not including English)' => [
[
'de',
'it',
],
FALSE,
],
];
}
public function testProcess($passed_value, $expected_value) {
$this
->invokeMethod('process', [
&$passed_value,
]);
$this
->assertEquals($passed_value, $expected_value);
}
public function processDataProvider() {
return [
[
'Yo',
'yo',
],
[
'ties',
'tie',
],
[
'cries',
'cri',
],
[
'exceed',
'exceed',
],
[
'consign',
'consign',
],
[
'consigned',
'consign',
],
[
'consigning',
'consign',
],
[
'consignment',
'consign',
],
[
'consist',
'consist',
],
[
'consisted',
'consist',
],
[
'consistency',
'consist',
],
[
'consistent',
'consist',
],
[
'consistently',
'consist',
],
[
'consisting',
'consist',
],
[
'consists',
'consist',
],
[
'consolation',
'consol',
],
[
'consolations',
'consol',
],
[
'consolatory',
'consolatori',
],
[
'console',
'consol',
],
[
'consoled',
'consol',
],
[
'consoles',
'consol',
],
[
'consolidate',
'consolid',
],
[
'consolidated',
'consolid',
],
[
'consolidating',
'consolid',
],
[
'consoling',
'consol',
],
[
'consolingly',
'consol',
],
[
'consols',
'consol',
],
[
'consonant',
'conson',
],
[
'consort',
'consort',
],
[
'consorted',
'consort',
],
[
'consorting',
'consort',
],
[
'conspicuous',
'conspicu',
],
[
'conspicuously',
'conspicu',
],
[
'conspiracy',
'conspiraci',
],
[
'conspirator',
'conspir',
],
[
'conspirators',
'conspir',
],
[
'conspire',
'conspir',
],
[
'conspired',
'conspir',
],
[
'conspiring',
'conspir',
],
[
'constable',
'constabl',
],
[
'constables',
'constabl',
],
[
'constance',
'constanc',
],
[
'constancy',
'constanc',
],
[
'constant',
'constant',
],
[
'knack',
'knack',
],
[
'knackeries',
'knackeri',
],
[
'knacks',
'knack',
],
[
'knag',
'knag',
],
[
'knave',
'knave',
],
[
'knaves',
'knave',
],
[
'knavish',
'knavish',
],
[
'kneaded',
'knead',
],
[
'kneading',
'knead',
],
[
'knee',
'knee',
],
[
'kneel',
'kneel',
],
[
'kneeled',
'kneel',
],
[
'kneeling',
'kneel',
],
[
'kneels',
'kneel',
],
[
'knees',
'knee',
],
[
'knell',
'knell',
],
[
'knelt',
'knelt',
],
[
'knew',
'knew',
],
[
'knick',
'knick',
],
[
'knif',
'knif',
],
[
'knife',
'knife',
],
[
'knight',
'knight',
],
[
'knightly',
'knight',
],
[
'knights',
'knight',
],
[
'knit',
'knit',
],
[
'knits',
'knit',
],
[
'knitted',
'knit',
],
[
'knitting',
'knit',
],
[
'knives',
'knive',
],
[
'knob',
'knob',
],
[
'knobs',
'knob',
],
[
'knock',
'knock',
],
[
'knocked',
'knock',
],
[
'knocker',
'knocker',
],
[
'knockers',
'knocker',
],
[
'knocking',
'knock',
],
[
'knocks',
'knock',
],
[
'knopp',
'knopp',
],
[
'knot',
'knot',
],
[
'knots',
'knot',
],
[
" \tExtra spaces \rappeared \n",
'extra space appear',
],
[
"\tspaced-out \r\n",
'space out',
],
];
}
public function testIsNullConditions() {
$index = $this
->createMock(IndexInterface::class);
$index
->method('getFields')
->willReturn([
'field' => (new Field($index, 'field'))
->setType('string'),
]);
$this->processor
->setIndex($index);
$passed_value = NULL;
$this
->invokeMethod('processConditionValue', [
&$passed_value,
]);
$this
->assertSame(NULL, $passed_value);
$condition = new Condition('field', NULL);
$conditions = [
$condition,
];
$this
->invokeMethod('processConditions', [
&$conditions,
]);
$this
->assertSame([
$condition,
], $conditions);
}
}