say_when 1.0.0 → 2.0.0

data/test/say_when/configuration_test.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'minitest_helper'
+
+describe SayWhen::Configuration do
+  it 'has default values' do
+    dos = SayWhen::Configuration.default_options
+    dos.wont_be_nil
+    dos[:processor_strategy].must_equal :simple
+    dos[:storage_strategy].must_equal :memory
+    dos[:tick_length].must_equal 5
+    dos[:queue].must_equal "default"
+  end
+end

data/test/say_when/cron_expression_test.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+require 'minitest_helper'
+
+require 'active_support/all'
+require 'say_when/cron_expression'
+
+describe SayWhen::CronExpression do
+
+  it 'should create with defaults' do
+    ce = SayWhen::CronExpression.new
+    ce.expression.must_equal "* * * ? * ? *"
+    ce.time_zone.must_equal Time.zone.try(:name) || "UTC"
+  end
+
+  it 'should set the time_zone' do
+    ce = SayWhen::CronExpression.new("0 0 12 ? * 1#1 *", 'Pacific Time (US & Canada)')
+    ce.time_zone.must_equal 'Pacific Time (US & Canada)'
+  end
+
+  it 'has a pretty to_s' do
+    ce = SayWhen::CronExpression.new("1 1 1 1 1 ? 2000")
+    ce.to_s.must_match(/s:.*/)
+  end
+
+  it 'handles #/# numbers' do
+    ce = SayWhen::CronExpression.new("*/10 1 1 1 1 ? 2000")
+    ce.seconds.values.must_equal([0, 10, 20, 30, 40, 50])
+  end
+
+  it 'handles #,# numbers' do
+    ce = SayWhen::CronExpression.new("1,2 1 1 1 1 ? 2000")
+    ce.seconds.values.must_equal([1, 2])
+  end
+
+  it 'handles #-# numbers' do
+    ce = SayWhen::CronExpression.new("1-3 1 1 1 1 ? 2000")
+    ce.seconds.values.must_equal([1, 2, 3])
+  end
+
+  it 'no values when no match' do
+    ce = SayWhen::CronExpression.new("na 1 1 1 1 ? 2000")
+    ce.seconds.values.must_equal([])
+  end
+
+  it 'handles changes in seconds' do
+    ce = SayWhen::CronExpression.new("1-3 1 1 1 1 ? 2000", "UTC")
+    n = ce.next_fire_at(Time.utc(1999,1,1))
+    n.must_equal Time.parse("Sat, 01 Jan 2000 01:01:01 UTC")
+
+    n = ce.next_fire_at(Time.parse("Sat, 01 Jan 2000 01:00:59 UTC"))
+    n.must_equal(Time.parse("Sat, 01 Jan 2000 01:01:01 UTC"))
+  end
+
+  describe "Day of the month" do
+    it "gets the last day of the month" do
+      ce = SayWhen::CronExpression.new("0 0 0 L 1 ? 2004", 'UTC')
+      ce.next_fire_at(Time.utc(1999,1,1)).must_equal(Time.parse('Sat, 31 Jan 2004 00:00:00 UTC +00:00'))
+    end
+
+    it "gets the last weekday of the month" do
+      ce = SayWhen::CronExpression.new("0 0 0 LW 1 ? 2004", 'UTC')
+      ce.next_fire_at(Time.utc(1999,1,1)).must_equal(Time.parse('Fri, 30 Jan 2004 00:00:00 UTC +00:00'))
+    end
+
+    it "gets a weekday in the month" do
+      ce = SayWhen::CronExpression.new("0 0 0 W 1 ? 2000", 'UTC')
+      ce.next_fire_at(Time.utc(1999,1,1)).must_equal(Time.parse('Mon, 03 Jan 2000 00:00:00 UTC +00:00'))
+    end
+
+    it "gets the closest weekday in the month" do
+      ce = SayWhen::CronExpression.new("0 0 0 1W 1 ? 2000", 'UTC')
+      ce.next_fire_at(Time.utc(1999,1,1)).must_equal(Time.parse('Tue, 03 Jan 2000 00:00:00 UTC +00:00'))
+
+      ce = SayWhen::CronExpression.new("0 0 0 10W 1 ? 2000", 'UTC')
+      ce.next_fire_at(Time.utc(1999,1,1)).must_equal(Time.parse('Mon, 10 Jan 2000 00:00:00 UTC +00:00'))
+    end
+  end
+
+  describe 'get first sunday in the month with "1#1' do
+
+    before do
+      @ce = SayWhen::CronExpression.new("0 0 12 ? * 1#1 *", 'Pacific Time (US & Canada)')
+    end
+
+    it 'finds first sunday in the same month' do
+      @ce.next_fire_at(Time.utc(2008,1,1)).must_equal(Time.parse('2008-01-06 12:00:00 -0800'))
+    end
+
+
+    it 'finds first sunday in the next month' do
+      @ce.next_fire_at(Time.utc(2008,1,7)).must_equal(Time.parse('2008-02-03 12:00:00 -0800'))
+    end
+
+    it 'finds last sunday in the same month' do
+      @ce.last_fire_at(Time.utc(2008,1,10)).must_equal(Time.parse('2008-01-06 12:00:00 -0800'))
+    end
+
+    it 'finds sundays in the prior months and years' do
+      @ce.last_fire_at(Time.utc(2008,1,5)).must_equal Time.parse('2007-12-02 12:00:00 -0800')
+      @ce.last_fire_at(Time.parse('2007-12-02 12:00:00 -0800') - 1.second).must_equal(Time.parse('2007-11-04 12:00:00 -0800'))
+      @ce.last_fire_at(Time.parse('2007-11-04 12:00:00 -0800') - 1.second).must_equal(Time.parse('2007-10-07 12:00:00 -0700'))
+      @ce.next_fire_at(Time.parse('2007-10-07 12:00:00 -0700') + 1.second).must_equal(Time.parse('2007-11-04 12:00:00 -0800'))
+    end
+  end
+
+  describe 'get last sunday in the month with "1L"' do
+    before do
+      @ce = SayWhen::CronExpression.new("0 0 12 ? * 1L *", 'Pacific Time (US & Canada)')
+    end
+
+    it 'gets next final sunday for same month' do
+      @ce.next_fire_at(Time.utc(2008,1,1)).must_equal(Time.parse('2008-01-27 12:00:00 -0800'))
+    end
+
+
+    it 'gets next final sunday for next month' do
+      @ce.next_fire_at(Time.utc(2008,1,28)).must_equal(Time.parse('2008-02-24 12:00:00 -0800'))
+    end
+
+    it 'gets last final sunday for same month' do
+      @ce.last_fire_at(Time.utc(2008,1,28)).must_equal(Time.parse('2008-01-27 12:00:00 -0800'))
+    end
+
+    it 'gets last sunday for prior month and year' do
+      @ce.last_fire_at(Time.utc(2008,1,1)).must_equal(Time.parse('2007-12-30 12:00:00 -0800'))
+    end
+
+
+    it 'gets last sunday for prior month and year' do
+      nfa = @ce.last_fire_at(Time.utc(2007,12,1))
+      nfa.must_equal(Time.parse('2007-11-25 12:00:00 -0800'))
+
+      nfa = @ce.last_fire_at(nfa - 1.second)
+      nfa.must_equal(Time.parse('2007-10-28 12:00:00 -0700'))
+
+      nfa = @ce.next_fire_at(nfa + 1.second)
+      nfa.must_equal(Time.parse('2007-11-25 12:00:00 -0800'))
+    end
+  end
+end

data/test/say_when/poller/base_poller_test.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+require 'minitest_helper'
+require 'say_when/poller/base_poller'
+
+describe SayWhen::Poller::BasePoller do
+
+  class TestPoller; include(SayWhen::Poller::BasePoller); end
+
+  let (:poller) { TestPoller.new }
+  let (:time_now) { Time.now }
+
+  it 'handles errors' do
+    job = Minitest::Mock.new
+    job.expect(:release, true)
+    err = nil
+    begin
+      raise RuntimeError.new('bad')
+    rescue RuntimeError => ex
+      err = ex
+    end
+
+    poller.job_error("oh noes", job, err)
+  end
+
+  it "can acquire a job" do
+    poller.acquire(time_now)
+  end
+
+  it "can process a job" do
+    job = Minitest::Mock.new
+    job.expect(:fired, true, [Object])
+    poller.process(job, time_now)
+  end
+
+  it "can process jobs" do
+    poller.process_jobs
+  end
+
+  it "defines an error tick length" do
+    poller.error_tick_length.must_equal 0
+  end
+end

data/test/say_when/poller/celluloid_poller_test.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+require 'minitest_helper'
+require 'say_when/poller/celluloid_poller'
+
+describe SayWhen::Poller::CelluloidPoller do
+  let (:poller) { SayWhen::Poller::CelluloidPoller.new(100) }
+
+  it 'should instantiate the poller' do
+    poller.tick_length.must_equal 100
+  end
+
+  it 'should start the poller running, and can stop it' do
+    poller.start
+    sleep(0.2)
+    poller.stop
+  end
+end

data/test/say_when/poller/concurrent_poller_test.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'minitest_helper'
+require 'say_when/poller/concurrent_poller'
+
+describe SayWhen::Poller::ConcurrentPoller do
+
+  let (:poller) { SayWhen::Poller::ConcurrentPoller.new(100) }
+
+  it 'should instantiate the poller' do
+    poller.tick_length.must_equal 100
+  end
+
+  it 'should start the poller running, and can stop it' do
+    poller.start
+    sleep(0.2)
+    poller.stop
+  end
+end

data/test/say_when/poller/simple_poller_test.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require 'minitest_helper'
+require 'say_when/poller/simple_poller'
+
+describe SayWhen::Poller::SimplePoller do
+
+  let (:poller) { SayWhen::Poller::SimplePoller.new }
+
+  it 'should instantiate the poller' do
+    poller.wont_be_nil
+  end
+
+  it 'can check if poller is running' do
+    poller.wont_be :running?
+  end
+
+  it 'should start the poller running, and can stop it' do
+    poller.wont_be :running
+
+    Thread.start{ poller.start }
+    sleep(0.2)
+    poller.must_be :running
+
+    poller.stop
+    poller.wont_be :running
+  end
+end

data/test/say_when/processor/active_job_strategy_test.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'minitest_helper'
+require 'active_job'
+require 'say_when/processor/active_job_strategy'
+
+describe SayWhen::Processor::ActiveJobStrategy do
+
+  let(:processor) { SayWhen::Processor::ActiveJobStrategy }
+
+  before {
+    SayWhen::Test::TestTask.reset
+  }
+
+  it 'process a memory stored job' do
+    options = {
+      name:  'Test',
+      group: 'Test',
+      data:  { foo: 'bar', result: 1 },
+      job_class: 'SayWhen::Test::TestTask',
+      job_method: 'execute'
+    }
+
+    SayWhen::Test::TestTask.wont_be :executed?
+
+    job = SayWhen::Storage::MemoryStrategy.create(options)
+    processor.process(job)
+
+    SayWhen::Test::TestTask.must_be :executed?
+  end
+end

data/test/say_when/processor/simple_strategy_test.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'minitest_helper'
+require 'say_when/processor/simple_strategy'
+
+describe SayWhen::Processor::SimpleStrategy do
+
+  let(:processor) { SayWhen::Processor::SimpleStrategy }
+
+  it 'process a job by sending a message' do
+    job = Minitest::Mock.new
+    job.expect(:execute, 'done!')
+    processor.process(job).must_equal 'done!'
+  end
+end

data/test/say_when/scheduler_test.rb

@@ -4,72 +4,56 @@ require 'minitest_helper'
 
 describe SayWhen::Scheduler do
 
-  before {
-    SayWhen::logger = Logger.new('/dev/null')
-  }
-
-  describe 'class methods' do
-
-    it 'can return singleton' do
-      s = SayWhen::Scheduler.scheduler
-      s.wont_be_nil
-      s.must_equal SayWhen::Scheduler.scheduler
-    end
-
-    it 'can be configured' do
-      SayWhen::Scheduler.configure do |scheduler|
-        scheduler.storage_strategy = :memory
-        scheduler.processor_class  = SayWhen::Test::TestProcessor
-      end
-      SayWhen::Scheduler.scheduler.storage_strategy.must_equal :memory
-      SayWhen::Scheduler.scheduler.processor_class.must_equal SayWhen::Test::TestProcessor
-    end
-
-    it 'can schedule a new job' do
-      SayWhen::Scheduler.configure do |scheduler|
-        scheduler.storage_strategy = :memory
-        scheduler.processor_class  = SayWhen::Test::TestProcessor
-      end
-
-      job = SayWhen::Scheduler.schedule(
-        trigger_strategy: 'once',
-        trigger_options: { at: 10.second.since },
-        job_class: 'SayWhen::Test::TestTask',
-        job_method: 'execute'
-      )
-      job.wont_be_nil
-    end
+  let (:scheduler) { SayWhen::Scheduler.new }
 
+  it 'has a logger' do
+    scheduler.logger.must_be_instance_of Logger
   end
 
-  describe 'instance methods' do
+  it 'extracts data' do
+    scheduler.extract_data({}).must_be_nil
+    scheduler.extract_data(data: 'data').must_equal 'data'
+  end
 
-    before(:all) do
-      SayWhen::Scheduler.configure do |scheduler|
-        scheduler.storage_strategy = :memory
-        scheduler.processor_class  = SayWhen::Test::TestProcessor
-      end
-    end
+  it 'extracts job method' do
+    scheduler.extract_job_method({}).must_equal 'execute'
+    scheduler.extract_job_method(job_method: 'just_doit').must_equal 'just_doit'
+    scheduler.extract_job_method(method: 'doit').must_equal 'doit'
+  end
 
-    let (:scheduler) { SayWhen::Scheduler.scheduler }
+  it 'extracts job class' do
+    scheduler.extract_job_class(job_class: 'foo').must_equal 'foo'
+    scheduler.extract_job_class(class: 'foo').must_equal 'foo'
+    scheduler.extract_job_class(SayWhen::Test::TestTask).must_equal 'SayWhen::Test::TestTask'
+    scheduler.extract_job_class('SayWhen::Test::TestTask').must_equal 'SayWhen::Test::TestTask'
 
-    it 'should instantiate the processor from its class' do
-      scheduler.processor.must_be_instance_of(SayWhen::Test::TestProcessor)
-    end
+    lambda do
+      scheduler.extract_job_class(bar: 'foo')
+    end.must_raise RuntimeError
+  end
 
-    it 'should get the job class based on the strategy' do
-      scheduler.job_class.must_equal SayWhen::Storage::Memory::Job
-    end
+  it 'gets job options' do
+    keys = [:job_class, :job_method, :data]
+    opts = scheduler.job_options(keys.inject({}) { |s, k| s[k] = k.to_s; s } )
+    keys.each{|k| opts[k].must_equal k.to_s }
+  end
 
-    it 'should start the scheduler running, and can stop it' do
-      scheduler.wont_be :running
+  it 'can schedule a new job' do
+    job = scheduler.schedule(
+      trigger_strategy: 'once',
+      trigger_options: { at: 10.second.since },
+      job_class: 'SayWhen::Test::TestTask',
+      job_method: 'execute'
+    )
+    job.wont_be_nil
+  end
 
-      scheduler_thread = Thread.start{ scheduler.start }
-      sleep(0.2)
-      scheduler.must_be :running
+  it 'can schedule a cron job' do
+    job = scheduler.schedule_cron("0 0 12 ? * * *", SayWhen::Test::TestTask)
+    job.wont_be_nil
+  end
 
-      scheduler.stop
-      scheduler.wont_be :running
-    end
+  it 'should provide the storage strategy' do
+    scheduler.storage.must_equal SayWhen::Storage::MemoryStrategy
   end
 end

data/test/say_when/storage/active_record_strategy_test.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+require 'minitest_helper'
+require 'active_record_helper'
+require 'say_when/storage/active_record_strategy'
+
+describe SayWhen::Storage::ActiveRecordStrategy do
+  let(:valid_attributes) {
+    {
+      trigger_strategy: :cron,
+      trigger_options: { expression: '0 0 12 ? * * *', time_zone: 'Pacific Time (US & Canada)' },
+      data:            { foo: 'bar', result: 1 },
+      job_class:       'SayWhen::Test::TestTask',
+      job_method:      'execute'
+    }
+  }
+
+  let(:strategy) { SayWhen::Storage::ActiveRecordStrategy }
+
+  let(:job) { strategy.create(valid_attributes) }
+
+  it 'job can be created' do
+    j = strategy.create(valid_attributes)
+    j.wont_be_nil
+  end
+
+  it 'job can be serialized' do
+    strategy.serialize(job).must_equal job
+    strategy.deserialize(job).must_equal job
+  end
+
+  it 'can execute the task for the job' do
+    job.execute_job( { result: 1 } ).must_equal 1
+  end
+
+  it 'can execute the job' do
+    j = strategy.create(valid_attributes)
+    j.execute.must_equal 1
+  end
+
+  it 'derives a trigger from the attributes' do
+    t = strategy.create(valid_attributes)
+    t.trigger.wont_be_nil
+    t.trigger.must_be_instance_of SayWhen::Triggers::CronStrategy
+  end
+
+  it 'has a waiting state on create' do
+    t = strategy.create(valid_attributes)
+    t.status.must_equal SayWhen::Storage::BaseJob::STATE_WAITING
+  end
+
+  it 'has a next fire at set on create' do
+    opts = valid_attributes[:trigger_options]
+    ce = SayWhen::CronExpression.new(opts[:expression], opts[:time_zone])
+    j = strategy.create(valid_attributes)
+    j.status.must_equal SayWhen::Storage::BaseJob::STATE_WAITING
+    j.next_fire_at.must_equal ce.next_fire_at
+  end
+
+  it 'can acquire and release the next job' do
+    SayWhen::Storage::ActiveRecordStrategy::Job.delete_all
+
+    j2_opts = {
+      trigger_strategy: :cron,
+      trigger_options:  { expression: '0 0 10 ? * * *', time_zone: 'Pacific Time (US & Canada)' },
+      data:             { foo: 'bar', result: 2 },
+      job_class:        'SayWhen::Test::TestTask',
+      job_method:       'execute'
+    }
+
+    now = Time.now.change(hour: 0)
+    Time.stub(:now, now) do
+      j1 = strategy.create(valid_attributes)
+      j1.wont_be_nil
+      j2 = strategy.create(j2_opts)
+
+      next_job = strategy.acquire_next(2.days.since)
+      next_job.status.must_equal "acquired"
+      next_job.must_equal j2
+      strategy.release(next_job)
+      next_job.status.must_equal "waiting"
+    end
+  end
+
+  it 'resets acquired jobs' do
+    old = 2.hours.ago
+    j = strategy.create(valid_attributes)
+    j.update_attributes(status: 'acquired', updated_at: old, created_at: old)
+
+    j.status.must_equal 'acquired'
+
+    strategy.reset_acquired(3600)
+
+    j.reload
+    j.status.must_equal 'waiting'
+  end
+
+  it 'can be fired' do
+    opts = valid_attributes[:trigger_options]
+    ce = SayWhen::CronExpression.new(opts[:expression], opts[:time_zone])
+    j = strategy.create(valid_attributes)
+    nfa = ce.last_fire_at(j.created_at - 1.second)
+    lfa = ce.last_fire_at(nfa - 1.second)
+    j.next_fire_at = nfa
+    j.last_fire_at = lfa
+
+    now = Time.now
+    Time.stub(:now, now) do
+      strategy.fired(j, now)
+      j.next_fire_at.must_equal ce.next_fire_at(now)
+      j.last_fire_at.must_equal now
+      j.status.must_equal SayWhen::Storage::BaseJob::STATE_WAITING
+    end
+  end
+
+  describe "acts_as_scheduled" do
+    it "acts_as_scheduled calls has_many" do
+      SayWhen::Test::TestActsAsScheduled.must_be :has_many_called?
+    end
+
+    it "includes schedule methods" do
+      taas = SayWhen::Test::TestActsAsScheduled.new
+      [:schedule, :schedule_instance, :schedule_cron, :schedule_once, :schedule_in].each do |m|
+        taas.respond_to?(m).must_equal true
+      end
+    end
+
+    it "sets the scheduled value" do
+      taas = SayWhen::Test::TestActsAsScheduled.new
+      job = taas.set_scheduled({})
+      job[:scheduled].must_equal taas
+    end
+  end
+end