maily_herald 0.8.0 → 0.9.1

data/spec/mailers/maily_herald/mailer_spec.rb

@@ -3,36 +3,43 @@ require 'spec_helper'
 describe MailyHerald::Mailer do
   before(:each) do
     @entity = FactoryGirl.create :user
-    @mailing = MailyHerald.dispatch(:sample_mail)
+    @mailing = MailyHerald.dispatch(:ad_hoc_mail)
     @list = @mailing.list
   end
 
-  describe "without subscription" do
+  context "without subscription" do
     it "should not deliver" do
-      MailyHerald::Log.delivered.count.should eq(0)
+      expect(MailyHerald::Log.delivered.count).to eq(0)
 
-      TestMailer.sample_mail(@entity).deliver
+      AdHocMailer.ad_hoc_mail(@entity).deliver
 
-      MailyHerald::Log.delivered.count.should eq(0)
+      expect(MailyHerald::Log.delivered.count).to eq(0)
     end
   end
 
-  describe "with subscription" do
+  context "with subscription" do
     before(:each) do
       @list.subscribe! @entity
     end
 
     it "should deliver" do
-      MailyHerald::Log.delivered.count.should eq(0)
+      expect(MailyHerald::Log.delivered.count).to eq(0)
 
-      TestMailer.sample_mail(@entity).deliver
+      AdHocMailer.ad_hoc_mail(@entity).deliver
 
-      MailyHerald::Log.delivered.count.should eq(1)
+      expect(MailyHerald::Log.delivered.count).to eq(1)
     end
   end
 
-  # missing mailers are how handled silently (bypassing Maily)
-  #it "should handle missing mailer" do
-    #expect { TestMailer.sample_mail_error(@entity).deliver }.to raise_error
-  #end
+  context "without defined mailing" do
+    it "should not deliver" do
+      expect do
+        expect(MailyHerald::Log.delivered.count).to eq(0)
+
+        AdHocMailer.missing_mailing_mail(@entity).deliver
+
+        expect(MailyHerald::Log.delivered.count).to eq(0)
+      end.not_to change { ActionMailer::Base.deliveries.count }
+    end
+  end
 end

data/spec/models/maily_herald/ad_hoc_mailing_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe MailyHerald::AdHocMailing do
+  before(:each) do
+    @entity = FactoryGirl.create :user
+
+    @list = MailyHerald.list(:generic_list)
+    expect(@list.context).to be_a(MailyHerald::Context)
+  end
+
+  describe "with subscription" do
+    before(:each) do
+      @list.subscribe!(@entity)
+    end
+
+    describe "run all delivery" do
+      before(:each) do
+        @mailing = MailyHerald.ad_hoc_mailing(:ad_hoc_mail)
+        expect(@mailing).to be_kind_of(MailyHerald::AdHocMailing)
+        expect(@mailing).not_to be_a_new_record
+      end
+
+      it "should not be delivered without explicit scheduling" do
+        expect(MailyHerald::Subscription.count).to eq(1)
+        expect(@mailing.conditions_met?(@entity)).to be_truthy
+        expect(@mailing.processable?(@entity)).to be_truthy
+
+        expect(@mailing.logs.scheduled.count).to eq(0)
+        expect(@mailing.logs.processed.count).to eq(0)
+
+        @mailing.run
+
+        expect(@mailing.logs.scheduled.count).to eq(0)
+        expect(@mailing.logs.processed.count).to eq(0)
+      end
+
+      it "should be delivered" do
+        subscription = @mailing.subscription_for(@entity)
+
+        expect(MailyHerald::Subscription.count).to eq(1)
+        expect(MailyHerald::Log.delivered.count).to eq(0)
+
+        expect(subscription).to be_kind_of(MailyHerald::Subscription)
+
+        expect(@mailing.conditions_met?(@entity)).to be_truthy
+        expect(@mailing.processable?(@entity)).to be_truthy
+
+        @mailing.schedule_delivery_to_all Time.now - 5
+
+        ret = @mailing.run
+        expect(ret).to be_kind_of(Array)
+        expect(ret.first).to be_kind_of(MailyHerald::Log)
+        expect(ret.first).to be_delivered
+        expect(ret.first.mail).to be_kind_of(Mail::Message)
+
+        expect(MailyHerald::Subscription.count).to eq(1)
+        expect(MailyHerald::Log.delivered.count).to eq(1)
+
+        log = MailyHerald::Log.delivered.first
+        expect(log.entity).to eq(@entity)
+        expect(log.mailing).to eq(@mailing)
+        expect(log.entity_email).to eq(@entity.email)
+      end
+    end
+
+    describe "single entity delivery" do
+      before(:each) do
+        @mailing = MailyHerald.ad_hoc_mailing(:ad_hoc_mail)
+        expect(@mailing).to be_kind_of(MailyHerald::AdHocMailing)
+        expect(@mailing).not_to be_a_new_record
+      end
+
+      context "without explicit scheduling" do
+        it "should be delivered using Mailer deliver method" do
+          MailyHerald::Log.delivered.count.should eq(0)
+          msg = AdHocMailer.ad_hoc_mail(@entity).deliver
+          msg.should be_a(Mail::Message)
+          MailyHerald::Log.delivered.count.should eq(1)
+          expect(MailyHerald::Log.delivered.first.entity).to eq(@entity)
+        end
+      end
+
+      context "with explicit scheduling" do
+        it "should be delivered" do
+          MailyHerald::Log.delivered.count.should eq(0)
+
+          @mailing.schedule_delivery_to @entity, Time.now - 5
+
+          msg = AdHocMailer.ad_hoc_mail(@entity).deliver
+
+          expect(msg).to be_kind_of(Mail::Message)
+          MailyHerald::Log.delivered.count.should eq(1)
+        end
+
+        it "should not be delivered if subscription inactive" do
+          @mailing.schedule_delivery_to @entity, Time.now - 5
+
+          @list.unsubscribe!(@entity)
+
+          expect(MailyHerald::Log.delivered.count).to eq(0)
+
+          AdHocMailer.ad_hoc_mail(@entity).deliver
+
+          expect(MailyHerald::Log.delivered.count).to eq(0)
+        end
+      end
+    end
+
+    describe "with entity outside the scope" do
+      before(:each) do
+        @mailing = MailyHerald.ad_hoc_mailing(:ad_hoc_mail)
+      end
+
+      it "should not process mailings" do
+        expect(@list.context.scope).to include(@entity)
+        expect(@mailing).to be_processable(@entity)
+        expect(@mailing).to be_enabled
+
+        @entity.update_attribute(:active, false)
+
+        expect(@list.context.scope).not_to include(@entity)
+        expect(@list).to be_subscribed(@entity)
+
+        expect(@mailing).not_to be_processable(@entity)
+      end
+    end
+  end
+
+  describe "with subscription override" do
+    before(:each) do
+      @mailing = MailyHerald.ad_hoc_mailing(:ad_hoc_mail)
+      @mailing.update_attribute(:override_subscription, true)
+    end
+
+    after(:each) do
+      @mailing.update_attribute(:override_subscription, false)
+    end
+
+    it "single mail should be delivered" do
+      MailyHerald::Log.delivered.count.should eq(0)
+      @mailing.processable?(@entity).should be_truthy
+      @mailing.override_subscription?.should be_truthy
+      @mailing.enabled?.should be_truthy
+
+      @mailing.schedule_delivery_to @entity, Time.now - 5
+
+      msg = AdHocMailer.ad_hoc_mail(@entity).deliver
+      msg.should be_a(Mail::Message)
+
+      MailyHerald::Log.delivered.count.should eq(1)
+    end
+  end
+
+  describe "preview" do
+    before(:each) do
+      @mailing = MailyHerald.ad_hoc_mailing(:ad_hoc_mail)
+      @list.subscribe!(@entity)
+    end
+
+    it "should not deliver" do
+      expect(@mailing.logs).to be_empty
+
+      mail = @mailing.build_mail @entity
+      @mailing.reload
+
+      expect(@mailing.logs).to be_empty
+    end
+  end
+end

data/spec/models/maily_herald/list_spec.rb

@@ -54,8 +54,9 @@ describe MailyHerald::List do
   end
 
   it "should be lockable" do
-    @list = MailyHerald.list :locked_list
+    @list = MailyHerald.list :generic_list
     expect(@list).to be_locked
+    @list.title = "foo"
     expect(@list.save).to be_falsy
     expect(@list.errors.messages).to include(:base)
     @list.destroy

data/spec/models/maily_herald/log_spec.rb

@@ -9,14 +9,14 @@ describe MailyHerald::Log do
   describe "Associations" do
     it "should have proper scopes" do
       log = MailyHerald::Log.create_for @mailing, @entity, {status: :delivered}
-      log.should be_valid
-      log.entity.should eq(@entity)
-      log.mailing.should eq(@mailing)
+      expect(log).to be_valid
+      expect(log.entity).to eq(@entity)
+      expect(log.mailing).to eq(@mailing)
 
-      MailyHerald::Log.for_entity(@entity).should include(log)
-      MailyHerald::Log.for_mailing(@mailing).should include(log)
+      expect(MailyHerald::Log.for_entity(@entity)).to include(log)
+      expect(MailyHerald::Log.for_mailing(@mailing)).to include(log)
 
-      MailyHerald::Log.for_entity(@entity).for_mailing(@mailing).last.should eq(log)
+      expect(MailyHerald::Log.for_entity(@entity).for_mailing(@mailing).last).to eq(log)
     end
   end
 
@@ -26,11 +26,11 @@ describe MailyHerald::Log do
     expect(MailyHerald::Log.count).to eq(2)
 
     log1.update_attribute(:status, :skipped)
-    MailyHerald::Log.count.should eq(2)
-    MailyHerald::Log.skipped.count.should eq(1)
+    expect(MailyHerald::Log.count).to eq(2)
+    expect(MailyHerald::Log.skipped.count).to eq(1)
 
     log1.update_attribute(:status, :error)
-    MailyHerald::Log.count.should eq(2)
-    MailyHerald::Log.error.count.should eq(1)
+    expect(MailyHerald::Log.count).to eq(2)
+    expect(MailyHerald::Log.error.count).to eq(1)
   end
 end

data/spec/models/maily_herald/mailing_spec.rb

@@ -4,20 +4,20 @@ describe MailyHerald::Mailing do
   describe "Validations" do
     it "should validate template syntax" do
       @mailing = MailyHerald.one_time_mailing :test_mailing
-      @mailing.should be_valid
+      expect(@mailing).to be_valid
       @mailing.template = "foo {{ bar"
-      @mailing.should_not be_valid
-      @mailing.errors.messages.keys.should include(:template)
-      @mailing.errors.messages[:template].should_not be_empty
+      expect(@mailing).not_to be_valid
+      expect(@mailing.errors.messages.keys).to include(:template)
+      expect(@mailing.errors.messages[:template]).not_to be_empty
     end
 
     it "should validate conditions syntax" do
       @mailing = MailyHerald.one_time_mailing :test_mailing
-      @mailing.should be_valid
+      expect(@mailing).to be_valid
       @mailing.conditions = "foo {{ bar"
-      @mailing.should_not be_valid
-      @mailing.errors.messages.keys.should include(:conditions)
-      @mailing.errors.messages[:conditions].should_not be_empty
+      expect(@mailing).not_to be_valid
+      expect(@mailing.errors.messages.keys).to include(:conditions)
+      expect(@mailing.errors.messages[:conditions]).not_to be_empty
     end
   end
   
@@ -25,6 +25,7 @@ describe MailyHerald::Mailing do
     it "should produce valiadtion errors" do
       @mailing = MailyHerald.dispatch :locked_mailing
       expect(@mailing).to be_locked
+      @mailing.title = "foo"
       expect(@mailing.save).to be_falsy
       expect(@mailing.errors.messages).to include(:base)
       @mailing.destroy

data/spec/models/maily_herald/one_time_mailing_spec.rb

@@ -8,6 +8,10 @@ describe MailyHerald::OneTimeMailing do
     expect(@list.context).to be_a(MailyHerald::Context)
   end
 
+  after(:all) do
+    Timecop.return
+  end
+
   describe "with subscription" do
     before(:each) do
       @list.subscribe!(@entity)
@@ -16,8 +20,30 @@ describe MailyHerald::OneTimeMailing do
     describe "run all delivery" do
       before(:each) do
         @mailing = MailyHerald.one_time_mailing(:test_mailing)
-        @mailing.should be_a MailyHerald::OneTimeMailing
-        @mailing.should_not be_a_new_record
+        expect(@mailing).to be_kind_of(MailyHerald::OneTimeMailing)
+        expect(@mailing).not_to be_a_new_record
+        expect(@mailing).to be_valid
+      end
+
+      it "should be delivered only once per user" do
+        subscription = @mailing.subscription_for(@entity)
+
+        expect(@mailing.logs.scheduled.count).to eq(1)
+        expect(@mailing.schedules.for_entity(@entity).count).to eq(1)
+
+        ret = @mailing.run
+
+        expect(@mailing.logs.processed.for_entity(@entity).count).to eq(1)
+        expect(@mailing.schedules.for_entity(@entity).count).to eq(0)
+
+        @mailing.set_schedules
+
+        expect(@mailing.schedules.for_entity(@entity).count).to eq(0)
+
+        ret = @mailing.run
+
+        expect(@mailing.logs.processed.for_entity(@entity).count).to eq(1)
+        expect(@mailing.schedules.for_entity(@entity).count).to eq(0)
       end
 
       it "should be delivered" do
@@ -25,46 +51,54 @@ describe MailyHerald::OneTimeMailing do
 
         expect(MailyHerald::Subscription.count).to eq(1)
         expect(MailyHerald::Log.delivered.count).to eq(0)
+        expect(@mailing.logs.scheduled.count).to eq(1)
 
-        subscription.should be_kind_of(MailyHerald::Subscription)
+        expect(subscription).to be_kind_of(MailyHerald::Subscription)
 
-        @mailing.conditions_met?(@entity).should be_truthy
-        @mailing.processable?(@entity).should be_truthy
-        @mailing.mailer_name.should eq(:generic)
+        expect(@mailing.conditions_met?(@entity)).to be_truthy
+        expect(@mailing.processable?(@entity)).to be_truthy
+        expect(@mailing.mailer_name).to eq(:generic)
 
         ret = @mailing.run
-        ret.should be_a(Array)
-        ret.first.should be_a(Mail::Message)
+        expect(ret).to be_kind_of(Array)
+        expect(ret.first).to be_kind_of(MailyHerald::Log)
+        expect(ret.first).to be_delivered
+        expect(ret.first.mail).to be_kind_of(Mail::Message)
 
-        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)
 
         log = MailyHerald::Log.delivered.first
-        log.entity.should eq(@entity)
-        log.mailing.should eq(@mailing)
-        log.entity_email.should eq(@entity.email)
+        expect(log.entity).to eq(@entity)
+        expect(log.mailing).to eq(@mailing)
+        expect(log.entity_email).to eq(@entity.email)
+      end
+
+      it "should handle template errors" do
+        MailyHerald::Log.delivered.count.should eq(0)
+
+        @mailing = MailyHerald.dispatch(:mail_with_error)
+        schedule = @mailing.schedule_for(@entity)
+        expect(schedule).to be_a(MailyHerald::Log)
+        expect(schedule.processing_at).to be <= Time.now
+
+        @mailing.run
+
+        schedule.reload
+        expect(schedule).to be_error
       end
     end
 
     describe "single entity delivery" do
-      before(:each) do
-        @mailing = MailyHerald.one_time_mailing(:test_mailing)
-        @mailing.should be_a MailyHerald::OneTimeMailing
-        @mailing.should_not be_a_new_record
-      end
+      it "should not be possible via Mailer" do
+        expect(MailyHerald::Log.delivered.count).to eq(0)
 
-      it "should be delivered" do
-        MailyHerald::Log.delivered.count.should eq(0)
-        msg = TestMailer.sample_mail(@entity).deliver
-        msg.should be_a(Mail::Message)
-        MailyHerald::Log.delivered.count.should eq(1)
-      end
+        schedule = MailyHerald.dispatch(:one_time_mail).schedule_for(@entity)
+        schedule.update_attribute(:processing_at, Time.now + 1.day)
 
-      it "should not be delivered if subscription inactive" do
-        @list.unsubscribe!(@entity)
-        MailyHerald::Log.delivered.count.should eq(0)
-        TestMailer.sample_mail(@entity).deliver
-        MailyHerald::Log.delivered.count.should eq(0)
+        expect{ CustomOneTimeMailer.one_time_mail(@entity).deliver }.not_to change{ActionMailer::Base.deliveries.count}
+
+        expect(MailyHerald::Log.delivered.count).to eq(0)
       end
     end
 
@@ -73,7 +107,7 @@ describe MailyHerald::OneTimeMailing do
         @mailing = MailyHerald.one_time_mailing(:test_mailing)
       end
 
-      it "should not process mailings" do
+      it "should not process mailings, postpone them and finally skip them" do
         expect(@list.context.scope).to include(@entity)
         expect(@mailing).to be_processable(@entity)
         expect(@mailing).to be_enabled
@@ -84,13 +118,51 @@ describe MailyHerald::OneTimeMailing do
         expect(@list).to be_subscribed(@entity)
 
         expect(@mailing).not_to be_processable(@entity)
+
+        schedule = @mailing.schedule_for(@entity)
+        processing_at = schedule.processing_at
+        expect(schedule).not_to be_nil
+        expect(schedule.processing_at).to be <= Time.now
+        
+        @mailing.run
+
+        schedule.reload
+        expect(schedule).to be_scheduled
+        expect(schedule.processing_at.to_i).to eq((Time.now + 1.day).to_i)
+        expect(schedule.data[:original_processing_at]).to eq(processing_at)
+        expect(schedule.data[:delivery_attempts].length).to eq(1)
+
+        Timecop.freeze schedule.processing_at + 1
+
+        @mailing.run
+
+        schedule.reload
+        expect(schedule).to be_scheduled
+        expect(schedule.data[:delivery_attempts].length).to eq(2)
+
+        Timecop.freeze schedule.processing_at + 1
+
+        @mailing.run
+
+        schedule.reload
+        expect(schedule).to be_scheduled
+        expect(schedule.data[:delivery_attempts].length).to eq(3)
+
+        Timecop.freeze schedule.processing_at + 1
+
+        @mailing.run
+
+        schedule.reload
+        expect(schedule).to be_skipped
+        expect(schedule.data[:delivery_attempts].length).to eq(3)
+        expect(schedule.data[:skip_reason]).to eq(:not_in_scope)
       end
     end
   end
 
   describe "with subscription override" do
     before(:each) do
-      @mailing = MailyHerald.one_time_mailing(:sample_mail)
+      @mailing = MailyHerald.one_time_mailing(:one_time_mail)
       @mailing.update_attribute(:override_subscription, true)
     end
 
@@ -98,15 +170,116 @@ describe MailyHerald::OneTimeMailing do
       @mailing.update_attribute(:override_subscription, false)
     end
 
-    it "single mail should be delivered" do
-      MailyHerald::Log.delivered.count.should eq(0)
-      @mailing.processable?(@entity).should be_truthy
-      @mailing.override_subscription?.should be_truthy
-      @mailing.enabled?.should be_truthy
-      msg = TestMailer.sample_mail(@entity).deliver
-      msg.should be_a(Mail::Message)
-      MailyHerald::Log.delivered.count.should eq(1)
+    it "should deliver single mail" do
+      expect(MailyHerald::Log.delivered.count).to eq(0)
+      expect(@mailing.processable?(@entity)).to be_truthy
+      expect(@mailing.override_subscription?).to be_truthy
+      expect(@mailing.enabled?).to be_truthy
+      @mailing.run
+      expect(MailyHerald::Log.delivered.count).to eq(1)
     end
   end
 
+  describe "with block start_at" do
+    before(:each) do
+      @mailing = MailyHerald::OneTimeMailing.new
+      @mailing.title = "Foobar"
+      @mailing.subject = "Foo"
+      @mailing.template = "Sample template"
+      @mailing.list = @list
+      @mailing.start_at = Proc.new{|user| user.created_at + 1.hour}
+      @mailing.enable
+      @mailing.save!
+    end
+
+    after(:each) do
+      @mailing.destroy
+    end
+
+    it "should be delivered" do
+      expect(@mailing.has_start_at_proc?).to be_truthy
+
+      expect(@mailing.processed_logs(@entity).count).to eq(0)
+      expect(@mailing.schedules.for_entity(@entity).count).to eq(0)
+
+      @list.subscribe!(@entity)
+
+      expect(@list.subscription_for(@entity)).to be_a(MailyHerald::Subscription)
+      expect(@list.subscription_for(@entity)).to be_active
+      expect(@list.subscribed?(@entity)).to be_truthy
+
+      # automatic schedule updater should be triggered
+      expect(@mailing.schedules.for_entity(@entity).count).to eq(1)
+      expect(@mailing.schedules.for_entity(@entity).last.processing_at.to_i).to eq((@entity.created_at + 1.hour).to_i)
+
+      # manually setting schedules should not change anything now
+      @mailing.set_schedules
+
+      expect(@mailing.schedules.for_entity(@entity).count).to eq(1)
+      expect(@mailing.schedules.for_entity(@entity).last.processing_at.to_i).to eq((@entity.created_at + 1.hour).to_i)
+    end
+  end
+
+  describe "with block conditions" do
+    before(:each) do
+      @mailing = MailyHerald::OneTimeMailing.new
+      @mailing.title = "Foobar"
+      @mailing.subject = "Foo"
+      @mailing.template = "Sample template"
+      @mailing.list = @list
+      @mailing.start_at = "user.created_at"
+      @mailing.conditions = Proc.new {|user| user.weekly_notifications}
+      @mailing.enable
+      @mailing.save!
+    end
+
+    after(:each) do
+      @mailing.destroy
+      @entity.reload
+      @entity.update_attribute(:weekly_notifications, true)
+    end
+
+    it "should deliver when positive" do
+      expect(@mailing.has_conditions_proc?).to be_truthy
+
+      @list.subscribe!(@entity)
+      @mailing.set_schedules
+
+      expect(@mailing.schedules.for_entity(@entity).count).to eq(1)
+
+      schedule = @mailing.schedules.for_entity(@entity).last
+
+      expect(schedule.processing_at.to_i).to eq(@entity.created_at.to_i)
+      expect(@entity.weekly_notifications).to be_truthy
+      expect(@mailing.conditions_met?(@entity)).to be_truthy
+
+      @mailing.run
+
+      schedule.reload
+      expect(schedule.status).to eq(:delivered)
+    end
+
+    it "should skip when negative" do
+      expect(@mailing.has_conditions_proc?).to be_truthy
+
+      @list.subscribe!(@entity)
+      @mailing.set_schedules
+
+      expect(@mailing.schedules.for_entity(@entity).count).to eq(1)
+
+      schedule = @mailing.schedules.for_entity(@entity).last
+
+      expect(schedule.processing_at.to_i).to eq(@entity.created_at.to_i)
+
+      @entity.update_attribute(:weekly_notifications, false)
+
+      expect(@entity.weekly_notifications).to be_falsey
+      expect(@mailing.conditions_met?(@entity)).to be_falsey
+
+      @mailing.run
+
+      schedule.reload
+      expect(schedule.status).to eq(:skipped)
+    end
+  end
 end