You are here

Home » API reference » Simplenews 3.x » SimplenewsAdministrationTest.php » SimplenewsAdministrationTest

public function SimplenewsAdministrationTest::testSubscriptionManagement in Simplenews 3.x

Same name and namespace in other branches
  1. 8.2 tests/src/Functional/SimplenewsAdministrationTest.php \Drupal\Tests\simplenews\Functional\SimplenewsAdministrationTest::testSubscriptionManagement()

Test newsletter subscription management.

Steps performed:

File

tests/src/Functional/SimplenewsAdministrationTest.php, line 281

Class

SimplenewsAdministrationTest
Managing of newsletter categories and content types.

Namespace

Drupal\Tests\simplenews\Functional

Code

public function testSubscriptionManagement() {
  $admin_user = $this
    ->drupalCreateUser([
    'administer newsletters',
    'administer simplenews settings',
    'administer simplenews subscriptions',
    'administer users',
  ]);
  $this
    ->drupalLogin($admin_user);

  // Create a newsletter.
  $newsletter_name = mb_strtolower($this
    ->randomMachineName());
  $edit = [
    'name' => $newsletter_name,
    'id' => $newsletter_name,
  ];
  $this
    ->drupalGet('admin/config/services/simplenews/add');
  $this
    ->submitForm($edit, 'Save');

  // This test adds a number of subscribers to each newsletter separately and
  // then adds another bunch to both. First step is to create some arrays
  // that describe the actions to take.
  $subscribers = [];
  $groups = [];
  $newsletters = simplenews_newsletter_get_all();
  foreach ($newsletters as $newsletter) {
    $groups[$newsletter
      ->id()] = [
      $newsletter
        ->id(),
    ];
  }
  $groups['all'] = array_keys($groups);
  $subscribers_flat = [];
  foreach ($groups as $key => $group) {
    for ($i = 0; $i < 5; $i++) {
      $mail = $this
        ->randomEmail();
      $subscribers[$key][$mail] = $mail;
      $subscribers_flat[$mail] = $mail;
    }
  }

  // Create a user and assign one of the mail addresses of the all group.
  // The other subscribers will not be users, just anonymous subscribers.
  $user = $this
    ->drupalCreateUser([
    'subscribe to newsletters',
  ]);

  // Make sure that user_save() does not update the user object, as it will
  // override the pass_raw property which we'll need to log this user in
  // later on.
  $user_mail = current($subscribers['all']);
  $user
    ->setEmail($user_mail);
  $user
    ->save();
  $delimiters = [
    ',',
    ' ',
    "\n",
  ];

  // Add the subscribers using mass subscribe.
  $this
    ->drupalGet('admin/people');
  $this
    ->clickLink('Subscribers');
  $i = 0;
  foreach ($groups as $key => $group) {
    $this
      ->clickLink(t('Mass subscribe'));
    $edit = [
      // Implode with a different, supported delimiter for each group.
      'emails' => implode($delimiters[$i++], $subscribers[$key]),
    ];
    foreach ($group as $newsletter_id) {
      $edit['newsletters[' . $newsletter_id . ']'] = TRUE;
    }
    $this
      ->submitForm($edit, 'Subscribe');
  }

  // Verify that all addresses are displayed in the table.
  $rows = $this
    ->xpath('//tbody/tr');
  $mail_addresses = [];
  for ($i = 0; $i < count($subscribers_flat); $i++) {
    $email = trim($rows[$i]
      ->find('xpath', '/td[1]')
      ->getText());
    $mail_addresses[] = $email;
    if ($email == $user_mail) {

      // The user to which the mail was assigned should show the user name.
      $this
        ->assertEqual(trim($rows[$i]
        ->find('xpath', '/td[2]/a')
        ->getText()), $user
        ->getAccountName());
    }
    else {

      // Blank value for user name.
      $this
        ->assertEqual($rows[$i]
        ->find('xpath', '/td[2]/a'), NULL);
    }
  }
  $this
    ->assertEqual(15, count($mail_addresses));
  foreach ($mail_addresses as $mail_address) {
    $mail_address = (string) $mail_address;
    $this
      ->assertTrue(isset($subscribers_flat[$mail_address]));
    unset($subscribers_flat[$mail_address]);
  }

  // All entries of the array should be removed by now.
  $this
    ->assertTrue(empty($subscribers_flat));
  reset($groups);
  $first = 'default';
  $first_mail = array_rand($subscribers[$first]);
  $all_mail = array_rand($subscribers['all']);

  // Limit list to subscribers of the first newsletter only.
  // Build a flat list of the subscribers of this list.
  $subscribers_flat = array_merge($subscribers[$first], $subscribers['all']);
  $this
    ->drupalGet('admin/people/simplenews', [
    'query' => [
      'subscriptions_target_id' => $first,
    ],
  ]);

  // Verify that all addresses are displayed in the table.
  $rows = $this
    ->xpath('//tbody/tr');
  $mail_addresses = [];
  for ($i = 0; $i < count($subscribers_flat); $i++) {
    $mail_addresses[] = trim($rows[$i]
      ->find('xpath', '/td[1]')
      ->getText());
  }
  $this
    ->assertEqual(10, count($mail_addresses));
  foreach ($mail_addresses as $mail_address) {
    $mail_address = (string) $mail_address;
    $this
      ->assertTrue(isset($subscribers_flat[$mail_address]));
    unset($subscribers_flat[$mail_address]);
  }

  // All entries of the array should be removed by now.
  $this
    ->assertTrue(empty($subscribers_flat));

  // Filter a single mail address, the one assigned to a user.
  $edit = [
    'mail' => mb_substr(current($subscribers['all']), 0, 4),
  ];
  $this
    ->drupalGet('admin/people/simplenews', [
    'query' => [
      'mail' => $edit['mail'],
    ],
  ]);
  $rows = $this
    ->xpath('//tbody/tr');
  $this
    ->assertEqual(1, count($rows));
  $this
    ->assertEqual(current($subscribers['all']), trim($rows[0]
    ->find('xpath', '/td[1]')
    ->getText()));

  // Mysteriously, the username is sometimes a span and sometimes a link.
  // Accept both.
  $this
    ->assertEqual($user
    ->label(), trim($rows[0]
    ->find('xpath', '/td[2]/span|/td[2]/a')
    ->getText()));

  // Reset the filter.
  $this
    ->drupalGet('admin/people/simplenews');

  // Test mass-unsubscribe, unsubscribe one from the first group and one from
  // the all group, but only from the first newsletter.
  unset($subscribers[$first][$first_mail]);
  $edit = [
    'emails' => $first_mail . ', ' . $all_mail,
    'newsletters[' . $first . ']' => TRUE,
  ];
  $this
    ->clickLink(t('Mass unsubscribe'));
  $this
    ->submitForm($edit, 'Unsubscribe');

  // The all mail is still displayed because it's still subscribed to the
  // second newsletter. Reload the page to get rid of the confirmation
  // message.
  $this
    ->drupalGet('admin/people/simplenews');
  $this
    ->assertNoText($first_mail);
  $this
    ->assertText($all_mail);

  // Limit to first newsletter, the all mail shouldn't be shown anymore.
  $this
    ->drupalGet('admin/people/simplenews', [
    'query' => [
      'subscriptions_target_id' => $first,
    ],
  ]);
  $this
    ->assertNoText($first_mail);
  $this
    ->assertNoText($all_mail);

  // Check exporting.
  $this
    ->clickLink(t('Export'));
  $this
    ->submitForm([
    'newsletters[' . $first . ']' => TRUE,
  ], 'Export');
  $export_field = $this
    ->xpath($this
    ->constructFieldXpath('name', 'emails'));
  $exported_mails = $export_field[0]
    ->getText();
  foreach ($subscribers[$first] as $mail) {
    $this
      ->assertStringContainsString($mail, $exported_mails, t('Mail address exported correctly.'));
  }
  foreach ($subscribers['all'] as $mail) {
    if ($mail != $all_mail) {
      $this
        ->assertStringContainsString($mail, $exported_mails, t('Mail address exported correctly.'));
    }
    else {
      $this
        ->assertStringNotContainsString($mail, $exported_mails, t('Unsubscribed mail address not exported.'));
    }
  }

  // Only export unsubscribed mail addresses.
  $edit = [
    'subscribed[subscribed]' => FALSE,
    'subscribed[unsubscribed]' => TRUE,
    'newsletters[' . $first . ']' => TRUE,
  ];
  $this
    ->submitForm($edit, 'Export');
  $export_field = $this
    ->xpath($this
    ->constructFieldXpath('name', 'emails'));
  $exported_mails = $export_field[0]
    ->getText();
  $exported_mails = explode(', ', $exported_mails);
  $this
    ->assertEqual(2, count($exported_mails));
  $this
    ->assertContains($all_mail, $exported_mails);
  $this
    ->assertContains($first_mail, $exported_mails);

  /** @var \Drupal\simplenews\Subscription\SubscriptionManagerInterface $subscription_manager */
  $subscription_manager = \Drupal::service('simplenews.subscription_manager');

  // Make sure there are unconfirmed subscriptions.
  $unconfirmed = [];
  $unconfirmed[] = $this
    ->randomEmail();
  $unconfirmed[] = $this
    ->randomEmail();
  foreach ($unconfirmed as $mail) {
    $subscription_manager
      ->subscribe($mail, $first, TRUE);
  }

  // Export unconfirmed active and inactive users.
  $edit = [
    'states[active]' => TRUE,
    'states[inactive]' => TRUE,
    'subscribed[subscribed]' => FALSE,
    'subscribed[unconfirmed]' => TRUE,
    'subscribed[unsubscribed]' => FALSE,
    'newsletters[' . $first . ']' => TRUE,
  ];
  $this
    ->submitForm($edit, 'Export');
  $export_field = $this
    ->xpath($this
    ->constructFieldXpath('name', 'emails'));
  $exported_mails = $export_field[0]
    ->getText();
  $exported_mails = explode(', ', $exported_mails);
  $this
    ->assertContains($unconfirmed[0], $exported_mails);
  $this
    ->assertContains($unconfirmed[1], $exported_mails);

  // Only export unconfirmed mail addresses.
  $edit = [
    'subscribed[subscribed]' => FALSE,
    'subscribed[unconfirmed]' => TRUE,
    'subscribed[unsubscribed]' => FALSE,
    'newsletters[' . $first . ']' => TRUE,
  ];
  $this
    ->submitForm($edit, 'Export');
  $export_field = $this
    ->xpath($this
    ->constructFieldXpath('name', 'emails'));
  $exported_mails = $export_field[0]
    ->getText();
  $exported_mails = explode(', ', $exported_mails);
  $this
    ->assertEqual(2, count($exported_mails));
  $this
    ->assertContains($unconfirmed[0], $exported_mails);
  $this
    ->assertContains($unconfirmed[1], $exported_mails);

  // Make sure the user is subscribed to the first newsletter_id.
  $spool_storage = \Drupal::service('simplenews.spool_storage');
  $issue = Node::create([
    'type' => 'simplenews_issue',
    'title' => $this
      ->randomString(10),
    'simplenews_issue' => [
      'target_id' => $first,
    ],
  ]);
  $subscription_manager
    ->subscribe($user_mail, $first, FALSE);
  $before_count = $spool_storage
    ->issueCountRecipients($issue);

  // Block the user.
  $user
    ->block();
  $user
    ->save();
  $this
    ->drupalGet('admin/people/simplenews');

  // Verify updated subscriptions count.
  drupal_static_reset('Drupal\\simplenews\\Plugin\\simplenews\\RecipientHandler\\RecipientHandlerBase::count');
  $after_count = $spool_storage
    ->issueCountRecipients($issue);
  $this
    ->assertEqual($before_count - 1, $after_count, t('Blocked users are not counted in subscription count.'));

  // Test mass subscribe with previously unsubscribed users.
  for ($i = 0; $i < 3; $i++) {
    $tested_subscribers[] = $this
      ->randomEmail();
  }
  $subscription_manager
    ->subscribe($tested_subscribers[0], $first, FALSE);
  $subscription_manager
    ->subscribe($tested_subscribers[1], $first, FALSE);
  $subscription_manager
    ->unsubscribe($tested_subscribers[0], $first, FALSE);
  $subscription_manager
    ->unsubscribe($tested_subscribers[1], $first, FALSE);
  $unsubscribed = implode(', ', array_slice($tested_subscribers, 0, 2));
  $edit = [
    'emails' => implode(', ', $tested_subscribers),
    'newsletters[' . $first . ']' => TRUE,
  ];
  $this
    ->drupalGet('admin/people/simplenews/import');
  $this
    ->submitForm($edit, 'Subscribe');
  \Drupal::entityTypeManager()
    ->getStorage('simplenews_subscriber')
    ->resetCache();
  $subscription_manager
    ->reset();
  $this
    ->assertFalse($subscription_manager
    ->isSubscribed($tested_subscribers[0], $first), t('Subscriber not resubscribed through mass subscription.'));
  $this
    ->assertFalse($subscription_manager
    ->isSubscribed($tested_subscribers[1], $first), t('Subscriber not resubscribed through mass subscription.'));
  $this
    ->assertTrue($subscription_manager
    ->isSubscribed($tested_subscribers[2], $first), t('Subscriber subscribed through mass subscription.'));
  $substitutes = [
    '@name' => Newsletter::load($first)
      ->label(),
    '@mail' => $unsubscribed,
  ];
  $this
    ->assertText(t('The following addresses were skipped because they have previously unsubscribed from @name: @mail.', $substitutes));
  $this
    ->assertText(t("If you would like to resubscribe them, use the 'Force resubscription' option."));

  // Try to mass subscribe without specifying newsletters.
  $tested_subscribers[2] = $this
    ->randomEmail();
  $edit = [
    'emails' => implode(', ', $tested_subscribers),
    'resubscribe' => TRUE,
  ];
  $this
    ->drupalGet('admin/people/simplenews/import');
  $this
    ->submitForm($edit, 'Subscribe');
  $this
    ->assertText('Subscribe to field is required.');

  // Test mass subscribe with previously unsubscribed users and force
  // resubscription.
  $tested_subscribers[2] = $this
    ->randomEmail();
  $edit = [
    'emails' => implode(', ', $tested_subscribers),
    'newsletters[' . $first . ']' => TRUE,
    'resubscribe' => TRUE,
  ];
  $this
    ->drupalGet('admin/people/simplenews/import');
  $this
    ->submitForm($edit, 'Subscribe');
  $subscription_manager
    ->reset();
  \Drupal::entityTypeManager()
    ->getStorage('simplenews_subscriber')
    ->resetCache();
  $this
    ->assertTrue($subscription_manager
    ->isSubscribed($tested_subscribers[0], $first, t('Subscriber resubscribed trough mass subscription.')));
  $this
    ->assertTrue($subscription_manager
    ->isSubscribed($tested_subscribers[1], $first, t('Subscriber resubscribed trough mass subscription.')));
  $this
    ->assertTrue($subscription_manager
    ->isSubscribed($tested_subscribers[2], $first, t('Subscriber subscribed trough mass subscription.')));

  // Try to mass unsubscribe without specifying newsletters.
  $tested_subscribers[2] = $this
    ->randomEmail();
  $edit = [
    'emails' => implode(', ', $tested_subscribers),
  ];
  $this
    ->drupalGet('admin/people/simplenews/unsubscribe');
  $this
    ->submitForm($edit, 'Unsubscribe');
  $this
    ->assertText('Unsubscribe from field is required.');

  // Create two blocks, to ensure that they are updated/deleted when a
  // newsletter is deleted.
  $only_first_block = $this
    ->setupSubscriptionBlock([
    'newsletters' => [
      $first,
    ],
  ]);
  $all_block = $this
    ->setupSubscriptionBlock([
    'newsletters' => array_keys($groups),
  ]);
  $enabled_newsletters = $all_block
    ->get('settings')['newsletters'];
  $this
    ->assertContains($first, $enabled_newsletters);

  // Delete newsletter.
  \Drupal::entityTypeManager()
    ->getStorage('simplenews_newsletter')
    ->resetCache();
  $this
    ->drupalGet('admin/config/services/simplenews/manage/' . $first);
  $this
    ->clickLink(t('Delete'));
  $this
    ->submitForm([], 'Delete');
  $this
    ->assertText(t('All subscriptions to newsletter @newsletter have been deleted.', [
    '@newsletter' => $newsletters[$first]->name,
  ]));

  // Verify that all related data has been deleted/updated.
  $this
    ->assertNull(Newsletter::load($first));
  $this
    ->assertNull(Block::load($only_first_block
    ->id()));
  $all_block = Block::load($all_block
    ->id());
  $enabled_newsletters = $all_block
    ->get('settings')['newsletters'];
  $this
    ->assertNotContains($first, $enabled_newsletters);

  // Verify that all subscriptions of that newsletter have been removed.
  $this
    ->drupalGet('admin/people/simplenews');
  foreach ($subscribers[$first] as $mail) {
    $this
      ->assertNoText($mail);
  }
  $this
    ->clickLink(t('Edit'), 1);

  // Get the subscriber id from the path.
  $this
    ->assertEqual(1, preg_match('|admin/people/simplenews/edit/(\\d+)\\?destination|', $this
    ->getUrl(), $matches), 'Subscriber found');
  $subscriber = Subscriber::load($matches[1]);
  $this
    ->assertTitle('Edit subscriber ' . $subscriber
    ->getMail() . ' | Drupal');
  $this
    ->assertFieldChecked('edit-status');

  // Disable account.
  $edit = [
    'status' => FALSE,
  ];
  $this
    ->submitForm($edit, 'Save');
  \Drupal::entityTypeManager()
    ->getStorage('simplenews_subscriber')
    ->resetCache();
  $subscription_manager
    ->reset();
  $this
    ->assertFalse($subscription_manager
    ->isSubscribed($subscriber
    ->getMail(), $this
    ->getRandomNewsletter()), t('Subscriber is not active'));

  // Re-enable account.
  $this
    ->drupalGet('admin/people/simplenews/edit/' . $subscriber
    ->id());
  $this
    ->assertTitle('Edit subscriber ' . $subscriber
    ->getMail() . ' | Drupal');
  $this
    ->assertNoFieldChecked('edit-status');
  $edit = [
    'status' => TRUE,
  ];
  $this
    ->submitForm($edit, 'Save');
  \Drupal::entityTypeManager()
    ->getStorage('simplenews_subscriber')
    ->resetCache();
  $subscription_manager
    ->reset();
  $this
    ->assertTrue($subscription_manager
    ->isSubscribed($subscriber
    ->getMail(), $this
    ->getRandomNewsletter()), t('Subscriber is active again.'));

  // Remove the newsletter.
  $this
    ->drupalGet('admin/people/simplenews/edit/' . $subscriber
    ->id());
  $this
    ->assertTitle('Edit subscriber ' . $subscriber
    ->getMail() . ' | Drupal');
  \Drupal::entityTypeManager()
    ->getStorage('simplenews_subscriber')
    ->resetCache();
  $subscriber = Subscriber::load($subscriber
    ->id());
  $nlids = $subscriber
    ->getSubscribedNewsletterIds();

  // If the subscriber still has subscribed to newsletter, try to unsubscribe.
  $newsletter_id = reset($nlids);
  $edit['subscriptions[' . $newsletter_id . ']'] = FALSE;
  $this
    ->submitForm($edit, 'Save');
  \Drupal::entityTypeManager()
    ->getStorage('simplenews_subscriber')
    ->resetCache();
  $subscription_manager
    ->reset();
  $nlids = $subscriber
    ->getSubscribedNewsletterIds();
  $this
    ->assertFalse($subscription_manager
    ->isSubscribed($subscriber
    ->getMail(), reset($nlids)), t('Subscriber not subscribed anymore.'));

  /*
   * @todo Test Admin subscriber edit preferred $subscription->language
   */

  // Register a subscriber with an insecure e-mail address through the API
  // and make sure the address is correctly encoded.
  $xss_mail = "<script>alert('XSS');</script>";
  $subscription_manager
    ->subscribe($xss_mail, $this
    ->getRandomNewsletter(), FALSE);
  $this
    ->drupalGet('admin/people/simplenews');
  $this
    ->assertNoRaw($xss_mail);
  $this
    ->assertRaw(Html::escape($xss_mail));
  $xss_subscriber = Subscriber::loadByMail($xss_mail);
  $this
    ->drupalGet('admin/people/simplenews/edit/' . $xss_subscriber
    ->id());
  $this
    ->assertNoRaw($xss_mail);
  $this
    ->assertRaw(Html::escape($xss_mail));

  // Create a new user for the next test.
  $new_user = $this
    ->drupalCreateUser([
    'subscribe to newsletters',
  ]);

  // Test for saving the subscription for no newsletter.
  $this
    ->drupalGet('user/' . $new_user
    ->id() . '/simplenews');
  $this
    ->submitForm([], 'Save');
  $this
    ->assertText('The newsletter subscriptions for user ' . $new_user
    ->getAccountName() . ' have been updated.');

  // Editing a subscriber with subscription.
  $edit = [
    'subscriptions[' . $newsletter_name . ']' => TRUE,
    'status' => TRUE,
    'mail[0][value]' => 'edit@example.com',
  ];
  $this
    ->drupalGet('admin/people/simplenews/edit/' . $xss_subscriber
    ->id());
  $this
    ->submitForm($edit, 'Save');
  $this
    ->assertText('Subscriber edit@example.com has been updated.');

  // Create a second newsletter.
  $second_newsletter_name = mb_strtolower($this
    ->randomMachineName());
  $edit2 = [
    'name' => $second_newsletter_name,
    'id' => $second_newsletter_name,
  ];
  $this
    ->drupalGet('admin/config/services/simplenews/add');
  $this
    ->submitForm($edit2, 'Save');

  // Test for adding a subscriber.
  $subscribe = [
    'newsletters[' . $newsletter_name . ']' => TRUE,
    'emails' => 'drupaltest@example.com',
  ];
  $this
    ->drupalGet('admin/people/simplenews/import');
  $this
    ->submitForm($subscribe, 'Subscribe');

  // The subscriber should appear once in the list.
  $rows = $this
    ->xpath('//tbody/tr');
  $counter = 0;
  foreach ($rows as $value) {
    if (trim($value
      ->find('xpath', '/td[1]')
      ->getText()) == 'drupaltest@example.com') {
      $counter++;
    }
  }
  $this
    ->assertEqual(1, $counter);
  $this
    ->assertText(t('The following addresses were added or updated: @email.', [
    '@email' => 'drupaltest@example.com',
  ]));
  $this
    ->assertText(t('The addresses were subscribed to the following newsletters: @newsletter.', [
    '@newsletter' => $newsletter_name,
  ]));

  // Check exact subscription statuses.
  $subscriber = Subscriber::loadByMail('drupaltest@example.com');
  $this
    ->assertEqual($subscriber
    ->getSubscription($newsletter_name)
    ->get('status')
    ->getValue(), SIMPLENEWS_SUBSCRIPTION_STATUS_SUBSCRIBED);

  // The second newsletter was not subscribed, so there should be no
  // subscription record at all.
  $this
    ->assertFalse($subscriber
    ->getSubscription($second_newsletter_name));
}