listing handler and bulk actions tests completed

lib/Listing/BulkAction.php

@@ -25,7 +25,7 @@ class BulkAction {
     $bulk_action_method = 'bulk'.ucfirst($this->action);
 
     if(!method_exists($this->model_class, $bulk_action_method)) {
-      throw new Exception(
+      throw new \Exception(
         $this->model_class. ' has not method "'.$bulk_action_method.'"'
       );
       return false;

lib/Listing/Handler.php

@@ -87,16 +87,6 @@ class Handler {
     }
   }
 
-  function getSelectionIds() {
-    $models = $this->getSelection()
-      ->select('id')
-      ->findArray();
-
-    return array_map(function($model) {
-      return (int)$model['id'];
-    }, $models);
-  }
-
   function get() {
     // get groups
     $groups = array();

tests/unit/Models/SubscriberTest.php

@@ -313,7 +313,7 @@ class SubscriberTest extends MailPoetTest {
     expect($subscribed_subscribers_in_segment)->count(2);
   }
 
-  function testItCannotTrashAWPUser() {
+  function testItCannotTrashWpUser() {
     $wp_subscriber = Subscriber::createOrUpdate(array(
       'email' => 'some.wp.user@mailpoet.com',
       'wp_user_id' => 1
@@ -325,7 +325,7 @@ class SubscriberTest extends MailPoetTest {
     expect($subscriber->deleted_at)->equals(null);
   }
 
-  function testItCannotDeleteAWPUser() {
+  function testItCannotDeleteWpUser() {
     $wp_subscriber = Subscriber::createOrUpdate(array(
       'email' => 'some.wp.user@mailpoet.com',
       'wp_user_id' => 1

tests/unit/Router/NewslettersTest.php

@@ -9,12 +9,12 @@ class NewslettersTest extends MailPoetTest {
   function _before() {
     $this->newsletter = Newsletter::createOrUpdate(array(
       'subject' => 'My Standard Newsletter',
-      'type' => 'standard'
+      'type' => Newsletter::TYPE_STANDARD
     ));
 
     $this->post_notification = Newsletter::createOrUpdate(array(
       'subject' => 'My Post Notification',
-      'type' => 'notification'
+      'type' => Newsletter::TYPE_NOTIFICATION
     ));
   }
 
@@ -34,7 +34,7 @@ class NewslettersTest extends MailPoetTest {
   function testItCanSaveANewNewsletter() {
     $valid_data = array(
       'subject' => 'My First Newsletter',
-      'type' => 'standard'
+      'type' => Newsletter::TYPE_STANDARD
     );
 
     $router = new Newsletters();
@@ -98,26 +98,26 @@ class NewslettersTest extends MailPoetTest {
     $router = new Newsletters();
     $response = $router->duplicate($this->newsletter->id());
     expect($response['subject'])->equals('Copy of My Standard Newsletter');
-    expect($response['type'])->equals('standard');
+    expect($response['type'])->equals(Newsletter::TYPE_STANDARD);
     expect($response['body'])->equals($this->newsletter->body);
 
     $response = $router->duplicate($this->post_notification->id());
     expect($response['subject'])->equals('Copy of My Post Notification');
-    expect($response['type'])->equals('notification');
+    expect($response['type'])->equals(Newsletter::TYPE_NOTIFICATION);
     expect($response['body'])->equals($this->post_notification->body);
   }
 
   function testItCanCreateANewsletter() {
     $data = array(
       'subject' => 'My New Newsletter',
-      'type' => 'standard'
+      'type' => Newsletter::TYPE_STANDARD
     );
     $router = new Newsletters();
     $response = $router->create($data);
     expect($response['result'])->true();
     expect($response['newsletter']['id'] > 0)->true();
     expect($response['newsletter']['subject'])->equals('My New Newsletter');
-    expect($response['newsletter']['type'])->equals('standard');
+    expect($response['newsletter']['type'])->equals(Newsletter::TYPE_STANDARD);
     expect($response['newsletter']['body'])->equals(array());
     expect($response)->hasntKey('errors');
 
@@ -176,6 +176,110 @@ class NewslettersTest extends MailPoetTest {
       ->equals($segment_2->id);
   }
 
+  function testItCanFilterListing() {
+    // create 2 segments
+    $segment_1 = Segment::createOrUpdate(array('name' => 'Segment 1'));
+    $segment_2 = Segment::createOrUpdate(array('name' => 'Segment 2'));
+
+    // link standard newsletter to the 2 segments
+    $newsletter_segment = NewsletterSegment::create();
+    $newsletter_segment->hydrate(array(
+      'newsletter_id' => $this->newsletter->id(),
+      'segment_id' => $segment_1->id()
+    ));
+    $newsletter_segment->save();
+
+    $newsletter_segment = NewsletterSegment::create();
+    $newsletter_segment->hydrate(array(
+      'newsletter_id' => $this->newsletter->id(),
+      'segment_id' => $segment_2->id()
+    ));
+    $newsletter_segment->save();
+
+    // link post notification to the 2nd segment
+    $newsletter_segment = NewsletterSegment::create();
+    $newsletter_segment->hydrate(array(
+      'newsletter_id' => $this->post_notification->id(),
+      'segment_id' => $segment_2->id()
+    ));
+    $newsletter_segment->save();
+
+    $router = new Newsletters();
+
+    // filter by 1st segment
+    $response = $router->listing(array(
+      'filter' => array(
+        'segment' => $segment_1->id
+      )
+    ));
+
+    // we should only get the standard newsletter
+    expect($response['count'])->equals(1);
+    expect($response['items'][0]['subject'])->equals($this->newsletter->subject);
+
+    // filter by 2nd segment
+    $response = $router->listing(array(
+      'filter' => array(
+        'segment' => $segment_2->id
+      )
+    ));
+
+    // we should have the 2 newsletters
+    expect($response['count'])->equals(2);
+  }
+
+  function testItCanLimitListing() {
+    $router = new Newsletters();
+    // get 1st page (limit items per page to 1)
+    $response = $router->listing(array(
+      'limit' => 1,
+      'sort_by' => 'subject',
+      'sort_order' => 'asc'
+    ));
+
+    expect($response['count'])->equals(2);
+    expect($response['items'])->count(1);
+    expect($response['items'][0]['subject'])->equals(
+      $this->post_notification->subject
+    );
+
+    // get 1st page (limit items per page to 1)
+    $response = $router->listing(array(
+      'limit' => 1,
+      'offset' => 1,
+      'sort_by' => 'subject',
+      'sort_order' => 'asc'
+    ));
+
+    expect($response['count'])->equals(2);
+    expect($response['items'])->count(1);
+    expect($response['items'][0]['subject'])->equals(
+      $this->newsletter->subject
+    );
+  }
+
+  function testItCanBulkDeleteSelectionOfNewsletters() {
+    $newsletter = Newsletter::createOrUpdate(array(
+      'subject' => 'To be deleted',
+      'type' => Newsletter::TYPE_STANDARD
+    ));
+
+    $selection_ids = array(
+      $newsletter->id,
+      $this->newsletter->id
+    );
+
+    $router = new Newsletters();
+    $response = $router->bulkAction(array(
+      'listing' => array(
+        'selection' => $selection_ids
+      ),
+      'action' => 'delete'
+    ));
+
+    expect($response)->equals(count($selection_ids));
+  }
+
   function testItCanBulkDeleteNewsletters() {
     expect(Newsletter::count())->equals(2);
 

tests/unit/Router/SubscribersTest.php

@@ -10,14 +10,16 @@ class SubscribersTest extends MailPoetTest {
     $this->segment_2 = Segment::createOrUpdate(array('name' => 'Segment 2'));
 
     $this->subscriber_1 = Subscriber::createOrUpdate(array(
-      'email' => 'john.doe@mailpoet.com',
+      'email' => 'john@mailpoet.com',
       'first_name' => 'John',
-      'last_name' => 'Doe'
+      'last_name' => 'Doe',
+      'status' => Subscriber::STATUS_UNCONFIRMED
     ));
     $this->subscriber_2 = Subscriber::createOrUpdate(array(
-      'email' => 'jane.doe@mailpoet.com',
+      'email' => 'jane@mailpoet.com',
       'first_name' => 'Jane',
       'last_name' => 'Doe',
+      'status' => Subscriber::STATUS_SUBSCRIBED,
       'segments' => array(
         $this->segment_1->id(),
         $this->segment_2->id()
@@ -43,8 +45,8 @@ class SubscribersTest extends MailPoetTest {
 
   function testItCanSaveANewSubscriber() {
     $valid_data = array(
-      'email' => 'john.doe@mailpoet.com',
+      'email' => 'raul.doe@mailpoet.com',
-      'first_name' => 'John',
+      'first_name' => 'Raul',
       'last_name' => 'Doe',
       'segments' => array(
         $this->segment_1->id(),
@@ -57,7 +59,7 @@ class SubscribersTest extends MailPoetTest {
     expect($response['result'])->true();
     expect($response)->hasntKey('errors');
 
-    $subscriber = Subscriber::where('email', 'john.doe@mailpoet.com')->findOne();
+    $subscriber = Subscriber::where('email', 'raul.doe@mailpoet.com')->findOne();
     $subscriber_segments = $subscriber->segments()->findMany();
     expect($subscriber_segments)->count(2);
     expect($subscriber_segments[0]->name)->equals($this->segment_1->name);
@@ -68,9 +70,7 @@ class SubscribersTest extends MailPoetTest {
     expect($response['errors'][0])->equals('Please enter your email address.');
 
     $invalid_data = array(
-      'email' => 'john.doe@invalid',
+      'email' => 'john.doe@invalid'
-      'first_name' => 'John',
-      'last_name' => 'Doe'
     );
 
     $response = $router->save($invalid_data);
@@ -89,7 +89,7 @@ class SubscribersTest extends MailPoetTest {
     expect($response['result'])->true();
 
     $updated_subscriber = Subscriber::findOne($this->subscriber_2->id());
-    expect($updated_subscriber->email)->equals('jane.doe@mailpoet.com');
+    expect($updated_subscriber->email)->equals($this->subscriber_2->email);
     expect($updated_subscriber->first_name)->equals('Super Jane');
   }
 
@@ -122,6 +122,180 @@ class SubscribersTest extends MailPoetTest {
     expect(Subscriber::findOne($this->subscriber_1->id()))->false();
   }
 
+  function testItCanFilterListing() {
+    $router = new Subscribers();
+
+    // filter by non existing segment
+    $response = $router->listing(array(
+      'filter' => array(
+        'segment' => '### invalid_segment_id ###'
+      )
+    ));
+
+    // it should return all subscribers
+    expect($response['count'])->equals(2);
+
+    // filter by 1st segment
+    $response = $router->listing(array(
+      'filter' => array(
+        'segment' => $this->segment_1->id
+      )
+    ));
+
+    expect($response['count'])->equals(1);
+    expect($response['items'][0]['email'])->equals($this->subscriber_2->email);
+
+    // filter by 2nd segment
+    $response = $router->listing(array(
+      'filter' => array(
+        'segment' => $this->segment_2->id
+      )
+    ));
+
+    expect($response['count'])->equals(1);
+    expect($response['items'][0]['email'])->equals($this->subscriber_2->email);
+  }
+
+  function testItCanSearchListing() {
+    $new_subscriber =  Subscriber::createOrUpdate(array(
+      'email' => 'search.me@find.me',
+      'first_name' => 'Billy Bob',
+      'last_name' => 'Thornton'
+    ));
+
+    $router = new Subscribers();
+
+    // empty search returns everything
+    $response = $router->listing(array(
+      'search' => ''
+    ));
+    expect($response['count'])->equals(3);
+
+    // search by email
+    $response = $router->listing(array(
+      'search' => '.me'
+    ));
+    expect($response['count'])->equals(1);
+    expect($response['items'][0]['email'])->equals($new_subscriber->email);
+
+    // search by last name
+    $response = $router->listing(array(
+      'search' => 'doe'
+    ));
+    expect($response['count'])->equals(2);
+    expect($response['items'][0]['email'])->equals($this->subscriber_1->email);
+    expect($response['items'][1]['email'])->equals($this->subscriber_2->email);
+
+    // search by first name
+    $response = $router->listing(array(
+      'search' => 'billy'
+    ));
+    expect($response['count'])->equals(1);
+    expect($response['items'][0]['email'])->equals($new_subscriber->email);
+  }
+
+  function testItCanGroupListing() {
+    $router = new Subscribers();
+
+    $subscribed_group = $router->listing(array(
+      'group' => Subscriber::STATUS_SUBSCRIBED
+    ));
+    expect($subscribed_group['count'])->equals(1);
+    expect($subscribed_group['items'][0]['email'])->equals(
+      $this->subscriber_2->email
+    );
+
+    $unsubscribed_group = $router->listing(array(
+      'group' => Subscriber::STATUS_UNSUBSCRIBED
+    ));
+    expect($unsubscribed_group['count'])->equals(0);
+
+    $unconfirmed_group = $router->listing(array(
+      'group' => Subscriber::STATUS_UNCONFIRMED
+    ));
+    expect($unconfirmed_group['count'])->equals(1);
+    expect($unconfirmed_group['items'][0]['email'])->equals(
+      $this->subscriber_1->email
+    );
+
+    $trashed_group = $router->listing(array(
+      'group' => 'trash'
+    ));
+    expect($trashed_group['count'])->equals(0);
+
+    // trash 1st subscriber
+    $this->subscriber_1->trash();
+
+    $trashed_group = $router->listing(array(
+      'group' => 'trash'
+    ));
+    expect($trashed_group['count'])->equals(1);
+    expect($trashed_group['items'][0]['email'])->equals(
+      $this->subscriber_1->email
+    );
+  }
+
+  function testItCanSortAndLimitListing() {
+    $router = new Subscribers();
+    // get 1st page (limit items per page to 1)
+    $response = $router->listing(array(
+      'limit' => 1,
+      'sort_by' => 'first_name',
+      'sort_order' => 'asc'
+    ));
+
+    expect($response['count'])->equals(2);
+    expect($response['items'])->count(1);
+    expect($response['items'][0]['email'])->equals(
+      $this->subscriber_2->email
+    );
+
+    // get 1st page (limit items per page to 1)
+    $response = $router->listing(array(
+      'limit' => 1,
+      'offset' => 1,
+      'sort_by' => 'first_name',
+      'sort_order' => 'asc'
+    ));
+
+    expect($response['count'])->equals(2);
+    expect($response['items'])->count(1);
+    expect($response['items'][0]['email'])->equals(
+      $this->subscriber_1->email
+    );
+  }
+
+  function testItCanBulkDeleteSelectionOfSubscribers() {
+    $deletable_subscriber =  Subscriber::createOrUpdate(array(
+      'email' => 'to.be.removed@mailpoet.com'
+    ));
+
+    $selection_ids = array(
+      $this->subscriber_1->id,
+      $deletable_subscriber->id
+    );
+
+    $router = new Subscribers();
+    $response = $router->bulkAction(array(
+      'listing' => array(
+        'selection' => $selection_ids
+      ),
+      'action' => 'delete'
+    ));
+
+    expect($response)->equals(count($selection_ids));
+
+    $is_subscriber_1_deleted = (
+      Subscriber::findOne($this->subscriber_1->id) === false
+    );
+    $is_deletable_subscriber_deleted = (
+      Subscriber::findOne($deletable_subscriber->id) === false
+    );
+
+    expect($is_subscriber_1_deleted)->true();
+    expect($is_deletable_subscriber_deleted)->true();
+  }
+
   function testItCanBulkDeleteSubscribers() {
     expect(Subscriber::count())->equals(2);
 
@@ -144,6 +318,21 @@ class SubscribersTest extends MailPoetTest {
     expect($response)->equals(0);
   }
 
+  function testItCannotRunAnInvalidBulkAction() {
+    try {
+      $router = new Subscribers();
+      $response = $router->bulkAction(array(
+        'action' => 'invalidAction',
+        'listing' => array()
+      ));
+      $this->fail('Bulk Action class did not throw an exception');
+    } catch(Exception $e) {
+      expect($e->getMessage())->equals(
+        '\MailPoet\Models\Subscriber has not method "bulkInvalidAction"'
+      );
+    }
+  }
+
   function _after() {
     Segment::deleteMany();
     Subscriber::deleteMany();

tests/unit/Util/UrlTest.php

@@ -1,7 +1,7 @@
 <?php
 use \MailPoet\Util\Url;
 
-class UrlTest extends MailPoetTest {
+class UtilUrlTest extends MailPoetTest {
   function testItCanReturnCurrentUrl() {
     $current_url = Url::getCurrentUrl();
     expect($current_url)->startsWith('http');