tmgmt-8.x-1.x-dev/sources/content/tests/src/Kernel/ContentEntitySuggestionsTest.php

<?php

namespace Drupal\Tests\tmgmt_content\Kernel;

use Drupal\field\Entity\FieldConfig;
use Drupal\field\Entity\FieldStorageConfig;
use Drupal\menu_link_content\Entity\MenuLinkContent;
use Drupal\node\Entity\Node;
use Drupal\node\Entity\NodeType;
use Drupal\Tests\tmgmt\Kernel\TMGMTKernelTestBase;

/**
 * Basic Source-Suggestions tests.
 *
 * @group tmgmt
 */
class ContentEntitySuggestionsTest extends TMGMTKernelTestBase {

  /**
   * Modules to enable.
   *
   * @var array
   */
  protected static $modules = array('menu_link_content', 'link', 'tmgmt_content', 'tmgmt_test', 'content_translation', 'node', 'filter');

  /**
   * {@inheritdoc}
   */
  public function setUp(): void {
    parent::setUp();
    $this->installEntitySchema('menu_link_content');
    $this->installEntitySchema('node');
    $this->installConfig(['node']);
  }

  /**
   * Prepare a node to get suggestions from.
   *
   * Creates a node with two file fields. The first one is not translatable,
   * the second one is. Both fields got two files attached, where one has
   * translatable content (title and atl-text) and the other one not.
   *
   * @return object
   *   The node which is prepared with all needed fields for the suggestions.
   */
  protected function prepareTranslationSuggestions() {
    // Create an untranslatable node type.
    $untranslatable_type = NodeType::create(['type' => $this->randomMachineName()]);
    $untranslatable_type->save();

    // Create a translatable content type with fields.
    // Only the first field is a translatable reference.
    $type = NodeType::create(['type' => $this->randomMachineName()]);
    $type->save();

    $content_translation_manager = \Drupal::service('content_translation.manager');
    $content_translation_manager->setEnabled('node', $type->id(), TRUE);

    $field1 = FieldStorageConfig::create(array(
      'field_name' => 'field1',
      'entity_type' => 'node',
      'type' => 'entity_reference',
      'cardinality' => -1,
      'settings' => array('target_type' => 'node'),
    ));
    $field1->save();
    $field2 = FieldStorageConfig::create(array(
      'field_name' => 'field2',
      'entity_type' => 'node',
      'type' => 'entity_reference',
      'cardinality' => -1,
      'settings' => array('target_type' => 'node'),
    ));
    $field2->save();
    $embedded_field = FieldStorageConfig::create(array(
      'field_name' => 'embedded_field',
      'entity_type' => 'node',
      'type' => 'entity_reference',
      'cardinality' => -1,
      'settings' => array('target_type' => 'node'),
    ));
    $embedded_field->save();

    $this->config('tmgmt_content.settings')
      ->set('embedded_fields.node.embedded_field', TRUE)
      ->save();

    // Create field instances on the content type.
    FieldConfig::create(array(
      'field_storage' => $field1,
      'bundle' => $type->id(),
      'label' => 'Field 1',
      'translatable' => FALSE,
      'settings' => array(),
    ))->save();
    FieldConfig::create(array(
      'field_storage' => $field2,
      'bundle' => $type->id(),
      'label' => 'Field 2',
      'translatable' => TRUE,
      'settings' => array(),
    ))->save();

    FieldConfig::create(array(
      'field_storage' => $embedded_field,
      'bundle' => $type->id(),
      'label' => 'Field 2',
      'translatable' => TRUE,
      'settings' => array(),
    ))->save();

    // Create a translatable body field.
    node_add_body_field($type);
    $field = FieldConfig::loadByName('node', $type->id(), 'body');
    $field->setTranslatable(TRUE);
    $field->save();

    // Create 4 translatable nodes to be referenced.
    $references = array();
    for ($i = 0; $i < 4; $i++) {
      $references[$i] = Node::create(array(
        'title' => $this->randomMachineName(),
        'body' => $this->randomMachineName(),
        'type' => $type->id(),
      ));
      $references[$i]->save();
    }

    // Create one untranslatable node.
    $untranslatable_node = Node::create([
      'title' => $this->randomMachineName(),
      'type' => $untranslatable_type->id(),
    ]);
    $untranslatable_node->save();

    // Create one node in a different language.
    $different_language_node = Node::create([
      'title' => $this->randomMachineName(),
      'type' => $type->id(),
      'langcode' => 'de',
    ]);
    $different_language_node->save();

    // Create a node with two translatable and two untranslatable references.
    $node = Node::create([
      'title' => $this->randomMachineName(),
      'type' => $type->id(),
      'language' => 'en',
      'body' => $this->randomMachineName(),
      $field1->getName() => [
        ['target_id' => $references[0]->id()],
        ['target_id' => $references[1]->id()],
      ],
      $field2->getName() => [
        ['target_id' => $references[2]->id()],
        ['target_id' => $untranslatable_node->id()],
        ['target_id' => $different_language_node->id()],
      ],
      $embedded_field->getName() => [
        ['target_id' => $references[3]->id()],
      ],
    ]);
    $node->save();

    $link = MenuLinkContent::create([
      'link' => [['uri' => 'entity:node/' . $node->id()]],
      'title' => 'Node menu link',
      'menu_name' => 'main',
    ]);
    $link->save();
    $node->link = $link;

    // Create a second menu link that is in a different language.
    $second_link = MenuLinkContent::create([
      'link' => [['uri' => 'entity:node/' . $node->id()]],
      'title' => 'German Node menu link',
      'menu_name' => 'main',
      'langcode' => 'de'
    ]);
    $second_link->save();

    return $node;
  }

  /**
   * Test suggested entities from a translation job.
   */
  public function testSuggestions() {
    // Prepare a job and a node for testing.
    $job = $this->createJob();
    $node = $this->prepareTranslationSuggestions();
    $expected_nodes = array(
      $node->field1[0]->target_id => $node->field1[0]->target_id,
      $node->field1[1]->target_id => $node->field1[1]->target_id,
      $node->field2[0]->target_id => $node->field2[0]->target_id,
    );
    $item = $job->addItem('content', 'node', $node->id());

    // Get all suggestions and clean the list.
    $suggestions = $job->getSuggestions();
    $job->cleanSuggestionsList($suggestions);

    // There should be 4 suggestions, 3 translatable nodes and the menu link.
    $this->assertEquals(4, count($suggestions));

    foreach ($suggestions as $suggestion) {
      switch ($suggestion['job_item']->getItemType()) {
        case 'node':
          // Check for valid attributes on the node suggestions.
          $this->assertEquals(2, $suggestion['job_item']->getWordCount(), 'Two translatable words in the suggestion.');
          $this->assertEquals('node', $suggestion['job_item']->getItemType(), 'Got a node in the suggestion.');
          $this->assertTrue(in_array($suggestion['job_item']->getItemId(), $expected_nodes), 'Node id match between node and suggestion.');
          unset($expected_nodes[$suggestion['job_item']->getItemId()]);
          break;
        case 'menu_link_content':
          // Check for valid attributes on the menu link suggestions.
          $this->assertEquals(3, $suggestion['job_item']->getWordCount(), 'Three translatable words in the suggestion.');
          $this->assertEquals('menu_link_content', $suggestion['job_item']->getItemType(), 'Got a menu link in the suggestion.');
          $this->assertEquals($node->link->id(), $suggestion['job_item']->getItemId(), 'Menu link id match between menu link and suggestion.');
          break;
        default:
          $this->fail('Found an invalid suggestion.');
          break;
      }
      $this->assertEquals('content', $suggestion['job_item']->getPlugin(), 'Got a content entity as plugin in the suggestion.');
      $this->assertEquals($item->id(), $suggestion['from_item']);
      $job->addExistingItem($suggestion['job_item']);
    }
    // Check that we tested all expected nodes.
    $this->assertTrue(empty($expected_nodes), 'Found unexpected node suggestions.');

    // Add the suggestion to the job and re-get all suggestions.
    $suggestions = $job->getSuggestions();
    $job->cleanSuggestionsList($suggestions);

    // Check for no more suggestions.
    $this->assertCount(0, $suggestions, 'Found no more suggestions.');
  }

}