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

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

Browse Source
This commit is contained in:
Jonathan Labreuille
2016-02-04 19:04:52 +01:00
parent 233020ca20
commit 55f851208b
25 changed files with 523 additions and 441 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
assets/js/src/newsletters/templates.jsx
View File

@ -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) {

12
assets/js/src/newsletters/types.jsx
View File

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

12
assets/js/src/newsletters/types/notification.jsx
View File

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

13
assets/js/src/newsletters/types/standard.jsx
View File

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

12
assets/js/src/newsletters/types/welcome.jsx
View File

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

30
lib/Models/CustomField.php
View File

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

18
lib/Models/Newsletter.php
View File

@ -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();

27
lib/Router/CustomFields.php
View File

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

15
lib/Router/Forms.php
View File

@ -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,
'form_id' => $form->id()
'result' => false,
'errors' => $errors
);
} else {
return array(
'result' => false,
'errors' => $form->getValidationErrors()
'result' => true,
'form_id' => $form->id()
);
}
}

13
lib/Router/NewsletterTemplates.php
View File

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

171
lib/Router/Newsletters.php
View File

@ -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()) {
$errors = $newsletter->getValidationErrors();
if(!empty($errors)) {
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();
}
wp_send_json($result);
return ($newsletter->getErrors() === false);
}
function trash($id) {
$result = false;
$newsletter = Newsletter::findOne($id);
if($newsletter !== false) {
$result = $newsletter->trash();
$newsletter->trash();
}
wp_send_json($result);
return ($newsletter->getErrors() === false);
}
function delete($id) {
$result = false;
$newsletter = Newsletter::findOne($id);
if($newsletter !== false) {
$newsletter->delete();
$result = 1;
return 1;
}
wp_send_json($result);
return false;
}
function duplicate($id) {
$result = false;
function duplicate($id = false) {
$newsletter = Newsletter::findOne($id);
if($newsletter !== false) {
$data = array(
return $newsletter->duplicate(array(
'subject' => sprintf(__('Copy of %s'), $newsletter->subject)
);
$result = $newsletter->duplicate($data)->asArray();
))->asArray();
}
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);
return false;
}
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();
$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;
}
$options = array();
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 $newsletter->asArray();
return array(
'result' => true,
'newsletter' => $newsletter->asArray()
);
}
}
}

4
lib/Router/Segments.php
View File

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

25
lib/Router/Subscribers.php
View File

@ -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()) {
$errors = $subscriber->getValidationErrors();
if(!empty($errors)) {
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()) {

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

@ -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() {

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

@ -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->getValidationErrors())->isEmpty();
expect($is_created->id() > 0)->true();
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',
'body' => 'body'
'subject' => 'updated newsletter'
));
$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')

62
tests/unit/Models/NewsletterOptionFieldCest.php
View File

@ -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->optionField->hydrate($this->data);
$this->saved = $this->optionField->save();
$this->newslettersData = array(
$this->option_field = NewsletterOptionField::create();
$this->option_field->hydrate($this->data);
$this->saved = $this->option_field->save();
$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;
$optionField->name = 'new name';
$optionField->save();
expect($old_created_at)->equals($optionField->created_at);
$old_created_at = $option_field->created_at;
$option_field->name = 'new name';
$option_field->save();
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';
$optionField->save();
$time_difference = strtotime($optionField->updated_at) >= $update_time;
$option_field->name = 'new name';
$option_field->save();
$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);
$newsletters = $optionField->newsletters()
$option_field = NewsletterOptionField::findOne($this->option_field->id);
$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);
$newsletter = $optionField->newsletters()
$option_field = NewsletterOptionField::findOne($this->option_field->id);
$newsletter = $option_field->newsletters()
->findOne();
expect($newsletter->value)->equals($association->value);
}

42
tests/unit/Models/SegmentCest.php
View File

@ -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->hydrate($this->data);
$this->saved = $this->segment->save();
$this->segment = Segment::createOrUpdate($this->data);
}
function itCanBeCreated() {
expect($this->saved->id() > 0)->true();
expect($this->saved->getErrors())->false();
expect($this->segment->id() > 0)->true();
expect($this->segment->getErrors())->false();
}
function itCanHaveName() {
@ -108,10 +108,10 @@ class SegmentCest {
function itCanCreateOrUpdate() {
$is_created = Segment::createOrUpdate(array(
'name' => 'new list'
));
expect($is_created)->notEquals(false);
expect($is_created->getValidationErrors())->isEmpty();
'name' => 'new list'
));
expect($is_created->id() > 0)->true();
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();

93
tests/unit/Models/SubscriberCest.php
View File

@ -105,75 +105,62 @@ class SubscriberCest {
}
function itCanHaveSegment() {
$segmentData = array(
$segment = Segment::createOrUpdate(array(
'name' => 'some name'
);
$segment = Segment::create();
$segment->hydrate($segmentData);
$segment->save();
));
expect($segment->getErrors())->false();
$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();
expect($subscriberSegment->id)->equals($segment->id);
$subscriber_segment = $subscriber->segments()->findOne();
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(
array(
'name' => 'City',
'type' => 'text',
),
array(
'name' => 'Country',
'type' => 'text',
)
);
foreach($customFieldData as $data) {
$customField = CustomField::create();
$customField->hydrate($data);
$customField->save();
$createdCustomFields[] = $customField->asArray();
}
$subscriberCustomFieldData = array(
array(
'subscriber_id' => $this->subscriber->id,
'custom_field_id' => $createdCustomFields[0]['id'],
'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();
}
$cf_city = CustomField::createOrUpdate(array(
'name' => 'City',
'type' => 'text'
));
SubscriberCustomField::createOrUpdate(array(
'subscriber_id' => $this->subscriber->id,
'custom_field_id' => $cf_city->id,
'value' => 'Paris'
));
$cf_country = CustomField::createOrUpdate(array(
'name' => 'Country',
'type' => 'text'
));
SubscriberCustomField::createOrUpdate(array(
'subscriber_id' => $this->subscriber->id,
'custom_field_id' => $cf_country->id,
'value' => 'France'
));
$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->getValidationErrors())->isEmpty();
expect($result->id() > 0)->true();
expect($result->getErrors())->false();
$record = Subscriber::where('email', $data['email'])
->findOne();

10
tests/unit/Router/FormsCest.php
View File

@ -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();

3
tests/unit/Router/NewsletterTemplatesCest.php
View File

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

208
tests/unit/Router/NewslettersCest.php Normal file
View File

@ -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();
}
}

9
tests/unit/Router/SegmentsCest.php
View File

@ -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'

22
tests/unit/Router/SubscribersCest.php
View File

@ -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',

146
tests/unit/Subscribers/ImportExport/BootStrapMenuCest.php
View File

@ -8,67 +8,76 @@ use MailPoet\Subscribers\ImportExport\BootStrapMenu;
class BootStrapMenuCest {
function _before() {
$this->segmentsData = array(
array(
'name' => 'first',
'description' => 'some description'
),
array(
'name' => 'second',
'description' => 'some description'
)
);
$this->subscribersData = array(
array(
'first_name' => 'John',
'last_name' => 'Mailer',
'status' => 'unconfirmed',
'email' => 'john@mailpoet.com'
),
array(
'first_name' => 'Mike',
'last_name' => 'Smith',
'status' => 'subscribed',
'email' => 'mike@maipoet.com'
)
);
$this->customFieldsData = array(
'name' => 'DOB',
'type' => 'date',
);
$customField = CustomField::create();
$customField->hydrate($this->customFieldsData);
$customField->save();
$segment_1 = Segment::createOrUpdate(array('name' => 'Unconfirmed Segment'));
$segment_2 = Segment::createOrUpdate(array('name' => 'Confirmed Segment'));
$subscriber_1 = Subscriber::createOrUpdate(array(
'first_name' => 'John',
'last_name' => 'Mailer',
'status' => 'unconfirmed',
'email' => 'john@mailpoet.com'
));
$subscriber_2 = Subscriber::createOrUpdate(array(
'first_name' => 'Mike',
'last_name' => 'Smith',
'status' => 'subscribed',
'email' => 'mike@maipoet.com'
));
$association = SubscriberSegment::create();
$association->subscriber_id = $subscriber_1->id;
$association->segment_id = $segment_1->id;
$association->save();
$association = SubscriberSegment::create();
$association->subscriber_id = $subscriber_2->id;
$association->segment_id = $segment_2->id;
$association->save();
CustomField::createOrUpdate(array(
'name' => 'Birthday',
'type' => 'date'
));
$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() {
$this->_createSegmentsAndSubscribers();
function itCanGetPublicSegmentsForImport() {
$segments = $this->bootStrapImportMenu->getSegments();
expect(count($segments))->equals(2);
$subscriber = Subscriber::findOne(1);
$subscriber->deleted_at = date('Y-m-d H:i:s');
$subscriber->save();
$subscriber = Subscriber::where(
'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() {
$this->_createSegmentsAndSubscribers();
function itCanGetPublicSegmentsForExport() {
$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);
ORM::raw_execute('TRUNCATE ' . Segment::$_table);
ORM::raw_execute('TRUNCATE ' . SubscriberSegment::$_table);
ORM::raw_execute('TRUNCATE ' . CustomField::$_table);
Subscriber::deleteMany();
Segment::deleteMany();
SubscriberSegment::deleteMany();
CustomField::deleteMany();
}
}

2
tests/unit/Subscribers/ImportExport/Export/ExportCest.php
View File

@ -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()