Major update of unit tests / updated routers + models + react

assets/js/src/newsletters/templates.jsx

@@ -29,7 +29,7 @@ define(
           action: 'save',
           data: template
         }).done(function(response) {
-          if(response === true) {
+          if(response.result === true) {
             this.props.onImport(template);
           } else {
             response.map(function(error) {

assets/js/src/newsletters/types.jsx

@@ -29,12 +29,14 @@ define(
             subject: 'Draft newsletter',
           }
         }).done(function(response) {
-          if(response.id !== undefined) {
+          if(response.result && response.newsletter.id) {
-            this.history.pushState(null, `/template/${response.id}`);
+            this.history.pushState(null, `/template/${response.newsletter.id}`);
           } else {
-            response.map(function(error) {
+            if(response.errors.length > 0) {
-              MailPoet.Notice.error(error);
+              response.errors.map(function(error) {
-            });
+                MailPoet.Notice.error(error);
+              });
+            }
           }
         }.bind(this));
       },

assets/js/src/newsletters/types/notification.jsx

@@ -138,12 +138,14 @@ define(
             options: this.state,
           },
         }).done(function(response) {
-          if(response.id !== undefined) {
+          if(response.result && response.newsletter.id) {
-            this.showTemplateSelection(response.id);
+            this.showTemplateSelection(response.newsletter.id);
           } else {
-            response.map(function(error) {
+            if(response.errors.length > 0) {
-              MailPoet.Notice.error(error);
+              response.errors.map(function(error) {
-            });
+                MailPoet.Notice.error(error);
+              });
+            }
           }
         }.bind(this));
       },

assets/js/src/newsletters/types/standard.jsx

@@ -32,12 +32,15 @@ define(
             type: 'standard',
           }
         }).done(function(response) {
-          if(response.id !== undefined) {
+          console.log(response);
-            this.showTemplateSelection(response.id);
+          if(response.result && response.newsletter.id) {
+            this.showTemplateSelection(response.newsletter.id);
           } else {
-            response.map(function(error) {
+            if(response.errors.length > 0) {
-              MailPoet.Notice.error(error);
+              response.errors.map(function(error) {
-            });
+                MailPoet.Notice.error(error);
+              });
+            }
           }
         }.bind(this));
       },

assets/js/src/newsletters/types/welcome.jsx

@@ -111,12 +111,14 @@ define(
             options: this.state,
           },
         }).done(function(response) {
-          if(response.id !== undefined) {
+          if(response.result && response.newsletter.id) {
-            this.showTemplateSelection(response.id);
+            this.showTemplateSelection(response.newsletter.id);
           } else {
-            response.map(function(error) {
+            if(response.errors.length > 0) {
-              MailPoet.Notice.error(error);
+              response.errors.map(function(error) {
-            });
+                MailPoet.Notice.error(error);
+              });
+            }
           }
         }.bind(this));
       },

lib/Models/CustomField.php

@@ -19,20 +19,24 @@ class CustomField extends Model {
   function asArray() {
     $model = parent::asArray();
 
-    $model['params'] = (
+    if(isset($model['params'])) {
-      is_serialized($this->params)
+      $model['params'] = (
-      ? unserialize($this->params)
+        is_array($this->params)
-      : $this->params
+        ? $this->params
-    );
+        : unserialize($this->params)
-
+      );
+    }
     return $model;
   }
 
   function save() {
+    if(is_null($this->params)) {
+      $this->params = array();
+    }
     $this->set('params', (
-      is_serialized($this->params)
+      is_array($this->params)
-      ? $this->params
+      ? serialize($this->params)
-      : serialize($this->params)
+      : $this->params
     ));
     return parent::save();
   }
@@ -66,12 +70,6 @@ class CustomField extends Model {
       $custom_field->set($data);
     }
 
-    try {
+    return $custom_field->save();
-      $custom_field->save();
-      return $custom_field;
-    } catch(Exception $e) {
-      return $custom_field->getValidationErrors();
-    }
-    return false;
   }
 }

lib/Models/Newsletter.php

@@ -8,6 +8,10 @@ class Newsletter extends Model {
 
   function __construct() {
     parent::__construct();
+
+    $this->addValidations('type', array(
+      'required' => __('You need to specify a type.')
+    ));
   }
 
   function save() {
@@ -15,9 +19,23 @@ class Newsletter extends Model {
       $this->set_expr('deleted_at', 'NULL');
     }
 
+    $this->set('body',
+      is_array($this->body)
+      ? json_encode($this->body)
+      : $this->body
+    );
     return parent::save();
   }
 
+  function asArray() {
+    $model = parent::asArray();
+
+    if(isset($model['body'])) {
+      $model['body'] = json_decode($model['body'], true);
+    }
+    return $model;
+  }
+
   function delete() {
     // delete all relations to segments
     NewsletterSegment::where('newsletter_id', $this->id)->deleteMany();

lib/Router/CustomFields.php

@@ -33,30 +33,19 @@ class CustomFields {
 
   function save($data = array()) {
     $custom_field = CustomField::createOrUpdate($data);
+    $errors = $custom_field->getErrors();
 
-    if($custom_field === false) {
+    if(!empty($errors)) {
-      $result = array(
+      return array(
         'result' => false,
-        'errors' => array(
+        'errors' => $errors
-          __('The custom field could not be created.')
-        )
       );
     } else {
-      $errors = $custom_field->getValidationErrors();
+      return array(
-      if(!empty($errors)) {
+        'result' => true,
-        $result = array(
+        'field' => $custom_field->asArray()
-          'result' => false,
+      );
-          'errors' => $errors
-        );
-      } else {
-        $result = array(
-          'result' => true,
-          'field' => $custom_field->asArray()
-        );
-      }
     }
-
-    return $result;
   }
 
   function get($id) {

lib/Router/Forms.php

@@ -47,10 +47,6 @@ class Forms {
     return $listing_data;
   }
 
-  function getAll() {
-    return Form::findArray();
-  }
-
   function create() {
     // create new form
     $form_data = array(
@@ -89,16 +85,17 @@ class Forms {
 
   function save($data = array()) {
     $form = Form::createOrUpdate($data);
+    $errors = $form->getErrors();
 
-    if($form !== false && $form->id()) {
+    if(!empty($errors)) {
       return array(
-        'result' => true,
+        'result' => false,
-        'form_id' => $form->id()
+        'errors' => $errors
       );
     } else {
       return array(
-        'result' => false,
+        'result' => true,
-        'errors' => $form->getValidationErrors()
+        'form_id' => $form->id()
       );
     }
   }

lib/Router/NewsletterTemplates.php

@@ -26,21 +26,16 @@ class NewsletterTemplates {
   }
 
   function save($data = array()) {
-    $result = NewsletterTemplate::createOrUpdate($data);
+    $template = NewsletterTemplate::createOrUpdate($data);
-    if($result !== true) {
+    return ($template->getErrors() === false && $template->id() > 0);
-      return $result;
-    } else {
-      return true;
-    }
   }
 
   function delete($id) {
     $template = NewsletterTemplate::findOne($id);
     if($template !== false) {
-      $result = $template->delete();
+      return $template->delete();
     } else {
-      $result = false;
+      return false;
     }
-    return $result;
   }
 }

lib/Router/Newsletters.php

@@ -33,42 +33,32 @@ class Newsletters {
         return $segment['id'];
       }, $segments);
       $newsletter['options'] = $options;
-      $newsletter['body'] = json_decode($newsletter['body']);
-
       return $newsletter;
     }
   }
 
-  function getAll() {
-    $collection = Newsletter::findArray();
-    $collection = array_map(function($item) {
-      $item['body'] = json_decode($item['body']);
-      return $item;
-    }, $collection);
-    wp_send_json($collection);
-  }
-
   function save($data = array()) {
+    $segment_ids = array();
     if(isset($data['segments'])) {
       $segment_ids = $data['segments'];
       unset($data['segments']);
     }
 
+    $options = array();
     if(isset($data['options'])) {
       $options = $data['options'];
       unset($data['options']);
     }
 
-    $errors = array();
-    $result = false;
-
     $newsletter = Newsletter::createOrUpdate($data);
+    $errors = $newsletter->getErrors();
 
-    if($newsletter !== false && !$newsletter->id()) {
+    if(!empty($errors)) {
-      $errors = $newsletter->getValidationErrors();
+      return array(
+        'result' => false,
+        'errors' => $errors
+      );
     } else {
-      $result = true;
-
       if(!empty($segment_ids)) {
         NewsletterSegment::where('newsletter_id', $newsletter->id)
           ->deleteMany();
@@ -100,117 +90,51 @@ class Newsletters {
           }
         }
       }
+
+      return array(
+        'result' => true
+      );
     }
-    wp_send_json(array(
-      'result' => $result,
-      'errors' => $errors
-    ));
   }
 
   function restore($id) {
-    $result = false;
-
     $newsletter = Newsletter::findOne($id);
     if($newsletter !== false) {
-      $result = $newsletter->restore();
+      $newsletter->restore();
     }
-
+    return ($newsletter->getErrors() === false);
-    wp_send_json($result);
   }
 
   function trash($id) {
-    $result = false;
-
     $newsletter = Newsletter::findOne($id);
     if($newsletter !== false) {
-      $result = $newsletter->trash();
+      $newsletter->trash();
     }
-
+    return ($newsletter->getErrors() === false);
-    wp_send_json($result);
   }
 
   function delete($id) {
-    $result = false;
-
     $newsletter = Newsletter::findOne($id);
     if($newsletter !== false) {
       $newsletter->delete();
-      $result = 1;
+      return 1;
     }
-
+    return false;
-    wp_send_json($result);
   }
 
-  function duplicate($id) {
+  function duplicate($id = false) {
-    $result = false;
-
     $newsletter = Newsletter::findOne($id);
     if($newsletter !== false) {
-      $data = array(
+      return $newsletter->duplicate(array(
         'subject' => sprintf(__('Copy of %s'), $newsletter->subject)
-      );
+      ))->asArray();
-      $result = $newsletter->duplicate($data)->asArray();
     }
-
+    return false;
-    wp_send_json($result);
-  }
-
-  function send($data = array()) {
-    $newsletter = Newsletter::findOne($data['id'])->asArray();
-
-    if(empty($data['segments'])) {
-      return wp_send_json(array(
-        'errors' => array(
-            __("You need to select a list.")
-          )
-      ));
-    }
-
-    $segments = Segment::whereIdIn($data['segments'])->findMany();
-    $subscribers = array();
-    foreach($segments as $segment) {
-      $segment_subscribers = $segment->subscribers()->findMany();
-      foreach($segment_subscribers as $segment_subscriber) {
-        $subscribers[$segment_subscriber->email] = $segment_subscriber
-          ->asArray();
-      }
-    }
-
-    if(empty($subscribers)) {
-      return wp_send_json(array(
-        'errors' => array(
-            __("No subscribers found.")
-          )
-      ));
-    }
-
-    // TODO: TO REMOVE once we add the columns from/reply_to
-    $newsletter = array_merge($newsletter, $data['newsletter']);
-    // END - TO REMOVE
-
-    $renderer = new Renderer(json_decode($newsletter['body'], true));
-    $newsletter['body'] = $renderer->render();
-
-    $subscribers = Subscriber::find_array();
-    $fromEmail = Setting::where('name', 'from_address')->findOne()->value;
-    $fromName = Setting::where('name', 'from_name')->findOne()->value;
-    $apiKey = Setting::where('name', 'api_key')->findOne()->value;
-    $mailer = new MailPoet($apiKey, $fromEmail, $fromName);
-
-    foreach ($subscribers as $subscriber) {
-      $result = $mailer->send(
-        $newsletter,
-        sprintf('%s %s <%s>', $subscriber['first_name'], $subscriber['last_name'], $subscriber['email'])
-      );
-      if ($result !== true) wp_send_json(false);
-    }
-
-    wp_send_json(true);
   }
 
   function render($data = array()) {
     if(!isset($data['body'])) {
-      wp_send_json(false);
+      return false;
     }
     $renderer = new Renderer($data);
     $rendered_newsletter = $renderer->render();
@@ -219,7 +143,7 @@ class Newsletters {
       $data
     );
     $rendered_newsletter = $shortcodes->replace();
-    wp_send_json(array('rendered_body' => $rendered_newsletter));
+    return array('rendered_body' => $rendered_newsletter);
   }
 
   function sendPreview($data = array()) {
@@ -227,15 +151,15 @@ class Newsletters {
     $newsletter = Newsletter::findOne($id);
 
     if($newsletter === false) {
-      wp_send_json(array(
+      return array(
         'result' => false
-      ));
+      );
     }
     if(empty($data['subscriber'])) {
-      wp_send_json(array(
+      return array(
         'result' => false,
-        'errors' => array(__('Please specify receiver information')),
+        'errors' => array(__('Please specify receiver information'))
-      ));
+      );
     }
 
     $newsletter = $newsletter->asArray();
@@ -263,7 +187,7 @@ class Newsletters {
         $sender = false,
         $reply_to = false
       );
-      $result = $mailer->send($newsletter, $data['subscriber'])
+      $result = $mailer->send($newsletter, $data['subscriber']);
 
       return array('result' => $result);
     } catch(\Exception $e) {
@@ -310,27 +234,30 @@ class Newsletters {
   }
 
   function create($data = array()) {
-    $newsletter = Newsletter::create();
+    $options = array();
-    $newsletter->type = $data['type'];
-    $newsletter->subject = $data['subject'];
-    $newsletter->body = '{}';
-
-    // try to load template data
-    $template_id = (!empty($data['template']) ? (int)$data['template'] : 0);
-    $template = NewsletterTemplate::findOne($template_id);
-    if($template !== false) {
-      $newsletter->body = $template->body;
-    }
-
     if(isset($data['options'])) {
       $options = $data['options'];
       unset($data['options']);
     }
 
+    $newsletter = Newsletter::createOrUpdate($data);
+
+    // try to load template data
+    $template_id = (!empty($data['template']) ? (int)$data['template'] : false);
+    $template = NewsletterTemplate::findOne($template_id);
+    if($template !== false) {
+      $newsletter->body = $template->body;
+    } else {
+      $newsletter->body = array();
+    }
+
     $newsletter->save();
     $errors = $newsletter->getErrors();
     if(!empty($errors)) {
-      return $errors;
+      return array(
+        'result' => false,
+        'errors' =>$errors
+      );
     } else {
       if(!empty($options)) {
         $option_fields = NewsletterOptionField::where(
@@ -347,8 +274,10 @@ class Newsletters {
           }
         }
       }
-      $newsletter->body = json_decode($newsletter->body);
+      return array(
-      return $newsletter->asArray();
+        'result' => true,
+        'newsletter' => $newsletter->asArray()
+      );
     }
   }
 }

lib/Router/Segments.php

@@ -65,10 +65,6 @@ class Segments {
     return $listing_data;
   }
 
-  function getAll() {
-    return Segment::findArray();
-  }
-
   function save($data = array()) {
     $errors = array();
     $result = false;

lib/Router/Subscribers.php

@@ -56,35 +56,30 @@ class Subscribers {
     return $listing_data;
   }
 
-  function getAll() {
-    return Subscriber::findArray();
-  }
-
   function save($data = array()) {
-    $errors = array();
-    $result = false;
     $segment_ids = array();
 
-    if(array_key_exists('segments', $data)) {
+    if(isset($data['segments'])) {
       $segment_ids = (array)$data['segments'];
       unset($data['segments']);
     }
 
     $subscriber = Subscriber::createOrUpdate($data);
+    $errors = $subscriber->getErrors();
 
-    if($subscriber !== false && !$subscriber->id()) {
+    if(!empty($errors)) {
-      $errors = $subscriber->getValidationErrors();
+      return array(
+        'result' => false,
+        'errors' => $errors
+      );
     } else {
-      $result = true;
-
       if(!empty($segment_ids)) {
         $subscriber->addToSegments($segment_ids);
       }
+      return array(
+        'result' => true
+      );
     }
-    return array(
-      'result' => $result,
-      'errors' => $errors
-    );
   }
 
   function subscribe($data = array()) {

tests/unit/Models/CustomFieldCest.php

@@ -43,7 +43,7 @@ class CustomFieldCest {
   }
 
   function itCanHaveParams() {
-    expect(unserialize($this->customField->params))->equals($this->data['params']);
+    expect($this->customField->params)->equals($this->data['params']);
   }
 
   function itHasToBeValid() {

tests/unit/Models/NewsletterCest.php

@@ -11,8 +11,8 @@ class NewsletterCest {
     $this->before_time = time();
     $this->data = array(
       'subject' => 'new newsletter',
-      'body' => 'body',
       'type' => 'standard',
+      'body' => 'body',
       'preheader' => 'preheader'
     );
 
@@ -78,10 +78,11 @@ class NewsletterCest {
     $is_created = Newsletter::createOrUpdate(
       array(
         'subject' => 'new newsletter',
+        'type' => 'standard',
         'body' => 'body'
       ));
-    expect($is_created)->notEquals(false);
+    expect($is_created->id() > 0)->true();
-    expect($is_created->getValidationErrors())->isEmpty();
+    expect($is_created->getErrors())->false();
 
     $newsletter = Newsletter::where('subject', 'new newsletter')
       ->findOne();
@@ -90,8 +91,7 @@ class NewsletterCest {
     $is_updated = Newsletter::createOrUpdate(
       array(
         'id' => $newsletter->id,
-        'subject' => 'updated newsletter',
+        'subject' => 'updated newsletter'
-        'body' => 'body'
       ));
     $newsletter = Newsletter::findOne($newsletter->id);
     expect($newsletter->subject)->equals('updated newsletter');
@@ -101,6 +101,7 @@ class NewsletterCest {
     Newsletter::createOrUpdate(
       array(
         'subject' => 'search for "pineapple"',
+        'type' => 'standard',
         'body' => 'body'
       ));
     $newsletter = Newsletter::filter('search', 'pineapple')

tests/unit/Models/NewsletterOptionFieldCest.php

@@ -9,19 +9,21 @@ class NewsletterOptionFieldCest {
     $this->before_time = time();
     $this->data = array(
       'name' => 'Event',
-      'newsletter_type' => 'welcome',
+      'newsletter_type' => 'welcome'
     );
-    $this->optionField = NewsletterOptionField::create();
+    $this->option_field = NewsletterOptionField::create();
-    $this->optionField->hydrate($this->data);
+    $this->option_field->hydrate($this->data);
-    $this->saved = $this->optionField->save();
+    $this->saved = $this->option_field->save();
-    $this->newslettersData = array(
+    $this->newsletter_data = array(
       array(
         'subject' => 'Test newsletter 1',
+        'type' => 'standard',
         'preheader' => '',
         'body' => '{}'
       ),
       array(
         'subject' => 'Test newsletter 2',
+        'type' => 'standard',
         'preheader' => 'A newsletter',
         'body' => '{}'
       )
@@ -34,15 +36,15 @@ class NewsletterOptionFieldCest {
   }
 
   function itHasName() {
-    $optionField = NewsletterOptionField::where('name', $this->data['name'])
+    $option_field = NewsletterOptionField::where('name', $this->data['name'])
       ->findOne();
-    expect($optionField->name)->equals($this->data['name']);
+    expect($option_field->name)->equals($this->data['name']);
   }
 
   function itHasNewsletterType() {
-    $optionField = NewsletterOptionField::where('name', $this->data['name'])
+    $option_field = NewsletterOptionField::where('name', $this->data['name'])
       ->findOne();
-    expect($optionField->newsletter_type)->equals($this->data['newsletter_type']);
+    expect($option_field->newsletter_type)->equals($this->data['newsletter_type']);
   }
 
   function itHasToBeValid() {
@@ -56,65 +58,65 @@ class NewsletterOptionFieldCest {
   }
 
   function itHasACreatedAtOnCreation() {
-    $optionField = NewsletterOptionField::where('name', $this->data['name'])
+    $option_field = NewsletterOptionField::where('name', $this->data['name'])
       ->findOne();
-    $time_difference = strtotime($optionField->created_at) >= $this->before_time;
+    $time_difference = strtotime($option_field->created_at) >= $this->before_time;
     expect($time_difference)->equals(true);
   }
 
   function itHasAnUpdatedAtOnCreation() {
-    $optionField = NewsletterOptionField::where('name', $this->data['name'])
+    $option_field = NewsletterOptionField::where('name', $this->data['name'])
       ->findOne();
-    $time_difference = strtotime($optionField->updated_at) >= $this->before_time;
+    $time_difference = strtotime($option_field->updated_at) >= $this->before_time;
     expect($time_difference)->equals(true);
   }
 
   function itKeepsTheCreatedAtOnUpdate() {
-    $optionField = NewsletterOptionField::where('name', $this->data['name'])
+    $option_field = NewsletterOptionField::where('name', $this->data['name'])
       ->findOne();
-    $old_created_at = $optionField->created_at;
+    $old_created_at = $option_field->created_at;
-    $optionField->name = 'new name';
+    $option_field->name = 'new name';
-    $optionField->save();
+    $option_field->save();
-    expect($old_created_at)->equals($optionField->created_at);
+    expect($old_created_at)->equals($option_field->created_at);
   }
 
   function itUpdatesTheUpdatedAtOnUpdate() {
-    $optionField = NewsletterOptionField::where('name', $this->data['name'])
+    $option_field = NewsletterOptionField::where('name', $this->data['name'])
       ->findOne();
     $update_time = time();
-    $optionField->name = 'new name';
+    $option_field->name = 'new name';
-    $optionField->save();
+    $option_field->save();
-    $time_difference = strtotime($optionField->updated_at) >= $update_time;
+    $time_difference = strtotime($option_field->updated_at) >= $update_time;
     expect($time_difference)->equals(true);
   }
 
   function itCanHaveManyNewsletters() {
-    foreach ($this->newslettersData as $data) {
+    foreach($this->newsletter_data as $data) {
       $newsletter = Newsletter::create();
       $newsletter->hydrate($data);
       $newsletter->save();
       $association = NewsletterOption::create();
       $association->newsletter_id = $newsletter->id;
-      $association->option_field_id = $this->optionField->id;
+      $association->option_field_id = $this->option_field->id;
       $association->save();
     }
-    $optionField = NewsletterOptionField::findOne($this->optionField->id);
+    $option_field = NewsletterOptionField::findOne($this->option_field->id);
-    $newsletters = $optionField->newsletters()
+    $newsletters = $option_field->newsletters()
       ->findArray();
     expect(count($newsletters))->equals(2);
   }
 
   function itCanStoreOptionValue() {
     $newsletter = Newsletter::create();
-    $newsletter->hydrate($this->newslettersData[0]);
+    $newsletter->hydrate($this->newsletter_data[0]);
     $newsletter->save();
     $association = NewsletterOption::create();
     $association->newsletter_id = $newsletter->id;
-    $association->option_field_id = $this->optionField->id;
+    $association->option_field_id = $this->option_field->id;
     $association->value = 'list';
     $association->save();
-    $optionField = NewsletterOptionField::findOne($this->optionField->id);
+    $option_field = NewsletterOptionField::findOne($this->option_field->id);
-    $newsletter = $optionField->newsletters()
+    $newsletter = $option_field->newsletters()
       ->findOne();
     expect($newsletter->value)->equals($association->value);
   }

tests/unit/Models/SegmentCest.php

@@ -13,7 +13,7 @@ class SegmentCest {
       'name' => 'some name',
       'description' => 'some description'
     );
-    $this->subscribersData = array(
+    $this->subscribers_data = array(
       array(
         'first_name' => 'John',
         'last_name' => 'Mailer',
@@ -27,22 +27,22 @@ class SegmentCest {
         'email' => 'mike@maipoet.com'
       )
     );
-    $this->newslettersData = array(
+    $this->newsletters_data = array(
       array(
-        'subject' => 'My first newsletter'
+        'subject' => 'My first newsletter',
+        'type' => 'standard'
       ),
       array(
-        'subject' => 'My second newsletter'
+        'subject' => 'My second newsletter',
+        'type' => 'standard'
       )
     );
-    $this->segment = Segment::create();
+    $this->segment = Segment::createOrUpdate($this->data);
-    $this->segment->hydrate($this->data);
-    $this->saved = $this->segment->save();
   }
 
   function itCanBeCreated() {
-    expect($this->saved->id() > 0)->true();
+    expect($this->segment->id() > 0)->true();
-    expect($this->saved->getErrors())->false();
+    expect($this->segment->getErrors())->false();
   }
 
   function itCanHaveName() {
@@ -108,10 +108,10 @@ class SegmentCest {
 
   function itCanCreateOrUpdate() {
     $is_created = Segment::createOrUpdate(array(
-                                            'name' => 'new list'
+      'name' => 'new list'
-                                          ));
+    ));
-    expect($is_created)->notEquals(false);
+    expect($is_created->id() > 0)->true();
-    expect($is_created->getValidationErrors())->isEmpty();
+    expect($is_created->getErrors())->false();
 
     $segment = Segment::where('name', 'new list')
       ->findOne();
@@ -128,9 +128,9 @@ class SegmentCest {
   }
 
   function itCanHaveManySubscribers() {
-    foreach ($this->subscribersData as $subscriberData) {
+    foreach($this->subscribers_data as $subscriber_data) {
       $subscriber = Subscriber::create();
-      $subscriber->hydrate($subscriberData);
+      $subscriber->hydrate($subscriber_data);
       $subscriber->save();
       $association = SubscriberSegment::create();
       $association->subscriber_id = $subscriber->id;
@@ -145,9 +145,9 @@ class SegmentCest {
   }
 
   function itCanHaveManyNewsletters() {
-    foreach ($this->newslettersData as $newsletterData) {
+    foreach($this->newsletters_data as $newsletter_data) {
       $newsletter = Newsletter::create();
-      $newsletter->hydrate($newsletterData);
+      $newsletter->hydrate($newsletter_data);
       $newsletter->save();
       $association = NewsletterSegment::create();
       $association->newsletter_id = $newsletter->id;
@@ -162,9 +162,9 @@ class SegmentCest {
   }
 
   function itCanGetSegmentsWithSubscriberCount() {
-    foreach ($this->subscribersData as $subscriberData) {
+    foreach($this->subscribers_data as $subscriber_data) {
       $subscriber = Subscriber::create();
-      $subscriber->hydrate($subscriberData);
+      $subscriber->hydrate($subscriber_data);
       $subscriber->save();
       $association = SubscriberSegment::create();
       $association->subscriber_id = $subscriber->id;
@@ -176,9 +176,9 @@ class SegmentCest {
   }
 
   function itCanGetSegmentsForExport() {
-    foreach ($this->subscribersData as $index => $subscriberData) {
+    foreach($this->subscribers_data as $index => $subscriber_data) {
       $subscriber = Subscriber::create();
-      $subscriber->hydrate($subscriberData);
+      $subscriber->hydrate($subscriber_data);
       $subscriber->save();
       if(!$index) {
         $association = SubscriberSegment::create();

tests/unit/Models/SubscriberCest.php

@@ -105,75 +105,62 @@ class SubscriberCest {
   }
 
   function itCanHaveSegment() {
-    $segmentData = array(
+    $segment = Segment::createOrUpdate(array(
       'name' => 'some name'
-    );
+    ));
-    $segment = Segment::create();
+    expect($segment->getErrors())->false();
-    $segment->hydrate($segmentData);
+
-    $segment->save();
     $association = SubscriberSegment::create();
     $association->subscriber_id = $this->subscriber->id;
     $association->segment_id = $segment->id;
     $association->save();
+
     $subscriber = Subscriber::findOne($this->subscriber->id);
-    $subscriberSegment = $subscriber->segments()
+
-      ->findOne();
+    $subscriber_segment = $subscriber->segments()->findOne();
-    expect($subscriberSegment->id)->equals($segment->id);
+    expect($subscriber_segment->id)->equals($segment->id);
   }
 
   function itCanHaveCustomFields() {
-    $customFieldData = array(
+    $custom_field = CustomField::createOrUpdate(array(
       'name' => 'DOB',
       'type' => 'date',
-    );
+    ));
-    $customField = CustomField::create();
+
-    $customField->hydrate($customFieldData);
-    $customField->save();
     $association = SubscriberCustomField::create();
     $association->subscriber_id = $this->subscriber->id;
-    $association->custom_field_id = $customField->id;
+    $association->custom_field_id = $custom_field->id;
     $association->value = '12/12/2012';
     $association->save();
+
     $subscriber = Subscriber::filter('filterWithCustomFields')
       ->findOne($this->subscriber->id);
     expect($subscriber->DOB)->equals($association->value);
   }
 
   function itCanFilterCustomFields() {
-    $customFieldData = array(
+    $cf_city = CustomField::createOrUpdate(array(
-      array(
+      'name' => 'City',
-        'name' => 'City',
+      'type' => 'text'
-        'type' => 'text',
+    ));
-      ),
+
-      array(
+    SubscriberCustomField::createOrUpdate(array(
-        'name' => 'Country',
+      'subscriber_id' => $this->subscriber->id,
-        'type' => 'text',
+      'custom_field_id' => $cf_city->id,
-      )
+      'value' => 'Paris'
-    );
+    ));
-    foreach($customFieldData as $data) {
+
-      $customField = CustomField::create();
+    $cf_country = CustomField::createOrUpdate(array(
-      $customField->hydrate($data);
+      'name' => 'Country',
-      $customField->save();
+      'type' => 'text'
-      $createdCustomFields[] = $customField->asArray();
+    ));
-    }
+
-    $subscriberCustomFieldData = array(
+    SubscriberCustomField::createOrUpdate(array(
-      array(
+      'subscriber_id' => $this->subscriber->id,
-        'subscriber_id' => $this->subscriber->id,
+      'custom_field_id' => $cf_country->id,
-        'custom_field_id' => $createdCustomFields[0]['id'],
+      'value' => 'France'
-        'value' => 'Paris'
+    ));
-      ),
+
-      array(
-        'subscriber_id' => $this->subscriber->id,
-        'custom_field_id' => $createdCustomFields[1]['id'],
-        'value' => 'France'
-      )
-    );
-    foreach($subscriberCustomFieldData as $data) {
-      $association = SubscriberCustomField::create();
-      $association->hydrate($data);
-      $association->save();
-      $createdAssociations[] = $association->asArray();
-    }
     $subscriber = Subscriber::filter('filterWithCustomFields')
       ->filter('filterSearchCustomFields', array(
         array(
@@ -196,6 +183,7 @@ class SubscriberCest {
       ))
       ->findArray();
     expect(empty($subscriber))->false();
+
     $subscriber = Subscriber::filter('filterWithCustomFields')
       ->filter('filterSearchCustomFields', array(
         array(
@@ -209,6 +197,7 @@ class SubscriberCest {
       ), 'OR')
       ->findArray();
     expect(empty($subscriber))->false();
+
     $subscriber = Subscriber::filter('filterWithCustomFields')
       ->filter('filterSearchCustomFields', array(
         array(
@@ -218,6 +207,7 @@ class SubscriberCest {
       ), 'AND', 'LIKE')
       ->findArray();
     expect(empty($subscriber))->false();
+
     $subscriber = Subscriber::filter('filterWithCustomFields')
       ->filter('filterSearchCustomFields', array(
         array(
@@ -227,6 +217,7 @@ class SubscriberCest {
       ))
       ->findArray();
     expect(empty($subscriber))->true();
+
     $subscriber = Subscriber::filter('filterWithCustomFields')
       ->filter('filterSearchCustomFields', array(
         array(
@@ -240,6 +231,7 @@ class SubscriberCest {
       ))
       ->findArray();
     expect(empty($subscriber))->true();
+
     $subscriber = Subscriber::filter('filterWithCustomFields')
       ->filter('filterSearchCustomFields', array(
         array(
@@ -253,6 +245,7 @@ class SubscriberCest {
       ), 'OR')
       ->findArray();
     expect(empty($subscriber))->true();
+
     $subscriber = Subscriber::filter('filterWithCustomFields')
       ->filter('filterSearchCustomFields', array(
         array(
@@ -271,8 +264,8 @@ class SubscriberCest {
       'last_name' => 'Doe'
     );
     $result = Subscriber::createOrUpdate($data);
-    expect($result)->notEquals(false);
+    expect($result->id() > 0)->true();
-    expect($result->getValidationErrors())->isEmpty();
+    expect($result->getErrors())->false();
 
     $record = Subscriber::where('email', $data['email'])
       ->findOne();

tests/unit/Router/FormsCest.php

@@ -40,16 +40,6 @@ class FormsCest {
     expect($response['items'][2]['name'])->equals('Form 3');
   }
 
-  function itCanGetAllForms() {
-    $forms = Form::findArray();
-
-    $router = new Forms();
-    $response = $router->getAll();
-
-    expect($response)->count(3);
-    expect($response)->equals($forms);
-  }
-
   function itCanCreateANewForm() {
     $router = new Forms();
     $response = $router->create();

tests/unit/Router/NewsletterTemplatesCest.php

@@ -56,8 +56,7 @@ class NewsletterTemplatesCest {
 
     $router = new NewsletterTemplates();
     $response = $router->save($template_data);
-
+    expect($response)->true();
-    expect($response->id() > 0)->true();
 
     $template = NewsletterTemplate::where('name', 'Template #3')->findOne();
     expect($template->name)->equals('Template #3');

tests/unit/Router/NewslettersCest.php

@@ -0,0 +1,208 @@
+<?php
+use \MailPoet\Router\Newsletters;
+use \MailPoet\Models\Newsletter;
+use \MailPoet\Models\NewsletterSegment;
+use \MailPoet\Models\NewsletterTemplate;
+use \MailPoet\Models\Segment;
+
+class NewslettersCest {
+  function _before() {
+  }
+
+  function itCanGetANewsletter() {
+    $newsletter = Newsletter::createOrUpdate(array(
+      'subject' => 'My First Newsletter',
+      'type' => 'standard'
+    ));
+    expect($newsletter->id() > 0)->true();
+
+    $router = new Newsletters();
+
+    $response = $router->get($newsletter->id());
+
+    expect($response['id'])->equals($newsletter->id());
+
+    $response = $router->get('not_an_id');
+    expect($response)->false();
+
+    $response = $router->get(/* missing argument */);
+    expect($response)->false();
+  }
+
+  function itCanSaveANewNewsletter() {
+    $valid_data = array(
+      'subject' => 'My First Newsletter',
+      'type' => 'standard'
+    );
+
+    $router = new Newsletters();
+    $response = $router->save($valid_data);
+    expect($response['result'])->true();
+    expect($response)->hasntKey('errors');
+
+    $invalid_data = array(
+      'subject' => 'Missing newsletter type'
+    );
+
+    $response = $router->save($invalid_data);
+    expect($response['result'])->false();
+    expect($response['errors'][0])->equals('You need to specify a type.');
+  }
+
+  function itCanSaveAnExistingNewsletter() {
+    $newsletter = Newsletter::createOrUpdate(array(
+      'subject' => 'My First Newsletter',
+      'type' => 'standard'
+    ));
+    expect($newsletter->id() > 0)->true();
+
+    $router = new Newsletters();
+    $newsletter_data = $newsletter->asArray();
+    $newsletter_data['subject'] = 'My Updated Newsletter';
+
+    $response = $router->save($newsletter_data);
+    expect($response['result'])->true();
+
+    $updated_newsletter = Newsletter::findOne($newsletter->id());
+    expect($updated_newsletter->subject)->equals('My Updated Newsletter');
+  }
+
+  function itCanRestoreANewsletter() {
+    $newsletter = Newsletter::createOrUpdate(array(
+      'subject' => 'My First Newsletter',
+      'type' => 'standard'
+    ));
+    expect($newsletter->id() > 0)->true();
+
+    $newsletter->trash();
+
+    expect($newsletter->deleted_at)->notNull();
+
+    $router = new Newsletters();
+    $router->restore($newsletter->id());
+
+    $restored_subscriber = Newsletter::findOne($newsletter->id());
+    expect($restored_subscriber->deleted_at)->null();
+  }
+
+  function itCanTrashANewsletter() {
+    $newsletter = Newsletter::createOrUpdate(array(
+      'subject' => 'My First Newsletter',
+      'type' => 'standard'
+    ));
+    expect($newsletter->id() > 0)->true();
+
+    $router = new Newsletters();
+    $response = $router->trash($newsletter->id());
+    expect($response)->true();
+
+    $trashed_subscriber = Newsletter::findOne($newsletter->id());
+    expect($trashed_subscriber->deleted_at)->notNull();
+  }
+
+  function itCanDeleteANewsletter() {
+    $newsletter = Newsletter::createOrUpdate(array(
+      'subject' => 'My First Newsletter',
+      'type' => 'standard'
+    ));
+    expect($newsletter->id() > 0)->true();
+
+    $router = new Newsletters();
+    $response = $router->delete($newsletter->id());
+    expect($response)->equals(1);
+
+    expect(Newsletter::findOne($newsletter->id()))->false();
+  }
+
+  function itCanDuplicateANewsletter() {
+    $newsletter = Newsletter::createOrUpdate(array(
+      'subject' => 'My First Newsletter',
+      'type' => 'standard'
+    ));
+    expect($newsletter->id() > 0)->true();
+
+    $router = new Newsletters();
+    $response = $router->duplicate($newsletter->id());
+    expect($response['subject'])->equals('Copy of My First Newsletter');
+    expect($response['type'])->equals('standard');
+    expect($response['body'])->equals($newsletter->body);
+  }
+
+  function itCanCreateANewsletter() {
+    $data = array(
+      'subject' => 'My New 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']['body'])->equals(array());
+    expect($response)->hasntKey('errors');
+
+    $response = $router->create();
+    expect($response['result'])->false();
+    expect($response['errors'][0])->equals('You need to specify a type.');
+  }
+
+  function itCanGetListingData() {
+    $segment_1 = Segment::createOrUpdate(array('name' => 'Segment 1'));
+    $segment_2 = Segment::createOrUpdate(array('name' => 'Segment 2'));
+
+    $newsletter_1 = Newsletter::createOrUpdate(array(
+      'subject' => 'My First Newsletter',
+      'type' => 'standard'
+    ));
+    $newsletter_2 = Newsletter::createOrUpdate(array(
+      'subject' => 'My Second Newsletter',
+      'type' => 'standard'
+    ));
+
+    $newsletter_segment = NewsletterSegment::create();
+    $newsletter_segment->hydrate(array(
+      'newsletter_id' => $newsletter_1->id(),
+      'segment_id' => $segment_1->id()
+    ));
+    $newsletter_segment->save();
+
+    $newsletter_segment = NewsletterSegment::create();
+    $newsletter_segment->hydrate(array(
+      'newsletter_id' => $newsletter_1->id(),
+      'segment_id' => $segment_2->id()
+    ));
+    $newsletter_segment->save();
+
+    $newsletter_segment = NewsletterSegment::create();
+    $newsletter_segment->hydrate(array(
+      'newsletter_id' => $newsletter_2->id(),
+      'segment_id' => $segment_2->id()
+    ));
+    $newsletter_segment->save();
+
+    $router = new Newsletters();
+    $response = $router->listing(array('sort'));
+
+    expect($response)->hasKey('filters');
+    expect($response)->hasKey('groups');
+
+    expect($response['count'])->equals(2);
+    expect($response['items'])->count(2);
+
+    expect($response['items'][0]['subject'])->equals('My First Newsletter');
+    expect($response['items'][1]['subject'])->equals('My Second Newsletter');
+    expect($response['items'][0]['segments'])->equals(array(
+      $segment_1->id(),
+      $segment_2->id()
+    ));
+    expect($response['items'][1]['segments'])->equals(array(
+      $segment_2->id()
+    ));
+  }
+
+  function _after() {
+    Newsletter::deleteMany();
+    Segment::deleteMany();
+  }
+}

tests/unit/Router/SegmentsCest.php

@@ -38,15 +38,6 @@ class SegmentsCest {
     expect($response['items'][2]['name'])->equals('Segment 3');
   }
 
-  function itCanGetAllSegments() {
-    $router = new Segments();
-    $segments = Segment::findArray();
-
-    $response = $router->getAll();
-    expect($response)->count(3);
-    expect($response)->equals($segments);
-  }
-
   function itCanSaveASegment() {
     $segment_data = array(
       'name' => 'New Segment'

tests/unit/Router/SubscribersCest.php

@@ -6,7 +6,6 @@ use \MailPoet\Models\Segment;
 
 class SubscribersCest {
   function _before() {
-
   }
 
   function itCanGetASubscriber() {
@@ -27,21 +26,6 @@ class SubscribersCest {
     expect($response)->false();
   }
 
-  function itCanGetAllSubscribers(UnitTester $I) {
-    $I->generateSubscribers(10);
-
-    $router = new Subscribers();
-    $result = $router->getAll();
-
-    expect($result)->count(10);
-
-    $model = Subscriber::create();
-    foreach($result as $subscriber) {
-      expect($subscriber['id'] > 0)->true();
-      expect($subscriber['email'])->notEmpty();
-    }
-  }
-
   function itCanSaveANewSubscriber() {
     $valid_data = array(
       'email' => 'john.doe@mailpoet.com',
@@ -50,9 +34,13 @@ class SubscribersCest {
     );
 
     $router = new Subscribers();
-
     $response = $router->save($valid_data);
     expect($response['result'])->true();
+    expect($response)->hasntKey('errors');
+
+    $response = $router->save(/* missing data */);
+    expect($response['result'])->false();
+    expect($response['errors'][0])->equals('You need to enter your email address.');
 
     $invalid_data = array(
       'email' => 'john.doe@invalid',

tests/unit/Subscribers/ImportExport/BootStrapMenuCest.php

@@ -8,67 +8,76 @@ use MailPoet\Subscribers\ImportExport\BootStrapMenu;
 
 class BootStrapMenuCest {
   function _before() {
-    $this->segmentsData = array(
+        $segment_1 = Segment::createOrUpdate(array('name' => 'Unconfirmed Segment'));
-      array(
+    $segment_2 = Segment::createOrUpdate(array('name' => 'Confirmed Segment'));
-        'name' => 'first',
+
-        'description' => 'some description'
+    $subscriber_1 = Subscriber::createOrUpdate(array(
-      ),
+      'first_name' => 'John',
-      array(
+      'last_name' => 'Mailer',
-        'name' => 'second',
+      'status' => 'unconfirmed',
-        'description' => 'some description'
+      'email' => 'john@mailpoet.com'
-      )
+    ));
-    );
+
-    $this->subscribersData = array(
+    $subscriber_2 = Subscriber::createOrUpdate(array(
-      array(
+      'first_name' => 'Mike',
-        'first_name' => 'John',
+      'last_name' => 'Smith',
-        'last_name' => 'Mailer',
+      'status' => 'subscribed',
-        'status' => 'unconfirmed',
+      'email' => 'mike@maipoet.com'
-        'email' => 'john@mailpoet.com'
+    ));
-      ),
+
-      array(
+    $association = SubscriberSegment::create();
-        'first_name' => 'Mike',
+    $association->subscriber_id = $subscriber_1->id;
-        'last_name' => 'Smith',
+    $association->segment_id = $segment_1->id;
-        'status' => 'subscribed',
+    $association->save();
-        'email' => 'mike@maipoet.com'
+
-      )
+    $association = SubscriberSegment::create();
-    );
+    $association->subscriber_id = $subscriber_2->id;
-    $this->customFieldsData = array(
+    $association->segment_id = $segment_2->id;
-      'name' => 'DOB',
+    $association->save();
-      'type' => 'date',
+
-    );
+    CustomField::createOrUpdate(array(
-    $customField = CustomField::create();
+      'name' => 'Birthday',
-    $customField->hydrate($this->customFieldsData);
+      'type' => 'date'
-    $customField->save();
+    ));
+
     $this->bootStrapImportMenu = new BootStrapMenu('import');
     $this->bootStrapExportMenu = new BootStrapMenu('export');
   }
 
   function itCanGetSegmentsWithSubscriberCount() {
-    // TOFIX.
-    /*$this->_createSegmentsAndSubscribers();
     $segments = $this->bootStrapImportMenu->getSegments();
     expect(count($segments))->equals(2);
-    expect($segments[0]['name'])->equals($this->segmentsData[0]['name']);
+    expect($segments[0]['name'])->equals('Unconfirmed Segment');
     expect($segments[0]['subscriberCount'])->equals(1);
-    expect($segments[1]['subscriberCount'])->equals(1);*/
+    expect($segments[1]['name'])->equals('Confirmed Segment');
+    expect($segments[1]['subscriberCount'])->equals(1);
   }
 
-  function itCanGetSegmentsForImportWithoutTrashedSubscribers() {
+  function itCanGetPublicSegmentsForImport() {
-    $this->_createSegmentsAndSubscribers();
+
     $segments = $this->bootStrapImportMenu->getSegments();
     expect(count($segments))->equals(2);
-    $subscriber = Subscriber::findOne(1);
+
-    $subscriber->deleted_at = date('Y-m-d H:i:s');
+    $subscriber = Subscriber::where(
-    $subscriber->save();
+      'email', 'john@mailpoet.com'
+    )->findOne();
+    expect($subscriber->deleted_at)->null();
+    $subscriber->trash();
+
+    $subscriber = Subscriber::where(
+      'email', 'john@mailpoet.com'
+    )->whereNull('deleted_at')->findOne();
+    expect($subscriber)->false();
+
     $segments = $this->bootStrapImportMenu->getSegments();
     expect(count($segments))->equals(1);
   }
 
-  function itCanGetSegmentsForExportWithoutTrashedSubscribers() {
+  function itCanGetPublicSegmentsForExport() {
-    $this->_createSegmentsAndSubscribers();
     $segments = $this->bootStrapExportMenu->getSegments();
     expect(count($segments))->equals(2);
-    $subscriber = Subscriber::findOne(1);
+    $subscriber = Subscriber::where('email', 'john@mailpoet.com')
+      ->findOne();
     $subscriber->deleted_at = date('Y-m-d H:i:s');
     $subscriber->save();
     $segments = $this->bootStrapExportMenu->getSegments();
@@ -76,21 +85,21 @@ class BootStrapMenuCest {
   }
 
   function itCanGetSegmentsForExport() {
-    $this->_createSegmentsAndSubscribers();
     $segments = $this->bootStrapExportMenu->getSegments();
     expect(count($segments))->equals(2);
-    expect($segments[0]['name'])->equals($this->segmentsData[0]['name']);
+
+    expect($segments[0]['name'])->equals('Confirmed Segment');
     expect($segments[0]['subscriberCount'])->equals(1);
+    expect($segments[1]['name'])->equals('Unconfirmed Segment');
     expect($segments[1]['subscriberCount'])->equals(1);
   }
 
   function itCanGetSegmentsWithConfirmedSubscribersForExport() {
-    $this->_createSegmentsAndSubscribers();
     $segments = $this->bootStrapExportMenu->getSegments(
       $withConfirmedSubscribers = true
     );
     expect(count($segments))->equals(1);
-    expect($segments[0]['name'])->equals($this->segmentsData[1]['name']);
+    expect($segments[0]['name'])->equals('Confirmed Segment');
   }
 
   function itCanGetSubscriberFields() {
@@ -101,7 +110,7 @@ class BootStrapMenuCest {
       'last_name',
       'status'
     );
-    foreach ($fields as $field) {
+    foreach($fields as $field) {
       expect(in_array($field, array_keys($subsriberFields)))->true();
     }
   }
@@ -117,7 +126,7 @@ class BootStrapMenuCest {
       'type',
       'custom'
     );
-    foreach ($fields as $field) {
+    foreach($fields as $field) {
       expect(in_array($field, array_keys($formattedSubscriberFields[0])))
         ->true();
     }
@@ -129,7 +138,7 @@ class BootStrapMenuCest {
       $this->bootStrapImportMenu
         ->getSubscriberCustomFields();
     expect($subscriberCustomFields[0]['type'])
-      ->equals($this->customFieldsData['type']);
+      ->equals('date');
   }
 
   function itCanFormatSubsciberCustomFields() {
@@ -143,7 +152,7 @@ class BootStrapMenuCest {
       'type',
       'custom'
     );
-    foreach ($fields as $field) {
+    foreach($fields as $field) {
       expect(in_array($field, array_keys($formattedSubscriberCustomFields[0])))
         ->true();
     }
@@ -241,10 +250,6 @@ class BootStrapMenuCest {
   }
 
   function itCanBootStrapImport() {
-    $customField = CustomField::create();
-    $customField->hydrate($this->customFieldsData);
-    $customField->save();
-    $this->_createSegmentsAndSubscribers();
     $import = clone($this->bootStrapImportMenu);
     $importMenu = $import->bootstrap();
     expect(count(json_decode($importMenu['segments'], true)))
@@ -257,15 +262,11 @@ class BootStrapMenuCest {
       ->equals(3);
     expect($importMenu['maxPostSize'])->equals(ini_get('post_max_size'));
     expect($importMenu['maxPostSizeBytes'])->equals(
-      (int) ini_get('post_max_size') * 1048576
+      (int)ini_get('post_max_size') * 1048576
     );
   }
 
   function itCanBootStrapExport() {
-    $customField = CustomField::create();
-    $customField->hydrate($this->customFieldsData);
-    $customField->save();
-    $this->_createSegmentsAndSubscribers();
     $export = clone($this->bootStrapImportMenu);
     $exportMenu = $export->bootstrap();
     expect(count(json_decode($exportMenu['segments'], true)))
@@ -275,27 +276,10 @@ class BootStrapMenuCest {
       ->equals(3);
   }
 
-  function _createSegmentsAndSubscribers() {
-    foreach ($this->segmentsData as $segmentData) {
-      $segment = Segment::create();
-      $segment->hydrate($segmentData);
-      $segment->save();
-    }
-    foreach ($this->subscribersData as $subscriberData) {
-      $subscriber = Subscriber::create();
-      $subscriber->hydrate($subscriberData);
-      $subscriber->save();
-      $association = SubscriberSegment::create();
-      $association->subscriber_id = $subscriber->id;
-      $association->segment_id = $subscriber->id;
-      $association->save();
-    };
-  }
-
   function _after() {
-    ORM::raw_execute('TRUNCATE ' . Subscriber::$_table);
+    Subscriber::deleteMany();
-    ORM::raw_execute('TRUNCATE ' . Segment::$_table);
+    Segment::deleteMany();
-    ORM::raw_execute('TRUNCATE ' . SubscriberSegment::$_table);
+    SubscriberSegment::deleteMany();
-    ORM::raw_execute('TRUNCATE ' . CustomField::$_table);
+    CustomField::deleteMany();
   }
 }

tests/unit/Subscribers/ImportExport/Export/ExportCest.php

@@ -146,7 +146,7 @@ class ExportCest {
     expect($target)->equals(array($source->id => $source->name));
   }
 
-  function itCanFormatsubscriber_fields() {
+  function itCanFormatSubscriberFields() {
     $formatted_subscriber_fields = $this->export->formatSubscriberFields(
       array_keys($this->subscriber_fields),
       $this->export->getSubscriberCustomFields()