Cavemanon/piratepoet
8
Fork 0
Code Pull Requests Actions Releases 16 Activity

Sending queue router update

Browse Source 
- cleaned up useless code
- bugfixes
- improved code coverage
This commit is contained in:
Jonathan Labreuille
2016-02-11 09:37:53 +01:00
committed by Vlad
parent cfb4265971
commit 409697ee64
19 changed files with 325 additions and 532 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
RoboFile.php
View File

@@ -108,11 +108,12 @@ class RoboFile extends \Robo\Tasks {
$this->_exec('vendor/bin/codecept run unit -f '.(($file) ? $file : ''));
}
function testCoverage() {
function testCoverage($file = null) {
$this->loadEnv();
$this->_exec('vendor/bin/codecept build');
$this->_exec(join(' ', array(
'vendor/bin/codecept run',
(($file) ? $file : ''),
'--coverage',
'--coverage-html'
)));

4
lib/Config/Initializer.php
View File

@@ -66,8 +66,6 @@ class Initializer {
$newsletters = Env::$db_prefix . 'newsletters';
$newsletter_templates = Env::$db_prefix . 'newsletter_templates';
$segments = Env::$db_prefix . 'segments';
$filters = Env::$db_prefix . 'filters';
$segment_filter = Env::$db_prefix . 'segment_filter';
$forms = Env::$db_prefix . 'forms';
$subscriber_segment = Env::$db_prefix . 'subscriber_segment';
$newsletter_segment = Env::$db_prefix . 'newsletter_segment';
@@ -82,8 +80,6 @@ class Initializer {
define('MP_SETTINGS_TABLE', $settings);
define('MP_NEWSLETTERS_TABLE', $newsletters);
define('MP_SEGMENTS_TABLE', $segments);
define('MP_FILTERS_TABLE', $filters);
define('MP_SEGMENT_FILTER_TABLE', $segment_filter);
define('MP_FORMS_TABLE', $forms);
define('MP_SUBSCRIBER_SEGMENT_TABLE', $subscriber_segment);
define('MP_NEWSLETTER_TEMPLATES_TABLE', $newsletter_templates);

6
lib/Models/CustomField.php
View File

@@ -20,11 +20,9 @@ class CustomField extends Model {
$model = parent::asArray();
if(isset($model['params'])) {
$model['params'] = (
is_array($this->params)
$model['params'] = (is_array($this->params))
? $this->params
: unserialize($this->params)
);
: unserialize($this->params);
}
return $model;
}

16
lib/Models/CustomValidator.php
View File

@@ -1,16 +0,0 @@
<?php namespace MailPoet\Models;
class CustomValidator {
function __construct() {
$this->validator = new \Sudzy\Engine();
}
function init() {
$this->validator
->addValidator('isString', function ($val) {
return is_string($val);
});
return $this->validator;
}
}

50
lib/Models/Filter.php
View File

@@ -1,50 +0,0 @@
<?php
namespace MailPoet\Models;
if(!defined('ABSPATH')) exit;
class Filter extends Model {
static $_table = MP_FILTERS_TABLE;
function __construct() {
parent::__construct();
$this->addValidations('name', array(
'required' => __('You need to specify a name.')
));
}
function delete() {
// delete all relations to subscribers
SegmentFilter::where('filter_id', $this->id)->deleteMany();
return parent::delete();
}
function segments() {
return $this->has_many_through(
__NAMESPACE__.'\Segment',
__NAMESPACE__.'\SegmentFilter',
'filter_id',
'segment_id'
);
}
static function createOrUpdate($data = array()) {
$filter = false;
if(isset($data['id']) && (int)$data['id'] > 0) {
$filter = self::findOne((int)$data['id']);
}
if($filter === false) {
$filter = self::create();
$filter->hydrate($data);
} else {
unset($data['id']);
$filter->set($data);
}
$filter->save();
return $filter;
}
}

30
lib/Models/Form.php
View File

@@ -17,36 +17,30 @@ class Form extends Model {
function asArray() {
$model = parent::asArray();
$model['body'] = (
is_serialized($this->body)
$model['body'] = (is_serialized($this->body))
? unserialize($this->body)
: $this->body
);
$model['settings'] = (
is_serialized($this->settings)
: $this->body;
$model['settings'] = (is_serialized($this->settings))
? unserialize($this->settings)
: $this->settings
);
: $this->settings;
return $model;
}
function save() {
$this->set('body', (
is_serialized($this->body)
$this->set('body', (is_serialized($this->body))
? $this->body
: serialize($this->body)
));
$this->set('settings', (
is_serialized($this->settings)
);
$this->set('settings', (is_serialized($this->settings))
? $this->settings
: serialize($this->settings)
));
);
return parent::save();
}
static function search($orm, $search = '') {
return $orm->where_like('name', '%'.$search.'%');
return $orm->whereLike('name', '%'.$search.'%');
}
static function groups() {
@@ -67,9 +61,8 @@ class Form extends Model {
static function groupBy($orm, $group = null) {
if($group === 'trash') {
return $orm->whereNotNull('deleted_at');
} else {
$orm = $orm->whereNull('deleted_at');
}
return $orm->whereNull('deleted_at');
}
static function createOrUpdate($data = array()) {
@@ -87,7 +80,6 @@ class Form extends Model {
$form->set($data);
}
$form->save();
return $form;
return $form->save();
}
}

3
lib/Models/Model.php
View File

@@ -8,8 +8,7 @@ class Model extends \Sudzy\ValidModel {
function __construct() {
$this->_errors = array();
$customValidators = new CustomValidator();
parent::__construct($customValidators->init());
parent::__construct();
}
static function create() {

15
lib/Models/Newsletter.php
View File

@@ -97,14 +97,13 @@ class Newsletter extends Model {
}
static function filterBy($orm, $filters = null) {
if(empty($filters)) {
return $orm;
}
foreach($filters as $key => $value) {
if($key === 'segment') {
$segment = Segment::findOne($value);
if($segment !== false) {
$orm = $segment->newsletters();
if(!empty($filters)) {
foreach($filters as $key => $value) {
if($key === 'segment') {
$segment = Segment::findOne($value);
if($segment !== false) {
$orm = $segment->newsletters();
}
}
}
}

12
lib/Models/SegmentFilter.php
View File

@@ -1,12 +0,0 @@
<?php
namespace MailPoet\Models;
if(!defined('ABSPATH')) exit;
class SegmentFilter extends Model {
public static $_table = MP_SEGMENT_FILTER_TABLE;
function __construct() {
parent::__construct();
}
}

9
lib/Models/SendingQueue.php
View File

@@ -15,7 +15,8 @@ class SendingQueue extends Model {
return false;
} else {
$this->set('status', 'paused');
return $this->save();
$this->save();
return ($this->getErrors() === false && $this->id() > 0);
}
}
@@ -24,12 +25,14 @@ class SendingQueue extends Model {
return $this->complete();
} else {
$this->set_expr('status', 'NULL');
return $this->save();
$this->save();
return ($this->getErrors() === false && $this->id() > 0);
}
}
function complete() {
$this->set('status', 'completed');
return $this->save();
$this->save();
return ($this->getErrors() === false && $this->id() > 0);
}
}

30
lib/Models/Setting.php
View File

@@ -35,6 +35,9 @@ class Setting extends Model {
if($setting !== $default) {
for($i = 0, $count = count($keys); $i < $count; $i++) {
if(!is_array($setting)) {
$setting = array();
}
if(array_key_exists($keys[$i], $setting)) {
$setting = $setting[$keys[$i]];
} else {
@@ -67,13 +70,6 @@ class Setting extends Model {
$last_key = array_pop($keys);
foreach($keys as $key) {
if(!is_array($current_value)) {
$current_value = array();
}
if(!array_key_exists($key, $current_value)) {
$current_value = array($key => array());
}
$current_value =& $current_value[$key];
}
if(is_scalar($current_value)) {
@@ -100,16 +96,20 @@ class Setting extends Model {
return $settings;
}
public static function createOrUpdate($model) {
$exists = self::where('name', $model['name'])->findOne();
public static function createOrUpdate($data = array()) {
$setting = false;
if($exists === false) {
$new_model = self::create();
$new_model->hydrate($model);
return $new_model->save();
if(isset($data['name'])) {
$setting = self::where('name', $data['name'])->findOne();
}
$exists->value = $model['value'];
return $exists->save();
if($setting === false) {
$setting = self::create();
$setting->hydrate($data);
} else {
$setting->value = $data['value'];
}
return $setting->save();
}
}

197
lib/Router/SendingQueue.php
View File

@@ -13,25 +13,21 @@ class SendingQueue {
try {
new Mailer(false);
} catch(\Exception $e) {
wp_send_json(
array(
'result' => false,
'errors' => array($e->getMessage())
)
return array(
'result' => false,
'errors' => array($e->getMessage())
);
}
$queue = \MailPoet\Models\SendingQueue::where('newsletter_id', $data['newsletter_id'])
->whereNull('status')
$queue = \MailPoet\Models\SendingQueue::whereNull('status')
->where('newsletter_id', $data['newsletter_id'])
->findArray();
if(count($queue)) {
wp_send_json(
array(
'result' => false,
'errors' => array(__('Send operation is already in progress.'))
)
if(!empty($queue)) {
return array(
'result' => false,
'errors' => array(__('Send operation is already in progress.'))
);
exit;
}
$queue = \MailPoet\Models\SendingQueue::create();
$queue->newsletter_id = $data['newsletter_id'];
@@ -40,50 +36,39 @@ class SendingQueue {
->findMany();
foreach($segments as $segment) {
$subscriber_ids = array_merge($subscriber_ids, Helpers::arrayColumn(
$segment->subscribers()
->findArray(),
'id'
));
$subscriber_ids = array_merge(
$subscriber_ids,
Helpers::arrayColumn(
$segment->subscribers()->findArray(), 'id'
)
);
}
if(empty($subscriber_ids)) {
wp_send_json(
array(
'result' => false,
'errors' => array(__('There are no subscribers.'))
)
return array(
'result' => false,
'errors' => array(__('There are no subscribers.'))
);
exit;
}
$subscriber_ids = array_unique($subscriber_ids);
$queue->subscribers = serialize(
$queue->subscribers = json_encode(
array(
'to_process' => $subscriber_ids
)
);
$queue->count_total = $queue->count_to_process = count($subscriber_ids);
$result = $queue->save();
if($result === false) {
$errors = array(__('Queue could not be created.'));
if(!empty($queue->getValidationErrors())) {
$errors = array_merge($errors, $queue->getValidationErrors());
}
wp_send_json(
array(
'result' => false,
'errors' => $errors
)
$queue->save();
$errors = $queue->getErrors();
if(!empty($errors)) {
return array(
'result' => false,
'errors' => $errors
);
} else {
wp_send_json(
array(
'result' => true,
'data' => array($queue->id)
)
return array(
'result' => true,
'data' => array($queue->id)
);
}
}
@@ -94,14 +79,15 @@ class SendingQueue {
if($newsletter !== false) {
$queue = $newsletter->getQueue();
if($queue !== false && $queue->id() > 0) {
if($queue !== false) {
$result = $queue->pause();
}
}
wp_send_json(array(
return array(
'result' => $result
));
);
}
function resume($newsletter_id) {
@@ -110,125 +96,14 @@ class SendingQueue {
if($newsletter !== false) {
$queue = $newsletter->getQueue();
if($queue !== false && $queue->id() > 0) {
if($queue !== false) {
$result = $queue->resume();
}
}
wp_send_json(array(
return array(
'result' => $result
));
}
function addQueues($data) {
$newsletterIds = Helpers::arrayColumn($data, 'newsletter_id');
$queues = \MailPoet\Models\SendingQueue::whereIn('newsletter_id', $newsletterIds)
->whereNull('status')
->findArray();
if(count($queues)) {
wp_send_json(
array(
'result' => false,
'errors' => array(__('Send operation is already in progress.'))
)
);
}
$result = array_map(function ($queueData) {
$queue = \MailPoet\Models\SendingQueue::create();
$queue->newsletter_id = $queueData['newsletter_id'];
$queue->subscribers = serialize(
array(
'to_process' => $queueData['subscribers']
)
);
$queue->count_total = $queue->count_to_process = count($queueData['subscribers']);
$queue->save();
return array(
'newsletter_id' => $queue->newsletter_id,
'queue_id' => $queue->id
);
}, $data);
$result = Helpers::arrayColumn($result, 'queue_id', 'newsletter_id');
wp_send_json(
count($data) != count($result) ?
array(
'result' => false,
'errors' => array(__('Some queues could not be created.')),
'data' => $result
) :
array(
'result' => true,
'data' => $result
)
);
}
function deleteQueue($data) {
$queue = \MailPoet\Models\SendingQueue::whereNull('deleted_at')
->findOne($data['queue_id']);
if(!$queue) {
wp_send_json(
array(
'result' => false,
'errors' => array(__('Queue not found.'))
)
);
}
$queue->deleted_at = 'Y-m-d H:i:s';
$queue->save();
wp_send_json(array('result' => true));
}
function deleteQueues($data) {
$queues = \MailPoet\Models\SendingQueue::whereNull('deleted_at')
->whereIn('id', $data['queue_ids'])
->findResultSet();
if(!$queues->count()) {
wp_send_json(
array(
'result' => false,
'errors' => array(__('Queues not found.'))
)
);
}
foreach($queues as $queue) {
$queue->deleted_at = 'Y-m-d H:i:s';
$queue->save();
}
wp_send_json(array('result' => true));
}
function getQueueStatus($data) {
$queue = \MailPoet\Models\SendingQueue::whereNull('deleted_at')
->findOne($data['queue_id'])
->asArray();
wp_send_json(
!$queue ?
array(
'result' => false,
'errors' => array(__('Queue not found.'))
) :
array(
'result' => true,
'data' => $queue
)
);
}
function getQueuesStatus($data) {
$queues = \MailPoet\Models\SendingQueue::whereNull('deleted_at')
->whereIn('id', $data['queue_ids'])
->findArray();
wp_send_json(
!$queues ?
array(
'result' => false,
'errors' => array(__('Queue not found.'))
) :
array(
'result' => true,
'data' => $queues
)
);
}
}

1
tests/_bootstrap.php
View File

@@ -14,6 +14,7 @@ $models = array(
'NewsletterSegment',
'NewsletterTemplate',
'Segment',
'SendingQueue',
'Setting',
'Subscriber',
'SubscriberCustomField',

3
tests/unit/Listing/ListingCest.php
View File

@@ -1,6 +1,7 @@
<?php
use MailPoet\Listing;
use MailPoet\Models\Subscriber;
class ListingCest {
function _before() {
@@ -57,6 +58,6 @@ class ListingCest {
}
function _after() {
Subscriber::deleteMany();
}
}

113
tests/unit/Models/CustomFieldCest.php
View File

@@ -6,16 +6,12 @@ use MailPoet\Models\SubscriberCustomField;
class CustomFieldCest {
function _before() {
$this->before_time = time();
$this->data = array(
'name' => 'DOB',
'type' => 'date',
'params' => 'none'
);
$this->customField = CustomField::create();
$this->customField->hydrate($this->data);
$this->saved = $this->customField->save();
$this->subscribersData = array(
$this->custom_field = CustomField::createOrUpdate(array(
'name' => 'Birthdate',
'type' => 'date'
));
$this->subscribers = array(
array(
'first_name' => 'John',
'last_name' => 'Mailer',
@@ -30,20 +26,26 @@ class CustomFieldCest {
}
function itCanBeCreated() {
expect($this->saved->id() > 0)->true();
expect($this->saved->getErrors())->false();
expect($this->custom_field->id() > 0)->true();
expect($this->custom_field->getErrors())->false();
}
function itCanHaveName() {
expect($this->customField->name)->equals($this->data['name']);
function itHasAName() {
expect($this->custom_field->name)->equals('Birthdate');
}
function itCanHaveType() {
expect($this->customField->type)->equals($this->data['type']);
function itHasAType() {
expect($this->custom_field->type)->equals('date');
}
function itCanHaveParams() {
expect($this->customField->params)->equals($this->data['params']);
function itCanDecodeParams() {
$custom_field = $this->custom_field->asArray();
expect($custom_field['params'])->hasKey('label');
}
function itHasDefaultParams() {
$params = unserialize($this->custom_field->params);
expect($params['label'])->equals('Birthdate');
}
function itHasToBeValid() {
@@ -57,76 +59,51 @@ class CustomFieldCest {
expect($errors[1])->equals('You need to specify a type.');
}
function itHasACreatedAtOnCreation() {
$customField = CustomField::where('name', $this->data['name'])
->findOne();
$time_difference = strtotime($customField->created_at) >= $this->before_time;
expect($time_difference)->equals(true);
}
function itCanBeUpdated() {
$custom_field = $this->custom_field->asArray();
$custom_field['name'] = 'Favorite color';
$custom_field['type'] = 'text';
function itHasAnUpdatedAtOnCreation() {
$customField = CustomField::where('name', $this->data['name'])
->findOne();
$time_difference = strtotime($customField->updated_at) >= $this->before_time;
expect($time_difference)->equals(true);
}
$custom_field = CustomField::createOrUpdate($custom_field);
function itKeepsTheCreatedAtOnUpdate() {
$customField = CustomField::where('name', $this->data['name'])
->findOne();
$old_created_at = $customField->created_at;
$customField->name = 'new name';
$customField->save();
expect($old_created_at)->equals($customField->created_at);
}
expect($custom_field->getErrors())->false();
function itUpdatesTheUpdatedAtOnUpdate() {
$customField = CustomField::where('name', $this->data['name'])
->findOne();
$update_time = time();
$customField->name = 'new name';
$customField->save();
$time_difference = strtotime($customField->updated_at) >= $update_time;
expect($time_difference)->equals(true);
$updated_custom_field = CustomField::findOne($custom_field->id);
expect($updated_custom_field->name)->equals('Favorite color');
expect($updated_custom_field->type)->equals('text');
}
function itCanHaveManySubscribers() {
foreach ($this->subscribersData as $data) {
$subscriber = Subscriber::create();
$subscriber->hydrate($data);
$subscriber->save();
foreach($this->subscribers as $subscriber) {
$subscriber = Subscriber::createOrUpdate($subscriber);
$association = SubscriberCustomField::create();
$association->subscriber_id = $subscriber->id;
$association->custom_field_id = $this->customField->id;
$association->custom_field_id = $this->custom_field->id;
$association->save();
}
$customField = CustomField::findOne($this->customField->id);
$subscribers = $customField->subscribers()
->findArray();
$custom_field = CustomField::findOne($this->custom_field->id);
$subscribers = $custom_field->subscribers()->findArray();
expect(count($subscribers))->equals(2);
}
function itCanStoreCustomFieldValue() {
$subscriber = Subscriber::create();
$subscriber->hydrate($this->subscribersData[0]);
$subscriber->save();
function itCanHaveAValue() {
$subscriber = Subscriber::createOrUpdate($this->subscribers[0]);
$association = SubscriberCustomField::create();
$association->subscriber_id = $subscriber->id;
$association->custom_field_id = $this->customField->id;
$association->custom_field_id = $this->custom_field->id;
$association->value = '12/12/2012';
$association->save();
$customField = CustomField::findOne($this->customField->id);
$subscriber = $customField->subscribers()
->findOne();
$custom_field = CustomField::findOne($this->custom_field->id);
$subscriber = $custom_field->subscribers()->findOne();
expect($subscriber->value)->equals($association->value);
}
function _after() {
ORM::forTable(CustomField::$_table)
->deleteMany();
ORM::forTable(Subscriber::$_table)
->deleteMany();
ORM::forTable(SubscriberCustomField::$_table)
->deleteMany();
CustomField::deleteMany();
Subscriber::deleteMany();
SubscriberCustomField::deleteMany();
}
}

87
tests/unit/Models/FormCest.php
View File

@@ -3,19 +3,14 @@ use MailPoet\Models\Form;
class FormCest {
function _before() {
$this->before_time = time();
$this->data = array(
'name' => 'my form',
);
$this->form = Form::create();
$this->form->hydrate($this->data);
$this->saved = $this->form->save();
$this->form = Form::createOrUpdate(array(
'name' => 'My Form'
));
}
function itCanBeCreated() {
expect($this->saved->id() > 0)->true();
expect($this->saved->getErrors())->false();
expect($this->form->id() > 0)->true();
expect($this->form->getErrors())->false();
}
function itHasToBeValid() {
@@ -27,60 +22,50 @@ class FormCest {
expect($errors[0])->equals('You need to specify a name.');
}
function itHasACreatedAtOnCreation() {
$form = Form::where('name', $this->data['name'])
->findOne();
$time_difference = strtotime($form->created_at) >= $this->before_time;
expect($time_difference)->equals(true);
function itCanBeGrouped() {
$forms = Form::filter('groupBy', 'all')->findArray();
expect($forms)->count(1);
$forms = Form::filter('groupBy', 'trash')->findArray();
expect($forms)->count(0);
$this->form->trash();
$forms = Form::filter('groupBy', 'trash')->findArray();
expect($forms)->count(1);
$forms = Form::filter('groupBy', 'all')->findArray();
expect($forms)->count(0);
$this->form->restore();
$forms = Form::filter('groupBy', 'all')->findArray();
expect($forms)->count(1);
}
function itHasAnUpdatedAtOnCreation() {
$form = Form::where('name', $this->data['name'])
->findOne();
$time_difference = strtotime($form->updated_at) >= $this->before_time;
expect($time_difference)->equals(true);
}
function itKeepsTheCreatedAtOnUpdate() {
$form = Form::where('name', $this->data['name'])
->findOne();
$old_created_at = $form->created_at;
$form->name = 'new name';
$form->save();
expect($old_created_at)->equals($form->created_at);
}
function itUpdatesTheUpdatedAtOnUpdate() {
$form = Form::where('name', $this->data['name'])
->findOne();
$update_time = time();
$form->name = 'new name';
$form->save();
$time_difference = strtotime($form->updated_at) >= $update_time;
expect($time_difference)->equals(true);
function itCanBeSearched() {
$form = Form::filter('search', 'my F')->findOne();
expect($form->name)->equals('My Form');
}
function itCanCreateOrUpdate() {
$is_created = Form::createOrUpdate(array(
'name' => 'new form'
$created_form = Form::createOrUpdate(array(
'name' => 'Created Form'
));
expect($is_created)->notEquals(false);
expect($is_created->getValidationErrors())->isEmpty();
expect($created_form->id > 0)->true();
expect($created_form->getErrors())->false();
$form = Form::where('name', 'new form')->findOne();
expect($form->name)->equals('new form');
$form = Form::findOne($created_form->id);
expect($form->name)->equals('Created Form');
$is_updated = Form::createOrUpdate(array(
'id' => $form->id,
'name' => 'updated form'
'id' => $created_form->id,
'name' => 'Updated Form'
));
$form = Form::where('name', 'updated form')->findOne();
expect($form->name)->equals('updated form');
$form = Form::findOne($created_form->id);
expect($form->name)->equals('Updated Form');
}
function _after() {
ORM::forTable(Form::$_table)
->deleteMany();
Form::deleteMany();
}
}

182
tests/unit/Models/NewsletterCest.php
View File

@@ -2,76 +2,80 @@
use MailPoet\Models\Newsletter;
use MailPoet\Models\Segment;
use MailPoet\Models\SendingQueue;
use MailPoet\Models\NewsletterSegment;
use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\NewsletterOption;
class NewsletterCest {
function _before() {
$this->before_time = time();
$this->data = array(
'subject' => 'new newsletter',
'type' => 'standard',
'body' => 'body',
'preheader' => 'preheader'
);
$this->newsletter = Newsletter::createOrUpdate(array(
'subject' => 'My Standard Newsletter',
'preheader' => 'Pre Header',
'type' => 'standard'
));
$newsletter = Newsletter::create();
$newsletter->hydrate($this->data);
$this->newsletter = $newsletter;
$this->saved = $newsletter->save();
$this->segment_1 = Segment::createOrUpdate(array(
'name' => 'Segment 1'
));
$association = NewsletterSegment::create();
$association->newsletter_id = $this->newsletter->id;
$association->segment_id = $this->segment_1->id;
$association->save();
$this->segment_2 = Segment::createOrUpdate(array(
'name' => 'Segment 2'
));
$association = NewsletterSegment::create();
$association->newsletter_id = $this->newsletter->id;
$association->segment_id = $this->segment_2->id;
$association->save();
}
function itCanBeCreated() {
expect($this->saved->id() > 0)->true();
expect($this->saved->getErrors())->false();
expect($this->newsletter->id() > 0)->true();
expect($this->newsletter->getErrors())->false();
}
function itHasSubject() {
$newsletter = Newsletter::where('subject', $this->data['subject'])
->findOne();
expect($newsletter->subject)->equals($this->data['subject']);
$newsletter = Newsletter::findOne($this->newsletter->id);
expect($newsletter->subject)->equals($this->newsletter->subject);
}
function itHasType() {
$newsletter = Newsletter::where('type', $this->data['type'])
->findOne();
expect($newsletter->type)->equals($this->data['type']);
function itHasAType() {
$newsletter = Newsletter::findOne($this->newsletter->id);
expect($newsletter->type)->equals($this->newsletter->type);
}
function itHasBody() {
$newsletter = Newsletter::where('body', $this->data['body'])
->findOne();
expect($newsletter->body)->equals($this->data['body']);
function itHasABody() {
$newsletter = Newsletter::findOne($this->newsletter->id);
expect($newsletter->body)->equals($this->newsletter->body);
}
function itHasPreheader() {
$newsletter = Newsletter::where('preheader', $this->data['preheader'])
->findOne();
expect($newsletter->preheader)->equals($this->data['preheader']);
$newsletter = Newsletter::findOne($this->newsletter->id);
expect($newsletter->preheader)->equals($this->newsletter->preheader);
}
function itCanHaveASegment() {
$segmentData = array(
'name' => 'my first list'
);
function itCanBeQueued() {
$queue = $this->newsletter->getQueue();
expect($queue)->false();
$segment = Segment::create();
$segment->hydrate($segmentData);
$segment->save();
$sending_queue = SendingQueue::create();
$sending_queue->newsletter_id = $this->newsletter->id;
$sending_queue->save();
$newsletter = Newsletter::create();
$newsletter->hydrate($this->data);
$newsletter->save();
$queue = $this->newsletter->getQueue();
expect($queue->id() > 0)->true();
}
$association = NewsletterSegment::create();
$association->newsletter_id = $newsletter->id();
$association->segment_id = $segment->id();
$association->save();
$newsletter = Newsletter::findOne($newsletter->id);
$newsletterSegment = $newsletter->segments()->findOne();
expect($newsletterSegment->id)->equals($segment->id);
function itCanHaveSegments() {
$newsletter_segments = $this->newsletter->segments()->findArray();
expect($newsletter_segments)->count(2);
expect($newsletter_segments[0]['id'])->equals($this->segment_1->id);
expect($newsletter_segments[0]['name'])->equals('Segment 1');
expect($newsletter_segments[1]['id'])->equals($this->segment_2->id);
expect($newsletter_segments[1]['name'])->equals('Segment 2');
}
function itCanCreateOrUpdate() {
@@ -97,6 +101,54 @@ class NewsletterCest {
expect($newsletter->subject)->equals('updated newsletter');
}
function itCannotSetAnEmptyDeletedAt() {
$this->newsletter->deleted_at = '';
$newsletter = $this->newsletter->save();
expect($newsletter->deleted_at)->equals('NULL');
}
function itCanBeFilteredBySegment() {
// no filter
$newsletters = Newsletter::filter('filterBy')->findArray();
expect($newsletters)->count(1);
// filter by segment
$newsletters = Newsletter::filter('filterBy', array(
'segment' => $this->segment_1->id
))->findArray();
expect($newsletters)->count(1);
expect($newsletters[0]['subject'])->equals($this->newsletter->subject);
// remove all segment relations to newsletters
NewsletterSegment::deleteMany();
$newsletters = Newsletter::filter('filterBy', array(
'segment' => $this->segment_1->id
))->findArray();
expect($newsletters)->isEmpty();
}
function itCanBeGrouped() {
$newsletters = Newsletter::filter('groupBy', 'all')->findArray();
expect($newsletters)->count(1);
$newsletters = Newsletter::filter('groupBy', 'trash')->findArray();
expect($newsletters)->count(0);
$this->newsletter->trash();
$newsletters = Newsletter::filter('groupBy', 'trash')->findArray();
expect($newsletters)->count(1);
$newsletters = Newsletter::filter('groupBy', 'all')->findArray();
expect($newsletters)->count(0);
$this->newsletter->restore();
$newsletters = Newsletter::filter('groupBy', 'all')->findArray();
expect($newsletters)->count(1);
}
function itHasSearchFilter() {
Newsletter::createOrUpdate(
array(
@@ -110,16 +162,16 @@ class NewsletterCest {
}
function itCanHaveOptions() {
$newsletterOptionFieldData = array(
$newsletter_options = array(
'name' => 'Event',
'newsletter_type' => 'welcome',
);
$optionField = NewsletterOptionField::create();
$optionField->hydrate($newsletterOptionFieldData);
$optionField->save();
$option_field = NewsletterOptionField::create();
$option_field->hydrate($newsletter_options);
$option_field->save();
$association = NewsletterOption::create();
$association->newsletter_id = $this->newsletter->id;
$association->option_field_id = $optionField->id;
$association->option_field_id = $option_field->id;
$association->value = 'list';
$association->save();
$newsletter = Newsletter::filter('filterWithOptions')
@@ -128,7 +180,7 @@ class NewsletterCest {
}
function itCanFilterOptions() {
$newsletterOptionFieldData = array(
$newsletter_options = array(
array(
'name' => 'Event',
'newsletter_type' => 'welcome',
@@ -138,13 +190,13 @@ class NewsletterCest {
'newsletter_type' => 'welcome',
)
);
foreach ($newsletterOptionFieldData as $data) {
$optionField = NewsletterOptionField::create();
$optionField->hydrate($data);
$optionField->save();
$createdOptionFields[] = $optionField->asArray();
foreach ($newsletter_options as $data) {
$option_field = NewsletterOptionField::create();
$option_field->hydrate($data);
$option_field->save();
$createdOptionFields[] = $option_field->asArray();
}
$newsletterOptionData = array(
$newsletter_options = array(
array(
'newsletter_id' => $this->newsletter->id,
'option_field_id' => $createdOptionFields[0]['id'],
@@ -156,12 +208,12 @@ class NewsletterCest {
'value' => '1'
)
);
foreach ($newsletterOptionData as $data) {
foreach($newsletter_options as $data) {
$association = NewsletterOption::create();
$association->hydrate($data);
$association->save();
$createdAssociations[] = $association->asArray();
}
$newsletter = Newsletter::filter('filterWithOptions')
->filter('filterSearchCustomFields', array(
array(
@@ -200,11 +252,11 @@ class NewsletterCest {
}
function _after() {
ORM::forTable(NewsletterOption::$_table)
->deleteMany();
ORM::forTable(NewsletterOptionField::$_table)
->deleteMany();
ORM::for_table(Newsletter::$_table)
->deleteMany();
NewsletterOption::deleteMany();
NewsletterOptionField::deleteMany();
Newsletter::deleteMany();
Segment::deleteMany();
NewsletterSegment::deleteMany();
SendingQueue::deleteMany();
}
}

88
tests/unit/Models/SettingCest.php
View File

@@ -2,63 +2,52 @@
use MailPoet\Models\Setting;
class SettingCest {
function _before() {
$this->before_time = time();
$this->data = array(
'name' => 'sending_method',
'value' => 'smtp'
);
$setting = Setting::create();
$setting->hydrate($this->data);
$this->saved = $setting->save();
}
function itCanBeCreated() {
expect($this->saved->id() > 0)->true();
expect($this->saved->getErrors())->false();
}
function itHasToBeValid() {
$invalid_setting = Setting::create();
$result = $invalid_setting->save();
$errors = $result->getErrors();
$invalid_setting = Setting::createOrUpdate();
$errors = $invalid_setting->getErrors();
expect(is_array($errors))->true();
expect($errors)->notEmpty();
expect($errors[0])->equals('You need to specify a name.');
}
function itHasACreatedAtOnCreation() {
$setting = Setting::where('name', $this->data['name'])
->findOne();
$time_difference = strtotime($setting->created_at) >= $this->before_time;
expect($time_difference)->equals(true);
function itCanGetAllSettings() {
Setting::setValue('key_1', 'value_1');
Setting::setValue('key_2', 'value_2');
Setting::setValue('key_3', array(
'subkey_1' => 'subvalue_1',
'subkey_2' => 'subvalue_2'
));
$settings = Setting::getAll();
expect(array_keys($settings))->count(3);
expect($settings['key_1'])->equals('value_1');
expect($settings['key_2'])->equals('value_2');
expect($settings['key_3'])->equals(array(
'subkey_1' => 'subvalue_1',
'subkey_2' => 'subvalue_2'
));
}
function itHasAnUpdatedAtOnCreation() {
$setting = Setting::where('name', $this->data['name'])
->findOne();
$time_difference = strtotime($setting->updated_at) >= $this->before_time;
expect($time_difference)->equals(true);
}
function itReturnsDefaultValueIfNotSet() {
// try to get an "unknown" key
$setting = Setting::getValue('unknown_key', 'default_value');
expect($setting)->equals('default_value');
function itKeepsTheCreatedAtOnUpdate() {
$setting = Setting::where('name', $this->data['name'])
->findOne();
$old_created_at = $setting->created_at;
$setting->value = 'http_api';
$setting->save();
expect($old_created_at)->equals($setting->created_at);
}
// setting a "known" key
$setting = Setting::setValue('known_key', 'actual_value');
expect($setting)->equals(true);
function itUpdatesTheUpdatedAtOnUpdate() {
$setting = Setting::where('name', $this->data['name'])
->findOne();
$update_time = time();
$setting->value = 'http_api';
$setting->save();
$time_difference = strtotime($setting->updated_at) >= $update_time;
expect($time_difference)->equals(true);
// try to get a "known" key
$setting = Setting::getValue('known_key', 'default_value');
expect($setting)->equals('actual_value');
// try to get an "unknown" subkey of a "known" key
$setting = Setting::getValue('known_key.unknown_subkey', 'default_value');
expect($setting)->equals('default_value');
// try to get an "unknown" subkey of an "unknown" key
$setting = Setting::getValue('unknown_key.unknown_subkey', 'default_value');
expect($setting)->equals('default_value');
}
function itCanCreateOrUpdate() {
@@ -109,7 +98,6 @@ class SettingCest {
}
function _after() {
ORM::forTable(Setting::$_table)
->deleteMany();
Setting::deleteMany();
}
}

8
tests/unit/Router/CustomFieldsCest.php
View File

@@ -69,13 +69,17 @@ class CustomFieldsCest {
function itCanDeleteACustomField() {
$custom_field = CustomField::where('type', 'date')->findOne();
$custom_field_id = $custom_field->id();
$router = new CustomFields();
$response = $router->delete($custom_field->id());
$response = $router->delete($custom_field_id);
expect($response['result'])->true();
$custom_field = CustomField::where('type', 'date')->findOne();
expect($custom_field)->false();
$response = $router->delete($custom_field_id);
expect($response['result'])->false();
}
function itCanSaveACustomField() {
@@ -120,6 +124,6 @@ class CustomFieldsCest {
}
function _after() {
ORM::forTable(CustomField::$_table)->deleteMany();
CustomField::deleteMany();
}
}