say_when 0.4.1 → 1.0.0

data/lib/say_when.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'active_support'
 
 require "say_when/version"
@@ -7,25 +9,24 @@ require 'say_when/processor/base'
 require 'say_when/processor/simple'
 require 'say_when/scheduler'
 
-require 'say_when/processor/active_messaging' if defined?(ActiveMessaging)
-
-require 'say_when/storage/active_record/job' if defined?(ActiveRecord)
+require 'say_when/processor/active_messaging' if defined?(::ActiveMessaging)
+require 'say_when/processor/shoryuken' if defined?(::Shoryuken)
+require 'say_when/storage/active_record/job' if defined?(::ActiveRecord)
+require 'say_when/railtie' if defined?(Rails)
 
 module SayWhen
-
   def SayWhen.logger=(logger)
     @@logger = logger
   end
-  
+
   def SayWhen.logger
     if !defined?(@@logger) || !@@logger
       if defined?(Rails.logger) && Rails.logger
         @@logger = Rails.logger
       end
-      
+
       @@logger = Logger.new(STDOUT) unless defined?(@@logger)
     end
     @@logger
   end
-
 end

data/lib/tasks/say_when.rake

@@ -1,2 +1,4 @@
+# encoding: utf-8
+
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
-require 'say_when/tasks'
+require 'say_when/tasks'

data/say_when.gemspec

@@ -1,24 +1,31 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "say_when/version"
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'say_when/version'
 
-Gem::Specification.new do |s|
-  s.name        = "say_when"
-  s.version     = SayWhen::VERSION
-  s.authors     = ["Andrew Kuklewicz"]
-  s.email       = ["andrew@prx.org"]
-  s.homepage    = "http://labs.prx.org"
-  s.summary     = %q{Scheduling system for programmatically defined and stored jobs.}
+Gem::Specification.new do |spec|
+  spec.name          = 'say_when'
+  spec.version       = SayWhen::VERSION
+  spec.authors       = ['Andrew Kuklewicz']
+  spec.email         = ['andrew@beginsinwonder.com']
+  spec.summary       = %q{Scheduling system for programmatically defined and stored jobs.}
+  spec.description   = %q{Scheduling system for programmatically defined and stored jobs.}
+  spec.homepage      = 'https://github.com/kookster/say_when'
+  spec.license       = 'MIT'
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
 
-  s.add_development_dependency "activemessaging", '~> 0.9.0'
-  s.add_development_dependency "activesupport", '~> 2.3.14'
-  s.add_development_dependency "activerecord", '~> 2.3.14'
-  s.add_development_dependency 'rspec', '~> 1.3'
-  s.add_development_dependency 'rake', '~> 10.5.0'
-  s.add_development_dependency 'sqlite3'
+  spec.add_runtime_dependency('activesupport')
+
+  spec.add_development_dependency('activerecord')
+  spec.add_development_dependency('shoryuken')
+  spec.add_development_dependency('activemessaging')
+  spec.add_development_dependency('bundler', '~> 1.3')
+  spec.add_development_dependency('rake')
+  spec.add_development_dependency('minitest')
+  spec.add_development_dependency('simplecov')
+  spec.add_development_dependency('sqlite3')
 end

data/test/active_record_helper.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'active_record'
+require 'sqlite3'
+
+ActiveRecord::Base.logger = Logger.new('/dev/null')
+
+ActiveRecord::Base.establish_connection(
+  adapter:  'sqlite3',
+  database: (File.dirname(__FILE__) + '/db/test.db')
+)
+
+require (File.dirname(__FILE__) + '/db/schema.rb')

data/{spec → test}/db/schema.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 ActiveRecord::Schema.define(:version => 0) do
 
   create_table :say_when_jobs, :force => true do |t|
@@ -18,7 +20,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.string    :job_method
     t.text      :data
 
-    t.timestamps
+    t.timestamps null: false
   end
 
   create_table :say_when_job_executions, :force => true do |t|
@@ -31,8 +33,6 @@ ActiveRecord::Schema.define(:version => 0) do
 
   add_index :say_when_jobs, :status
   add_index :say_when_jobs, :next_fire_at
-  add_index :say_when_jobs, [:next_fire_at, :status]
-  add_index :say_when_jobs, [:last_fire_at, :status]
 
 
-end
+end

data/{spec/spec_helper.rb → test/minitest_helper.rb}

@@ -1,27 +1,17 @@
-ENV['RAILS_ENV']='test'
+# encoding: utf-8
 
-require "rubygems"
-require 'bundler/setup'
-require 'active_support'
-require 'active_record'
-
-require 'spec'
-require 'spec/autorun'
-
-$: << (File.dirname(__FILE__) + "/../lib")
-require "say_when"
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'say_when'
 
-logger = Logger.new(STDOUT)
-logger.level = Logger::ERROR
-SayWhen.logger = logger
-::ActiveRecord::Base.logger = logger
+require 'minitest'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/mock'
+require 'fileutils'
 
 Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
 
-
-Spec::Runner.configure do |config|
-  config.mock_with :rspec
-end
+require 'active_support'
 
 module SayWhen
   module Test

data/test/say_when/cron_expression_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe SayWhen::CronExpression do
+
+  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
+
+  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/{spec/say_when/processor/active_messaging_spec.rb → test/say_when/processor/active_messaging_test.rb}

@@ -1,6 +1,13 @@
-require_relative '../../spec_helper'
-require_relative '../../../lib/say_when/processor/active_messaging'
-require_relative '../../../lib/say_when/storage/active_record/job'
+# encoding: utf-8
+
+require 'minitest_helper'
+
+require 'say_when/processor/active_messaging'
+require 'say_when/storage/active_record/job'
+require 'activemessaging'
+
+ActiveMessaging.logger = Logger.new('/dev/null')
+ActiveMessaging.load_extensions
 
 def destination(destination_name)
   d = ActiveMessaging::Gateway.find_destination(destination_name).value
@@ -11,11 +18,9 @@ describe SayWhen::Processor::ActiveMessaging do
 
   before do
 
-    require 'activemessaging'
+    ActiveMessaging::Gateway.connections['default'] = ActiveMessaging::Gateway.adapters[:test].new({})
 
-    ActiveMessaging::Gateway.stub!(:load_connection_configuration).and_return({:adapter=>:test})
-
-    ActiveMessaging::Gateway.define do |s|    
+    ActiveMessaging::Gateway.define do |s|
       s.destination :say_when, '/queue/SayWhen'
     end
 
@@ -26,12 +31,11 @@ describe SayWhen::Processor::ActiveMessaging do
     @processor = SayWhen::Processor::ActiveMessaging.new(SayWhen::Scheduler.scheduler)
   end
 
-  it "process a job by sending a message" do
-    @job = mock('SayWhen::Storage::ActiveRecord::Job')
-    @job.should_receive(:id).and_return(100)
+  it 'process a job by sending a message' do
+    @job = Minitest::Mock.new
+    @job.expect(:id, 100)
     @processor.process(@job)
-    destination(:say_when).messages.size.should == 1
-    YAML::load(destination(:say_when).messages.first.body)[:job_id].should == 100
+    destination(:say_when).messages.size.must_equal 1
+    YAML::load(destination(:say_when).messages.first.body)[:job_id].must_equal 100
   end
-
 end

data/test/say_when/scheduler_test.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+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
+
+  end
+
+  describe 'instance methods' do
+
+    before(:all) do
+      SayWhen::Scheduler.configure do |scheduler|
+        scheduler.storage_strategy = :memory
+        scheduler.processor_class  = SayWhen::Test::TestProcessor
+      end
+    end
+
+    let (:scheduler) { SayWhen::Scheduler.scheduler }
+
+    it 'should instantiate the processor from its class' do
+      scheduler.processor.must_be_instance_of(SayWhen::Test::TestProcessor)
+    end
+
+    it 'should get the job class based on the strategy' do
+      scheduler.job_class.must_equal SayWhen::Storage::Memory::Job
+    end
+
+    it 'should start the scheduler running, and can stop it' do
+      scheduler.wont_be :running
+
+      scheduler_thread = Thread.start{ scheduler.start }
+      sleep(0.2)
+      scheduler.must_be :running
+
+      scheduler.stop
+      scheduler.wont_be :running
+    end
+  end
+end

data/test/say_when/storage/active_record/job_test.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+require 'minitest_helper'
+require 'active_record_helper'
+require 'say_when/storage/active_record/job'
+
+describe SayWhen::Storage::ActiveRecord::Job 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'
+    }
+  }
+
+  it 'can be instantiated' do
+    j = SayWhen::Storage::ActiveRecord::Job.create!(valid_attributes)
+    j.wont_be_nil
+  end
+
+  it 'can execute the task for the job' do
+    j = SayWhen::Storage::ActiveRecord::Job.create(valid_attributes)
+    j.execute_job( { result: 1 } ).must_equal 1
+  end
+
+  it 'can execute the job' do
+    j = SayWhen::Storage::ActiveRecord::Job.create(valid_attributes)
+    j.execute.must_equal 1
+  end
+
+  it 'derives a trigger from the attributes' do
+    t = SayWhen::Storage::ActiveRecord::Job.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 = SayWhen::Storage::ActiveRecord::Job.create(valid_attributes)
+    t.status.must_equal SayWhen::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 = SayWhen::Storage::ActiveRecord::Job.create(valid_attributes)
+    j.status.must_equal SayWhen::BaseJob::STATE_WAITING
+    j.next_fire_at.must_equal ce.next_fire_at
+  end
+
+  it 'can find the next job' do
+    SayWhen::Storage::ActiveRecord::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 = SayWhen::Storage::ActiveRecord::Job.create(valid_attributes)
+      j2 = SayWhen::Storage::ActiveRecord::Job.create(j2_opts)
+
+      next_job = SayWhen::Storage::ActiveRecord::Job.acquire_next(2.days.since)
+      next_job.must_equal j2
+    end
+  end
+
+  it 'can be fired' do
+    opts = valid_attributes[:trigger_options]
+    ce = SayWhen::CronExpression.new(opts[:expression], opts[:time_zone])
+    j = SayWhen::Storage::ActiveRecord::Job.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
+      j.fired
+      j.next_fire_at.must_equal ce.next_fire_at(now)
+      j.last_fire_at.must_equal now
+      j.status.must_equal SayWhen::BaseJob::STATE_WAITING
+    end
+  end
+end

data/test/say_when/storage/memory/job_test.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'minitest_helper'
+require 'say_when/storage/memory/job'
+
+describe SayWhen::Storage::Memory::Job do
+
+  let(:valid_attributes) {
+    {
+      :name       => 'Memory::Job::Test',
+      :group      => 'Test',
+      :data       => { foo: 'bar', result: 1 },
+      :job_class  => 'SayWhen::Test::TestTask',
+      :job_method => 'execute'
+    }
+  }
+
+  it 'can be instantiated' do
+    j = SayWhen::Storage::Memory::Job.new(valid_attributes)
+    j.wont_be_nil
+  end
+
+  it 'can execute the task for the job' do
+    j = SayWhen::Storage::Memory::Job.new(valid_attributes)
+    j.execute_job( { result: 1 } ).must_equal 1
+  end
+
+  it 'can execute the job' do
+    j = SayWhen::Storage::Memory::Job.new(valid_attributes)
+    j.execute.must_equal 1
+  end
+end

data/test/say_when/storage/memory/trigger_test.rb

@@ -0,0 +1,54 @@
+# require 'minitest_helper'
+# require 'say_when/storage/memory/trigger'
+
+# describe SayWhen::Storage::Memory::Trigger do
+
+#   let(:valid_attributes) {
+#     {
+#       expression: '0 0 12 ? * * *',
+#       time_zone: 'Pacific Time (US & Canada)'
+#     }
+#   }
+
+#   it 'can be instantiated' do
+#     t = SayWhen::Storage::Memory::Trigger.new(@valid_attributes)
+#     t.wont_be_nil
+#   end
+
+#   it 'sets a cron_expression' do
+#     t = SayWhen::Storage::Memory::Trigger.new(@valid_attributes)
+#     t.cron_expression.wont_be_nil
+#     t.cron_expression.expression.must_equal '0 0 12 ? * * *'
+#     t.cron_expression.time_zone.must_equal 'Pacific Time (US & Canada)'
+#   end
+
+#   it 'has a waiting state on instantiate' do
+#     t = SayWhen::Storage::Memory::Trigger.new(@valid_attributes)
+#     t.status.must_equal SayWhen::BaseTrigger::STATE_WAITING
+#   end
+
+#   it 'has a next fire at set on instantiate' do
+#     ce = SayWhen::CronExpression.new(@valid_attributes[:expression], @valid_attributes[:time_zone])
+#     t = SayWhen::Storage::Memory::Trigger.new(@valid_attributes)
+#     t.status.must_equal SayWhen::BaseTrigger::STATE_WAITING
+#     t.next_fire_at.must_equal ce.next_fire_at
+#   end
+
+#   it 'can be fired' do
+#     ce = SayWhen::CronExpression.new(@valid_attributes[:expression], @valid_attributes[:time_zone])
+#     t = SayWhen::Storage::Memory::Trigger.new(@valid_attributes)
+#     nfa = ce.last_fire_at(1.second.ago)
+#     lfa = ce.last_fire_at(nfa - 1.second)
+#     t.next_fire_at = nfa
+#     t.last_fire_at = lfa
+
+#     now = Time.now
+#     Time.stub!(:now).and_return(now)
+
+#     t.fired
+#     t.next_fire_at.must_equal ce.next_fire_at(now)
+#     t.last_fire_at.must_equal now
+#     t.status.must_equal SayWhen::BaseTrigger::STATE_WAITING
+#   end
+
+# end

data/test/say_when/triggers/once_strategy_test.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'minitest_helper'
+require 'say_when/triggers/once_strategy'
+
+describe SayWhen::Triggers::OnceStrategy do
+
+  it 'should be constucted with at option' do
+    time_at = 1.second.ago
+    o = SayWhen::Triggers::OnceStrategy.new({:at=>time_at})
+    o.wont_be_nil
+    o.once_at.must_equal time_at
+  end
+
+  it 'should return once at only once' do
+    time_at = 1.second.ago
+    o = SayWhen::Triggers::OnceStrategy.new({:at=>time_at})
+    o.wont_be_nil
+    o.next_fire_at.must_equal time_at
+    o.next_fire_at(time_at + 10.second).must_be_nil
+    o.next_fire_at(time_at - 10.second).must_equal time_at
+  end
+end

data/{spec → test}/support/models.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'active_support'
 
 class TestModel < Object
@@ -6,13 +8,13 @@ class TestModel < Object
   def initialize(id=nil)
     @id = id
   end
-  
+
   def ==(b)
     return false unless b
     # puts "compare: #{self.class.name}_#{@id} == #{b.class.name}_#{b.id}"
     @id == b.id
   end
-  
+
   class << self
 
     def find(ids=nil)
@@ -28,4 +30,4 @@ end
 
 class Account < TestModel
   attr_accessor :owner
-end
+end