View source
<?php
namespace Drupal\Tests\facets\Unit\Plugin\processor;
use Drupal\Core\Entity\EntityStorageInterface;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\Entity\TypedData\EntityDataDefinition;
use Drupal\Core\Language\Language;
use Drupal\Core\Language\LanguageManagerInterface;
use Drupal\Core\TypedData\ComplexDataDefinitionInterface;
use Drupal\Core\TypedData\DataReferenceDefinitionInterface;
use Drupal\facets\Entity\Facet;
use Drupal\facets\FacetInterface;
use Drupal\facets\Plugin\facets\processor\TranslateEntityProcessor;
use Drupal\facets\Result\Result;
use Drupal\node\Entity\Node;
use Drupal\taxonomy\Entity\Term;
use Drupal\Tests\UnitTestCase;
use Symfony\Component\DependencyInjection\ContainerBuilder;
class TranslateEntityProcessorTest extends UnitTestCase {
protected $languageManager;
protected $entityTypeManager;
protected function setUp() {
parent::setUp();
$this->languageManager = $this
->getMockBuilder(LanguageManagerInterface::class)
->disableOriginalConstructor()
->getMock();
$language = new Language([
'langcode' => 'en',
]);
$this->languageManager
->expects($this
->any())
->method('getCurrentLanguage')
->will($this
->returnValue($language));
$this->entityTypeManager = $this
->getMockBuilder(EntityTypeManagerInterface::class)
->disableOriginalConstructor()
->getMock();
$container = new ContainerBuilder();
$container
->set('language_manager', $this->languageManager);
$container
->set('entity_type.manager', $this->entityTypeManager);
\Drupal::setContainer($container);
}
public function facetDataProvider() {
$data = [];
foreach ([
'entity_reference',
'entity_reference_revision',
] as $field_type) {
$target_field_definition = $this
->createMock(EntityDataDefinition::class);
$target_field_definition
->expects($this
->once())
->method('getEntityTypeId')
->willReturn('entity_type');
$property_definition = $this
->createMock(DataReferenceDefinitionInterface::class);
$property_definition
->expects($this
->any())
->method('getTargetDefinition')
->willReturn($target_field_definition);
$property_definition
->expects($this
->any())
->method('getDataType')
->willReturn($field_type);
$data_definition = $this
->createMock(ComplexDataDefinitionInterface::class);
$data_definition
->expects($this
->any())
->method('getPropertyDefinition')
->willReturn($property_definition);
$data_definition
->expects($this
->any())
->method('getPropertyDefinitions')
->willReturn([
$property_definition,
]);
$facet = $this
->getMockBuilder(Facet::class)
->disableOriginalConstructor()
->getMock();
$facet
->expects($this
->any())
->method('getDataDefinition')
->willReturn($data_definition);
$facet
->expects($this
->any())
->method('getFieldIdentifier')
->willReturn('testfield');
$results = [
new Result($facet, 2, 2, 5),
];
$facet
->setResults($results);
$data[$field_type][] = $facet;
$data[$field_type][] = $results;
}
return $data;
}
public function testNodeResultsChanged(FacetInterface $facet, array $results) {
$node = $this
->getMockBuilder(Node::class)
->disableOriginalConstructor()
->getMock();
$node
->expects($this
->any())
->method('label')
->willReturn('shaken not stirred');
$nodes = [
2 => $node,
];
$node_storage = $this
->createMock(EntityStorageInterface::class);
$node_storage
->expects($this
->any())
->method('loadMultiple')
->willReturn($nodes);
$this->entityTypeManager
->expects($this
->exactly(1))
->method('getStorage')
->willReturn($node_storage);
$expected_results = [
[
'nid' => 2,
'title' => 'shaken not stirred',
],
];
foreach ($expected_results as $key => $expected) {
$this
->assertEquals($expected['nid'], $results[$key]
->getRawValue());
$this
->assertEquals($expected['nid'], $results[$key]
->getDisplayValue());
}
$processor = new TranslateEntityProcessor([], 'translate_entity', [], $this->languageManager, $this->entityTypeManager);
$filtered_results = $processor
->build($facet, $results);
foreach ($expected_results as $key => $expected) {
$this
->assertEquals($expected['nid'], $filtered_results[$key]
->getRawValue());
$this
->assertEquals($expected['title'], $filtered_results[$key]
->getDisplayValue());
}
}
public function testTermResultsChanged(FacetInterface $facet, array $results) {
$term = $this
->getMockBuilder(Term::class)
->disableOriginalConstructor()
->getMock();
$term
->expects($this
->once())
->method('label')
->willReturn('Burrowing owl');
$terms = [
2 => $term,
];
$term_storage = $this
->createMock(EntityStorageInterface::class);
$term_storage
->expects($this
->any())
->method('loadMultiple')
->willReturn($terms);
$this->entityTypeManager
->expects($this
->exactly(1))
->method('getStorage')
->willReturn($term_storage);
$expected_results = [
[
'tid' => 2,
'name' => 'Burrowing owl',
],
];
foreach ($expected_results as $key => $expected) {
$this
->assertEquals($expected['tid'], $results[$key]
->getRawValue());
$this
->assertEquals($expected['tid'], $results[$key]
->getDisplayValue());
}
$processor = new TranslateEntityProcessor([], 'translate_entity', [], $this->languageManager, $this->entityTypeManager);
$filtered_results = $processor
->build($facet, $results);
foreach ($expected_results as $key => $expected) {
$this
->assertEquals($expected['tid'], $filtered_results[$key]
->getRawValue());
$this
->assertEquals($expected['name'], $filtered_results[$key]
->getDisplayValue());
}
}
public function testDeletedEntityResults(FacetInterface $facet, array $results) {
$term_storage = $this
->createMock(EntityStorageInterface::class);
$term_storage
->expects($this
->any())
->method('loadMultiple')
->willReturn([]);
$this->entityTypeManager
->expects($this
->exactly(1))
->method('getStorage')
->willReturn($term_storage);
$processor = new TranslateEntityProcessor([], 'translate_entity', [], $this->languageManager, $this->entityTypeManager);
$filtered_results = $processor
->build($facet, $results);
$this
->assertEmpty($filtered_results);
}
}