public function SchedulerRulesConditionsTest::testEntityTypeEnabledConditions in Scheduler 2.x

Tests the conditions for whether an entity type is enabled for Scheduler.

@dataProvider dataStandardEntityTypes()

File

tests/src/Functional/SchedulerRulesConditionsTest.php, line 35

Class

SchedulerRulesConditionsTest

Tests the four conditions that Scheduler provides for use in Rules module.

Namespace

Drupal\Tests\scheduler\Functional

Code

public function testEntityTypeEnabledConditions($entityTypeId, $bundle) {

  // The legacy rules condition ids for nodes remain as:
  // -  scheduler_condition_publishing_is_enabled
  // -  scheduler_condition_unpublishing_is_enabled
  // For all other entity types the new derived condition ids are of the form:
  // -  scheduler_publishing_is_enabled:{type}
  // -  scheduler_unpublishing_is_enabled:{type}
  // .
  $condition_prefix = $entityTypeId == 'node' ? 'scheduler_condition_' : 'scheduler_';
  $condition_suffix = $entityTypeId == 'node' ? '' : ":{$entityTypeId}";
  $entityType = $this
    ->entityTypeObject($entityTypeId, $bundle);
  $assert = $this
    ->assertSession();

  // Create a reaction rule to display a message when viewing an entity of a
  // type that is enabled for scheduled publishing.
  // "viewing content" actually means "viewing PUBLISHED content".
  $rule1 = $this->expressionManager
    ->createRule();
  $rule1
    ->addCondition("{$condition_prefix}publishing_is_enabled{$condition_suffix}", ContextConfig::create()
    ->map("{$entityTypeId}", "{$entityTypeId}"));
  $message1 = 'RULES message 1. This entity type is enabled for scheduled publishing.';
  $rule1
    ->addAction('rules_system_message', ContextConfig::create()
    ->setValue('message', $message1)
    ->setValue('type', 'status'));
  $config_entity = $this->rulesStorage
    ->create([
    'id' => 'rule1',
    'events' => [
      [
        'event_name' => "rules_entity_view:{$entityTypeId}",
      ],
    ],
    'expression' => $rule1
      ->getConfiguration(),
  ]);
  $config_entity
    ->save();

  // Create a reaction rule to display a message when viewing an entity of a
  // type that is enabled for scheduled unpublishing.
  $rule2 = $this->expressionManager
    ->createRule();
  $rule2
    ->addCondition("{$condition_prefix}unpublishing_is_enabled{$condition_suffix}", ContextConfig::create()
    ->map("{$entityTypeId}", "{$entityTypeId}"));
  $message2 = 'RULES message 2. This entity type is enabled for scheduled unpublishing.';
  $rule2
    ->addAction('rules_system_message', ContextConfig::create()
    ->setValue('message', $message2)
    ->setValue('type', 'status'));
  $config_entity = $this->rulesStorage
    ->create([
    'id' => 'rule2',
    'events' => [
      [
        'event_name' => "rules_entity_view:{$entityTypeId}",
      ],
    ],
    'expression' => $rule2
      ->getConfiguration(),
  ]);
  $config_entity
    ->save();

  // Create a reaction rule to display a message when viewing an entity of a
  // type that is NOT enabled for scheduled publishing.
  $rule3 = $this->expressionManager
    ->createRule();
  $rule3
    ->addCondition("{$condition_prefix}publishing_is_enabled{$condition_suffix}", ContextConfig::create()
    ->map("{$entityTypeId}", "{$entityTypeId}")
    ->negateResult());
  $message3 = 'RULES message 3. This entity type is not enabled for scheduled publishing.';
  $rule3
    ->addAction('rules_system_message', ContextConfig::create()
    ->setValue('message', $message3)
    ->setValue('type', 'status'));
  $config_entity = $this->rulesStorage
    ->create([
    'id' => 'rule3',
    'events' => [
      [
        'event_name' => "rules_entity_view:{$entityTypeId}",
      ],
    ],
    'expression' => $rule3
      ->getConfiguration(),
  ]);
  $config_entity
    ->save();

  // Create a reaction rule to display a message when viewing an entity of a
  // type that is NOT enabled for scheduled unpublishing.
  $rule4 = $this->expressionManager
    ->createRule();
  $rule4
    ->addCondition("{$condition_prefix}unpublishing_is_enabled{$condition_suffix}", ContextConfig::create()
    ->map("{$entityTypeId}", "{$entityTypeId}")
    ->negateResult());
  $message4 = 'RULES message 4. This entity type is not enabled for scheduled unpublishing.';
  $rule4
    ->addAction('rules_system_message', ContextConfig::create()
    ->setValue('message', $message4)
    ->setValue('type', 'status'));
  $config_entity = $this->rulesStorage
    ->create([
    'id' => 'rule4',
    'events' => [
      [
        'event_name' => "rules_entity_view:{$entityTypeId}",
      ],
    ],
    'expression' => $rule4
      ->getConfiguration(),
  ]);
  $config_entity
    ->save();

  // Create a published entity.
  $entity = $this
    ->createEntity($entityTypeId, $bundle, [
    'title' => "Enabled Conditions - {$entityTypeId} {$bundle}",
    'status' => TRUE,
  ]);

  // View the entity and check the default position - that the entity type is
  // enabled for both publishing and unpublishing.
  $this
    ->drupalGet($entity
    ->toUrl());
  $assert
    ->pageTextContains($message1);
  $assert
    ->pageTextContains($message2);
  $assert
    ->pageTextNotContains($message3);
  $assert
    ->pageTextNotContains($message4);

  // Turn off scheduled publishing for the entity type and check the rules.
  $entityType
    ->setThirdPartySetting('scheduler', 'publish_enable', FALSE)
    ->save();
  drupal_flush_all_caches();
  $this
    ->drupalGet($entity
    ->toUrl());
  $assert
    ->pageTextNotContains($message1);
  $assert
    ->pageTextContains($message2);
  $assert
    ->pageTextContains($message3);
  $assert
    ->pageTextNotContains($message4);

  // Turn off scheduled unpublishing for the entity type and the check again.
  $entityType
    ->setThirdPartySetting('scheduler', 'unpublish_enable', FALSE)
    ->save();
  drupal_flush_all_caches();
  $this
    ->drupalGet($entity
    ->toUrl());
  $assert
    ->pageTextNotContains($message1);
  $assert
    ->pageTextNotContains($message2);
  $assert
    ->pageTextContains($message3);
  $assert
    ->pageTextContains($message4);
}