maily_herald 0.8.0 → 0.9.1

data/spec/models/maily_herald/periodical_mailing_spec.rb

@@ -3,11 +3,11 @@ require 'spec_helper'
 describe MailyHerald::PeriodicalMailing do
   before(:each) do
     @mailing = MailyHerald.periodical_mailing(:weekly_summary)
-    @mailing.should be_a MailyHerald::PeriodicalMailing
-    @mailing.should_not be_a_new_record
+    expect(@mailing).to be_kind_of(MailyHerald::PeriodicalMailing)
+    expect(@mailing).not_to be_a_new_record
 
     @list = @mailing.list
-    @mailing.start_at.should eq("user.created_at")
+    expect(@mailing.start_at).to eq("user.created_at")
   end
 
   after do
@@ -21,7 +21,7 @@ describe MailyHerald::PeriodicalMailing do
     end
 
     it "should create schedule" do
-      MailyHerald::Log.scheduled.for_mailing(@mailing).count.should eq(1)
+      expect(MailyHerald::Log.scheduled.for_mailing(@mailing).count).to eq(1)
     end
   end
 
@@ -38,21 +38,21 @@ describe MailyHerald::PeriodicalMailing do
     end
 
     it "should be triggered by start_at change" do
-      MailyHerald::Log.scheduled.for_mailing(@mailing).count.should eq(1)
+      expect(MailyHerald::Log.scheduled.for_mailing(@mailing).count).to eq(1)
       schedule = MailyHerald::Log.scheduled.for_mailing(@mailing).first
-      schedule.processing_at.to_i.should eq(@entity.created_at.to_i)
+      expect(schedule.processing_at.to_i).to eq(@entity.created_at.to_i)
 
       time = Time.now + 10.days
       @mailing.update_attribute(:start_at, time.to_s)
 
       schedule.reload
-      schedule.processing_at.to_i.should eq(time.to_i)
+      expect(schedule.processing_at.to_i).to eq(time.to_i)
     end
 
     it "should be triggered by unsubscribe" do
-      MailyHerald::Log.scheduled.for_mailing(@mailing).count.should eq(1)
+      expect(MailyHerald::Log.scheduled.for_mailing(@mailing).count).to eq(1)
       schedule = MailyHerald::Log.scheduled.for_mailing(@mailing).first
-      schedule.processing_at.to_i.should eq(@entity.created_at.to_i)
+      expect(schedule.processing_at.to_i).to eq(@entity.created_at.to_i)
 
       @list.unsubscribe! @entity
 
@@ -60,9 +60,9 @@ describe MailyHerald::PeriodicalMailing do
     end
 
     it "should be triggered by disabling mailing" do
-      MailyHerald::Log.scheduled.for_mailing(@mailing).count.should eq(1)
+      expect(MailyHerald::Log.scheduled.for_mailing(@mailing).count).to eq(1)
       schedule = MailyHerald::Log.scheduled.for_mailing(@mailing).first
-      schedule.processing_at.to_i.should eq(@entity.created_at.to_i)
+      expect(schedule.processing_at.to_i).to eq(@entity.created_at.to_i)
 
       @mailing.disable!
 
@@ -90,20 +90,20 @@ describe MailyHerald::PeriodicalMailing do
     end
 
     it "should parse start_at" do
-      @entity.should be_a(User)
-      @mailing.start_processing_time(@entity).should be_a(Time)
-      @mailing.next_processing_time(@entity).should be_a(Time)
-      @mailing.next_processing_time(@entity).to_i.should eq(@entity.created_at.to_i)
+      expect(@entity).to be_kind_of(User)
+      expect(@mailing.start_processing_time(@entity)).to be_kind_of(Time)
+      expect(@mailing.next_processing_time(@entity)).to be_kind_of(Time)
+      expect(@mailing.next_processing_time(@entity).to_i).to eq(@entity.created_at.to_i)
     end
 
     it "should use absolute start date if possible" do
-      @entity.should be_a(User)
+      expect(@entity).to be_kind_of(User)
       time = (@entity.created_at + rand(100).days + rand(24).hours + rand(60).minutes).round
       @mailing.update_attribute(:start_at, time.to_s)
 
-      @mailing.start_processing_time(@entity).should be_a(Time)
-      @mailing.next_processing_time(@entity).should be_a(Time)
-      @mailing.next_processing_time(@entity).should eq(time)
+      expect(@mailing.start_processing_time(@entity)).to be_a(Time)
+      expect(@mailing.next_processing_time(@entity)).to be_kind_of(Time)
+      expect(@mailing.next_processing_time(@entity)).to eq(time)
     end
   end
 
@@ -114,111 +114,115 @@ describe MailyHerald::PeriodicalMailing do
     end
 
     it "should deliver mailings periodically" do
-      @mailing.period.should eq 7.days
+      expect(@mailing.period).to eq 7.days
 
-      @mailing.last_processing_time(@entity).should eq nil
-      @mailing.next_processing_time(@entity).to_i.should eq((@entity.created_at).to_i)
+      expect(@mailing.last_processing_time(@entity)).to be_nil
+      expect(@mailing.next_processing_time(@entity).to_i).to eq((@entity.created_at).to_i)
 
       Timecop.freeze @entity.created_at
-      @mailing.run
-
-      @mailing.last_processing_time(@entity).to_i.should eq @entity.created_at.to_i
-      @mailing.next_processing_time(@entity).to_i.should eq((@entity.created_at + 7.days).to_i)
+      ret = @mailing.run
+      expect(ret).to be_a(Array)
+      expect(ret.first).to be_kind_of(MailyHerald::Log)
+      expect(ret.first.mail).to be_kind_of(Mail::Message)
+      expect(ret.first).to be_delivered
+
+      expect(@mailing.last_processing_time(@entity).to_i).to eq @entity.created_at.to_i
+      expect(@mailing.next_processing_time(@entity).to_i).to eq((@entity.created_at + 7.days).to_i)
     end
 
     it "should deliver mailings after period" do
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.processed.count.should eq(0)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.processed.count).to eq(0)
 
       Timecop.freeze @entity.created_at
 
-      @mailing.conditions_met?(@entity).should be_truthy
-      @mailing.processable?(@entity).should be_truthy
-      @mailing.next_processing_time(@entity).should be <= @entity.created_at
+      expect(@mailing.conditions_met?(@entity)).to be_truthy
+      expect(@mailing.processable?(@entity)).to be_truthy
+      expect(@mailing.next_processing_time(@entity)).to be <= @entity.created_at
 
-      @mailing.logs(@entity).scheduled.count.should eq(1)
+      expect(@mailing.logs(@entity).scheduled.count).to eq(1)
       schedule = @mailing.logs(@entity).scheduled.first
 
       @mailing.run
 
       schedule.reload
-      schedule.status.should eq(:delivered)
+      expect(schedule.status).to eq(:delivered)
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.processed.count.should eq(1)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.processed.count).to eq(1)
 
       log = MailyHerald::Log.processed.first
-      log.entity.should eq(@entity)
-      log.entity_email.should eq(@entity.email)
-      log.mailing.should eq(@mailing)
+      expect(log.entity).to eq(@entity)
+      expect(log.entity_email).to eq(@entity.email)
+      expect(log.mailing).to eq(@mailing)
 
-      @mailing.logs(@entity).processed.last.should eq(log)
-      @mailing.last_processing_time(@entity).to_i.should eq(@entity.created_at.to_i)
+      expect(@mailing.logs(@entity).processed.last).to eq(log)
+      expect(@mailing.last_processing_time(@entity).to_i).to eq(@entity.created_at.to_i)
 
-      @mailing.logs(@entity).scheduled.count.should eq(1)
+      expect(@mailing.logs(@entity).scheduled.count).to eq(1)
 
       @mailing.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.processed.count.should eq(1)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.processed.count).to eq(1)
 
       Timecop.freeze @entity.created_at + @mailing.period + @mailing.period/3
 
-      @mailing.logs(@entity).scheduled.count.should eq(1)
+      expect(@mailing.logs(@entity).scheduled.count).to eq(1)
 
       @mailing.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.processed.count.should eq(2)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.processed.count).to eq(2)
 
       Timecop.freeze @entity.created_at + @mailing.period + @mailing.period/2
 
       @mailing.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.processed.count.should eq(2)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.processed.count).to eq(2)
     end
 
     it "should calculate valid next delivery date" do
       period = @mailing.period
 
-      @mailing.last_processing_time(@entity).should be_nil
-      @mailing.start_processing_time(@entity).should be_a(Time)
-      @mailing.start_processing_time(@entity).should eq(@entity.created_at)
-      @mailing.next_processing_time(@entity).to_i.should eq(@entity.created_at.to_i)
+      expect(@mailing.last_processing_time(@entity)).to be_nil
+      expect(@mailing.start_processing_time(@entity)).to be_kind_of(Time)
+      expect(@mailing.start_processing_time(@entity)).to eq(@entity.created_at)
+      expect(@mailing.next_processing_time(@entity).to_i).to eq(@entity.created_at.to_i)
     end
 
     it "should handle processing with start date evaluated to the past date" do
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.processed.count.should eq(0)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.processed.count).to eq(0)
 
-      @mailing.next_processing_time(@entity).to_i.should eq(@entity.created_at.to_i)
+      expect(@mailing.next_processing_time(@entity).to_i).to eq(@entity.created_at.to_i)
       start_at = @entity.created_at + 1.year
 
       Timecop.freeze start_at
 
-      @mailing.conditions_met?(@entity).should be_truthy
-      @mailing.processable?(@entity).should be_truthy
+      expect(@mailing.conditions_met?(@entity)).to be_truthy
+      expect(@mailing.processable?(@entity)).to be_truthy
 
       @mailing.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.processed.count.should eq(1)
-      @mailing.last_processing_time(@entity).to_i.should eq(start_at.to_i)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.processed.count).to eq(1)
+      expect(@mailing.last_processing_time(@entity).to_i).to eq(start_at.to_i)
 
       Timecop.freeze start_at +1
       @mailing.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(1)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
 
-      @mailing.next_processing_time(@entity).to_i.should eq((start_at + @mailing.period).to_i)
+      expect(@mailing.next_processing_time(@entity).to_i).to eq((start_at + @mailing.period).to_i)
       Timecop.freeze start_at + @mailing.period
 
       @mailing.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(2)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(2)
     end
   end
 
@@ -234,14 +238,14 @@ describe MailyHerald::PeriodicalMailing do
     end
 
     it "should handle start_at parsing errors or nil start time" do
-      @mailing.last_processing_time(@entity).should be_nil
-      @mailing.next_processing_time(@entity).should be_nil
+      expect(@mailing.last_processing_time(@entity)).to be_nil
+      expect(@mailing.next_processing_time(@entity)).to be_nil
 
       Timecop.freeze @entity.created_at
       @mailing.run
 
-      @mailing.last_processing_time(@entity).should be_nil
-      @mailing.next_processing_time(@entity).should be_nil
+      expect(@mailing.last_processing_time(@entity)).to be_nil
+      expect(@mailing.next_processing_time(@entity)).to be_nil
     end
 
     after do
@@ -259,42 +263,42 @@ describe MailyHerald::PeriodicalMailing do
     end
 
     it "should not deliver" do
-      MailyHerald::Subscription.count.should eq(0)
-      MailyHerald::Log.count.should eq(0)
+      expect(MailyHerald::Subscription.count).to eq(0)
+      expect(MailyHerald::Log.count).to eq(0)
 
       Timecop.freeze @entity.created_at
 
       @mailing.run
 
-      MailyHerald::Subscription.count.should eq(0)
-      MailyHerald::Log.count.should eq(0)
+      expect(MailyHerald::Subscription.count).to eq(0)
+      expect(MailyHerald::Log.count).to eq(0)
     end
 
     it "should not deliver individual mailing" do
-      MailyHerald::Subscription.count.should eq(0)
-      MailyHerald::Log.count.should eq(0)
+      expect(MailyHerald::Subscription.count).to eq(0)
+      expect(MailyHerald::Log.count).to eq(0)
 
       Timecop.freeze @entity.created_at
 
-      @mailing.deliver_to @entity
+      expect{ @mailing.deliver_to @entity }.to raise_error(NoMethodError)
 
-      MailyHerald::Subscription.count.should eq(0)
-      MailyHerald::Log.count.should eq(0)
+      expect(MailyHerald::Subscription.count).to eq(0)
+      expect(MailyHerald::Log.count).to eq(0)
     end
 
     it "should deliver with subscription override" do
-      MailyHerald::Subscription.count.should eq(0)
-      MailyHerald::Log.count.should eq(0)
+      expect(MailyHerald::Subscription.count).to eq(0)
+      expect(MailyHerald::Log.count).to eq(0)
 
       @mailing.update_attribute(:override_subscription, true)
-      MailyHerald::Log.scheduled.count.should eq(1)
+      expect(MailyHerald::Log.scheduled.count).to eq(1)
 
       Timecop.freeze @entity.created_at
 
       @mailing.run
 
-      MailyHerald::Subscription.count.should eq(0)
-      MailyHerald::Log.delivered.count.should eq(1)
+      expect(MailyHerald::Subscription.count).to eq(0)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
     end
   end
 
@@ -305,15 +309,16 @@ describe MailyHerald::PeriodicalMailing do
     end
 
     it "should check mailing conditions" do
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(0)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(0)
 
       Timecop.freeze @entity.created_at
 
       @mailing.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(1)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
+      expect(@mailing.schedule_for(@entity)).not_to be_nil
 
       @entity.update_attribute(:weekly_notifications, false)
       @entity.save
@@ -322,9 +327,10 @@ describe MailyHerald::PeriodicalMailing do
 
       @mailing.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(1)
-      MailyHerald::Log.skipped.count.should eq(1)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
+      expect(MailyHerald::Log.skipped.count).to eq(1)
+      expect(@mailing.schedule_for(@entity)).not_to be_nil
 
       @entity.update_attribute(:weekly_notifications, true)
 
@@ -332,8 +338,68 @@ describe MailyHerald::PeriodicalMailing do
 
       @mailing.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(2)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(2)
+    end
+  end
+
+  describe "general scheduling" do
+    before(:each) do
+      @entity = FactoryGirl.create :user
+
+      @mailing = MailyHerald.periodical_mailing(:general_scheduling_mailing) do |mailing|
+        mailing.enable
+        mailing.list = :generic_list
+        mailing.subject = "Test mailing"
+        mailing.start_at = Time.now.to_s
+        mailing.period = 1.day
+        mailing.template = "User name: {{user.name}}."
+      end
+
+      expect(@mailing).to be_valid
+      expect(@mailing).to be_persisted
+      expect(@mailing).to be_enabled
+    end
+
+    after(:each) do
+      @mailing.destroy
+    end
+
+    it "should detect individual/general scheduling properly" do
+      expect(@mailing.individual_scheduling?).to be_falsy
+
+      @mailing.start_at = "user.created_at"
+      expect(@mailing.individual_scheduling?).to be_truthy
+    end
+
+    it "should create schedules for the next period" do
+      schedule = @mailing.schedule_for(@entity)
+      expect(schedule).to be_nil
+
+      time = Time.now - 5.hours
+      @mailing.start_at = time
+      @mailing.save!
+
+      @list.subscribe!(@entity)
+
+      schedule = @mailing.schedule_for(@entity)
+      expect(schedule.processing_at.to_i).not_to eq(time.to_i)
+      expect(schedule.processing_at.to_i).to eq((time + @mailing.period).to_i)
+    end
+
+    it "should create schedules for the first period" do
+      schedule = @mailing.schedule_for(@entity)
+      expect(schedule).to be_nil
+
+      time = Time.now + 5.hours
+      @mailing.start_at = time
+      @mailing.save!
+
+      @list.subscribe!(@entity)
+
+      schedule = @mailing.schedule_for(@entity)
+      expect(schedule.processing_at.to_i).to eq(time.to_i)
+      expect(schedule.processing_at.to_i).not_to eq((time + @mailing.period).to_i)
     end
   end
 end

data/spec/models/maily_herald/sequence_mailing_spec.rb

@@ -9,10 +9,10 @@ describe MailyHerald::SequenceMailing do
   describe "Validations" do
     it do
       @mailing.absolute_delay = nil
-      @mailing.should_not be_valid
+      expect(@mailing).not_to be_valid
 
       @mailing.absolute_delay = ""
-      @mailing.should_not be_valid
+      expect(@mailing).not_to be_valid
     end
   end
 end

data/spec/models/maily_herald/sequence_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe MailyHerald::Sequence do
   before(:each) do
     @sequence = MailyHerald.sequence(:newsletters)
-    @sequence.should be_a MailyHerald::Sequence
-    @sequence.should_not be_a_new_record
-    @sequence.start_at.should eq("user.created_at")
-    @sequence.mailings.length.should eq(3)
+    expect(@sequence).to be_a MailyHerald::Sequence
+    expect(@sequence).not_to be_a_new_record
+    expect(@sequence.start_at).to eq("user.created_at")
+    expect(@sequence.mailings.length).to eq(3)
 
     @list = @sequence.list
-    @list.name.should eq "generic_list"
+    expect(@list.name).to eq "generic_list"
   end
 
   after(:all) do
@@ -24,19 +24,19 @@ describe MailyHerald::Sequence do
 
     it "should find or initialize sequence subscription" do
       subscription = @sequence.subscription_for @entity
-      subscription.should be_valid
-      subscription.should_not be_a_new_record
-      subscription.should be_a(MailyHerald::Subscription)
-      subscription.should be_active
+      expect(subscription).to be_valid
+      expect(subscription).not_to be_a_new_record
+      expect(subscription).to be_kind_of(MailyHerald::Subscription)
+      expect(subscription).to be_active
     end
 
     it "should find or initialize sequence subscription via mailing" do
       subscription = @sequence.mailings.first.subscription_for @entity
-      subscription.should be_valid
-      subscription.should_not be_a_new_record
-      subscription.should be_a(MailyHerald::Subscription)
-      subscription.should eq(@sequence.subscription_for(@entity))
-      subscription.should be_active
+      expect(subscription).to be_valid
+      expect(subscription).not_to be_a_new_record
+      expect(subscription).to be_kind_of(MailyHerald::Subscription)
+      expect(subscription).to eq(@sequence.subscription_for(@entity))
+      expect(subscription).to be_active
     end
   end
 
@@ -81,20 +81,25 @@ describe MailyHerald::Sequence do
     end
 
     it "should parse start_var" do
-      @entity.should be_a(User)
-      @sequence.processed_logs(@entity).should be_empty
-      @sequence.next_processing_time(@entity).should be_a(Time)
+      expect(@entity).to be_a(User)
+      expect(@sequence.processed_logs(@entity)).to be_empty
+      expect(@sequence.next_processing_time(@entity)).to be_kind_of(Time)
     end
 
-    it "should use absolute start date if provided and greater that evaluated start date" do
-      @entity.should be_a(User)
+    it "should use absolute start date if provided and greater than evaluated start date" do
+      expect(@entity).to be_kind_of(User)
       time = (@entity.created_at + rand(100).days + rand(24).hours + rand(60).minutes).round
       @sequence.start_at = time.to_s
-      @sequence.save
-      @sequence.next_processing_time(@entity).should be_a(Time)
-      @sequence.next_processing_time(@entity).should eq(time + @sequence.mailings.first.absolute_delay)
+      expect(@sequence.has_start_at_proc?).to be_falsey
+      expect(@sequence.start_at_changed?).to be_truthy
+      @sequence.save!
+      expect(Time.parse(@sequence.start_at).to_i).to eq(time.to_i)
+      expect(@sequence.next_processing_time(@entity)).to be_kind_of(Time)
+      expect(@sequence.next_processing_time(@entity)).to eq(time + @sequence.mailings.first.absolute_delay)
 
       @subscription = @sequence.subscription_for(@entity)
+      expect(@subscription).to be_active
+      expect(@sequence.processed_mailings(@entity)).to be_empty
     end
   end
 
@@ -113,210 +118,216 @@ describe MailyHerald::Sequence do
     end
 
     it "should deliver mailings with delays" do
-      @sequence.mailings.length.should eq(3)
-      #@sequence.start.should be_nil
-
-      @sequence.processed_mailings(@entity).length.should eq(0)
-      @sequence.pending_mailings(@entity).length.should eq(@sequence.mailings.length)
-      @sequence.next_mailing(@entity).absolute_delay.should_not eq(0)
-      @sequence.next_processing_time(@entity).round.should eq((@entity.created_at + @sequence.mailings.first.absolute_delay).round)
-      @subscription.should_not be_a_new_record
-      @subscription.should be_active
-      #@subscription.should be_processable
-      @subscription.should_not be_a_new_record
+      expect(@sequence.mailings.length).to eq(3)
+      #@sequence.start).to be_nil
+
+      expect(@sequence.processed_mailings(@entity).length).to eq(0)
+      expect(@sequence.pending_mailings(@entity).length).to eq(@sequence.mailings.length)
+      expect(@sequence.next_mailing(@entity).absolute_delay).not_to eq(0)
+      expect(@sequence.next_processing_time(@entity).round).to eq((@entity.created_at + @sequence.mailings.first.absolute_delay).round)
+      expect(@subscription).not_to be_a_new_record
+      expect(@subscription).to be_active
+      #@subscription).to be_processable
+      expect(@subscription).not_to be_a_new_record
+
+      schedule = @sequence.schedule_for(@entity)
+      expect(schedule).to be_a(MailyHerald::Log)
+      expect(schedule.processing_at.round).to eq((@entity.created_at + @sequence.mailings.first.absolute_delay).round)
 
       Timecop.freeze @entity.created_at
 
       @sequence.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(0)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(0)
 
       Timecop.freeze @entity.created_at + @sequence.mailings.first.absolute_delay
 
       @sequence.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(1)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      schedule.reload
+      expect(schedule.status).to eq(:delivered)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
 
-      @sequence.processed_mailings(@entity).length.should eq(1)
-      @sequence.pending_mailings(@entity).length.should eq(@sequence.mailings.length - 1)
-      @sequence.pending_mailings(@entity).first.should eq(@sequence.mailings[1])
+      expect(@sequence.processed_mailings(@entity).length).to eq(1)
+      expect(@sequence.pending_mailings(@entity).length).to eq(@sequence.mailings.length - 1)
+      expect(@sequence.pending_mailings(@entity).first).to eq(@sequence.mailings[1])
       
-      @sequence.last_processed_mailing(@entity).should eq @sequence.mailings.first
+      expect(@sequence.last_processed_mailing(@entity)).to eq @sequence.mailings.first
       log = @sequence.mailing_processing_log_for(@entity, @sequence.mailings.first)
-      log.processing_at.to_i.should eq (@entity.created_at + @sequence.mailings.first.absolute_delay).to_i
+      expect(log.processing_at.to_i).to eq (@entity.created_at + @sequence.mailings.first.absolute_delay).to_i
 
       Timecop.freeze @entity.created_at + (@sequence.mailings[0].absolute_delay + @sequence.mailings[1].absolute_delay)/2.0
 
       @sequence.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(1)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
 
       Timecop.freeze @entity.created_at + @sequence.mailings[1].absolute_delay
 
       @sequence.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(2) 
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(2) 
 
       log = @sequence.mailing_processing_log_for(@entity, @sequence.mailings.first)
-      log.should be_a(MailyHerald::Log)
-      log.entity.should eq(@entity)
+      expect(log).to be_kind_of(MailyHerald::Log)
+      expect(log.entity).to eq(@entity)
 
       log = @sequence.mailing_processing_log_for(@entity, @sequence.mailings[1])
-      log.should be_a(MailyHerald::Log)
-      log.entity.should eq(@entity)
-      log.entity_email.should eq(@entity.email)
+      expect(log).to be_kind_of(MailyHerald::Log)
+      expect(log.entity).to eq(@entity)
+      expect(log.entity_email).to eq(@entity.email)
     end
 
     it "should handle processing with start date evaluated to the past date" do
-      @sequence.mailings.length.should eq(3)
-      #@sequence.start.should be_nil
+      expect(@sequence.mailings.length).to eq(3)
+      #expect(@sequence.start).to be_nil
 
       start_at = @entity.created_at.round + 1.year
 
-      @sequence.processed_mailings(@entity).length.should eq(0)
-      @sequence.pending_mailings(@entity).length.should eq(@sequence.mailings.length)
-      @sequence.next_mailing(@entity).absolute_delay.should_not eq(0)
-      @sequence.next_processing_time(@entity).round.should eq((@entity.created_at + @sequence.mailings.first.absolute_delay).round)
+      expect(@sequence.processed_mailings(@entity).length).to eq(0)
+      expect(@sequence.pending_mailings(@entity).length).to eq(@sequence.mailings.length)
+      expect(@sequence.next_mailing(@entity).absolute_delay).not_to eq(0)
+      expect(@sequence.next_processing_time(@entity).round).to eq((@entity.created_at + @sequence.mailings.first.absolute_delay).round)
 
       Timecop.freeze start_at
 
       @sequence.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(1)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
 
       Timecop.freeze start_at + 1
 
       @sequence.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(1)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
 
-      @sequence.next_processing_time(@entity).to_i.should eq((start_at - @sequence.mailings.first.absolute_delay + @sequence.pending_mailings(@entity).first.absolute_delay).to_i)
+      expect(@sequence.next_processing_time(@entity).to_i).to eq((start_at - @sequence.mailings.first.absolute_delay + @sequence.pending_mailings(@entity).first.absolute_delay).to_i)
       Timecop.freeze start_at - @sequence.mailings.first.absolute_delay + @sequence.pending_mailings(@entity).first.absolute_delay
 
       @sequence.run
 
-      MailyHerald::Subscription.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(2)
+      expect(MailyHerald::Subscription.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(2)
     end
 
     it "should calculate delivery times relatively based on existing logs" do
-      @sequence.mailings.length.should eq(3)
-      #@sequence.start.should be_nil
+      expect(@sequence.mailings.length).to eq(3)
+      #expect(@sequence.start).to be_nil
 
       Timecop.freeze @entity.created_at + @sequence.mailings[0].absolute_delay
 
       @sequence.run
 
-      MailyHerald::Log.delivered.count.should eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
 
       Timecop.freeze @entity.created_at + @sequence.mailings[2].absolute_delay
 
       @sequence.run
       @sequence.run
 
-      MailyHerald::Log.delivered.count.should eq(2)
+      expect(MailyHerald::Log.delivered.count).to eq(2)
 
       Timecop.freeze @entity.created_at + @sequence.mailings[2].absolute_delay + (@sequence.mailings[2].absolute_delay - @sequence.mailings[1].absolute_delay)
 
       @sequence.run
 
-      MailyHerald::Log.delivered.count.should eq(3)
+      expect(MailyHerald::Log.delivered.count).to eq(3)
     end
 
     it "should skip disabled mailings and go on with processing" do
-      @sequence.mailings.length.should eq(3)
-      #@sequence.start.should be_nil
-      @sequence.should be_enabled
+      expect(@sequence.mailings.length).to eq(3)
+      #expect(@sequence.start).to be_nil
+      expect(@sequence).to be_enabled
 
-      @sequence.mailings[0].should be_enabled
-      @sequence.mailings[1].should be_enabled
-      @sequence.mailings[2].should be_enabled
+      expect(@sequence.mailings[0]).to be_enabled
+      expect(@sequence.mailings[1]).to be_enabled
+      expect(@sequence.mailings[2]).to be_enabled
 
       @sequence.mailings[1].disable!
-      @sequence.mailings[1].should_not be_enabled
+      expect(@sequence.mailings[1]).not_to be_enabled
 
-      @sequence.pending_mailings(@entity).first.should eq(@sequence.mailings.first)
-      @sequence.pending_mailings(@entity).first.should be_enabled
+      expect(@sequence.pending_mailings(@entity).first).to eq(@sequence.mailings.first)
+      expect(@sequence.pending_mailings(@entity).first).to be_enabled
 
       Timecop.freeze @entity.created_at + @sequence.pending_mailings(@entity).first.absolute_delay
 
       @sequence.run
 
-      MailyHerald::Log.delivered.count.should eq(1)
-      @sequence.processed_mailings(@entity).length.should eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
+      expect(@sequence.processed_mailings(@entity).length).to eq(1)
 
-      @sequence.pending_mailings(@entity).should_not include(@sequence.mailings[1])
-      @sequence.next_mailing(@entity).should eq(@sequence.mailings[2])
+      expect(@sequence.pending_mailings(@entity)).not_to include(@sequence.mailings[1])
+      expect(@sequence.next_mailing(@entity)).to eq(@sequence.mailings[2])
 
       Timecop.freeze @entity.created_at + @sequence.mailings[2].absolute_delay
 
       @sequence.run
 
-      MailyHerald::Log.delivered.count.should eq(2)
-      @sequence.pending_mailings(@entity).should be_empty
+      expect(MailyHerald::Log.delivered.count).to eq(2)
+      expect(@sequence.pending_mailings(@entity)).to be_empty
     end
 
     it "should skip mailings with unmet conditions and create logs for them" do
       @sequence.mailings[1].update_attribute(:conditions, "false")
 
-      @sequence.pending_mailings(@entity).first.should eq(@sequence.mailings.first)
+      expect(@sequence.pending_mailings(@entity).first).to eq(@sequence.mailings.first)
       Timecop.freeze @entity.created_at + @sequence.pending_mailings(@entity).first.absolute_delay
       @sequence.run
-      MailyHerald::Log.processed.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(1)
-      MailyHerald::Log.skipped.count.should eq(0)
-      MailyHerald::Log.error.count.should eq(0)
+      expect(MailyHerald::Log.processed.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
+      expect(MailyHerald::Log.skipped.count).to eq(0)
+      expect(MailyHerald::Log.error.count).to eq(0)
 
-      @sequence.pending_mailings(@entity).first.should eq(@sequence.mailings[1])
+      expect(@sequence.pending_mailings(@entity).first).to eq(@sequence.mailings[1])
       Timecop.freeze @entity.created_at + @sequence.pending_mailings(@entity).first.absolute_delay
       @sequence.run
-      MailyHerald::Log.processed.count.should eq(2)
-      MailyHerald::Log.delivered.count.should eq(1)
-      MailyHerald::Log.skipped.count.should eq(1)
-      MailyHerald::Log.error.count.should eq(0)
+      expect(MailyHerald::Log.processed.count).to eq(2)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
+      expect(MailyHerald::Log.skipped.count).to eq(1)
+      expect(MailyHerald::Log.error.count).to eq(0)
 
-      @sequence.pending_mailings(@entity).first.should eq(@sequence.mailings[2])
+      expect(@sequence.pending_mailings(@entity).first).to eq(@sequence.mailings[2])
       Timecop.freeze @entity.created_at + @sequence.pending_mailings(@entity).first.absolute_delay
       @sequence.run
-      MailyHerald::Log.processed.count.should eq(3)
-      MailyHerald::Log.delivered.count.should eq(2)
-      MailyHerald::Log.skipped.count.should eq(1)
-      MailyHerald::Log.error.count.should eq(0)
+      expect(MailyHerald::Log.processed.count).to eq(3)
+      expect(MailyHerald::Log.delivered.count).to eq(2)
+      expect(MailyHerald::Log.skipped.count).to eq(1)
+      expect(MailyHerald::Log.error.count).to eq(0)
     end
 
     pending "should skip mailings with errors and create logs for them" do
       @sequence.mailings[1].update_attribute(:template, "foo {{error =! here bar")
 
-      @sequence.pending_mailings(@entity).first.should eq(@sequence.mailings.first)
-      @sequence.processable?(@entity).should be_truthy
+      expect(@sequence.pending_mailings(@entity).first).to eq(@sequence.mailings.first)
+      expect(@sequence.processable?(@entity)).to be_truthy
       Timecop.freeze @entity.created_at + @sequence.pending_mailings(@entity).first.absolute_delay
       @sequence.run
-      MailyHerald::Log.processed.count.should eq(1)
-      MailyHerald::Log.delivered.count.should eq(1)
-      MailyHerald::Log.skipped.count.should eq(0)
-      MailyHerald::Log.error.count.should eq(0)
+      expect(MailyHerald::Log.processed.count).to eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
+      expect(MailyHerald::Log.skipped.count).to eq(0)
+      expect(MailyHerald::Log.error.count).to eq(0)
 
-      @sequence.pending_mailings(@entity).first.should eq(@sequence.mailings[1])
+      expect(@sequence.pending_mailings(@entity).first).to eq(@sequence.mailings[1])
       Timecop.freeze @entity.created_at + @sequence.pending_mailings(@entity).first.absolute_delay
       @sequence.run
-      MailyHerald::Log.processed.count.should eq(2)
-      MailyHerald::Log.delivered.count.should eq(1)
-      MailyHerald::Log.skipped.count.should eq(0)
-      MailyHerald::Log.error.count.should eq(1)
+      expect(MailyHerald::Log.processed.count).to eq(2)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
+      expect(MailyHerald::Log.skipped.count).to eq(0)
+      expect(MailyHerald::Log.error.count).to eq(1)
 
-      @sequence.pending_mailings(@entity).first.should eq(@sequence.mailings[2])
+      expect(@sequence.pending_mailings(@entity).first).to eq(@sequence.mailings[2])
       Timecop.freeze @entity.created_at + @sequence.pending_mailings(@entity).first.absolute_delay
       @sequence.run
-      MailyHerald::Log.processed.count.should eq(3)
-      MailyHerald::Log.delivered.count.should eq(2)
-      MailyHerald::Log.skipped.count.should eq(0)
-      MailyHerald::Log.error.count.should eq(1)
+      expect(MailyHerald::Log.processed.count).to eq(3)
+      expect(MailyHerald::Log.delivered.count).to eq(2)
+      expect(MailyHerald::Log.skipped.count).to eq(0)
+      expect(MailyHerald::Log.error.count).to eq(1)
     end
 
   end
@@ -334,36 +345,36 @@ describe MailyHerald::Sequence do
     end
 
     it "should handle start_var parsing errors or nil start time" do
-      @sequence.start_at.should eq("")
+      expect(@sequence.start_at).to eq("")
       @sequence = @sequence.subscription_for @entity
-      @sequence.last_processing_time(@entity).should be_nil
-      @sequence.next_processing_time(@entity).should be_nil
+      expect(@sequence.last_processing_time(@entity)).to be_nil
+      expect(@sequence.next_processing_time(@entity)).to be_nil
 
       Timecop.freeze @entity.created_at
       @sequence.run
 
       @sequence = @sequence.subscription_for @entity
-      @sequence.last_processing_time(@entity).should be_nil
-      @sequence.next_processing_time(@entity).should be_nil
+      expect(@sequence.last_processing_time(@entity)).to be_nil
+      expect(@sequence.next_processing_time(@entity)).to be_nil
     end
 
     pending "should allow to set start date via text field" do
       datetime = "2013-01-01 10:11"
 
       @sequence.start_at = datetime
-      @sequence.should be_valid
-      @sequence.start_at.should eq(datetime)
+      expect(@sequence).to be_valid
+      expect(@sequence.start_at).to eq(datetime)
 
       @sequence.start_at = ""
-      @sequence.should be_valid
+      expect(@sequence).to be_valid
     end
   end
 
   #describe "Without autosubscribe" do
     #before(:each) do
       #@sequence.update_attribute(:autosubscribe, false)
-      #@sequence.should be_valid
-      #@sequence.save.should be_truthy
+      #expect(@sequence).to be_valid
+      #expect(@sequence.save).to be_truthy
       #@entity = FactoryGirl.create :user
     #end
 
@@ -374,17 +385,17 @@ describe MailyHerald::Sequence do
     #it "should create inactive subscription" do
       #subscription = @sequence.subscription_for @entity
 
-      #MailyHerald::MailingSubscription.count.should eq(0)
-      #MailyHerald::SequenceSubscription.count.should eq(1)
-      #MailyHerald::Log.count.should eq(0)
+      #expect(MailyHerald::MailingSubscription.count).to eq(0)
+      #expect(MailyHerald::SequenceSubscription.count).to eq(1)
+      #expect(MailyHerald::Log.count).to eq(0)
 
       #Timecop.freeze @entity.created_at
 
       #@sequence.run
 
-      #MailyHerald::MailingSubscription.count.should eq(0)
-      #MailyHerald::SequenceSubscription.count.should eq(1)
-      #MailyHerald::Log.count.should eq(0)
+      #expect(MailyHerald::MailingSubscription.count).to eq(0)
+      #expect(MailyHerald::SequenceSubscription.count).to eq(1)
+      #expect(MailyHerald::Log.count).to eq(0)
     #end
   #end
 
@@ -400,30 +411,32 @@ describe MailyHerald::Sequence do
     it "should be able to override subscription" do
       subscription = @sequence.subscription_for @entity
 
-      subscription.should be_active
+      expect(subscription).to be_active
 
       next_processing = @sequence.next_processing_time(@entity)
 
       subscription.deactivate!
-      subscription.should_not be_active
+      expect(subscription).not_to be_active
 
-      @sequence.logs(@entity).count.should eq(0)
-      @sequence.last_processing_time(@entity).should be_nil
+      expect(@sequence.logs(@entity).count).to eq(0)
+      expect(@sequence.last_processing_time(@entity)).to be_nil
 
       Timecop.freeze next_processing
 
       @sequence.run
 
-      @sequence.logs(@entity).count.should eq(0)
-      @sequence.last_processing_time(@entity).should be_nil
+      expect(@sequence.logs(@entity).count).to eq(0)
+      expect(@sequence.last_processing_time(@entity)).to be_nil
 
       @sequence.update_attribute(:override_subscription, true)
 
       @sequence.run
 
-      @sequence.logs(@entity).count.should eq(1)
-      @sequence.last_processing_time(@entity).to_i.should eq(next_processing.to_i)
+      expect(@sequence.logs(@entity).count).to eq(1)
+      expect(@sequence.last_processing_time(@entity).to_i).to eq(next_processing.to_i)
     end
   end
 
+  pending "unprocessable mailings - postponing them"
+
 end