say_when 2.2.0 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a15986d3be49bd5a4df5bfba2efb10a6e87bb385dae3db7302a26998f6cc784
-  data.tar.gz: fd26b203f07e779d0f663c0650efe525f337ceb3567fdcc73aa8512bca42247f
+  metadata.gz: e4684a6afb159599fe11378e88e25603cfd413755d394f3ee42e026cb4aa33f4
+  data.tar.gz: 3f75b45a4c7ccb1fd73ccadad6130d6ab76abcc304d18215024cef43cefe9f7c
 SHA512:
-  metadata.gz: 25b2394bb39c4ed8fcd0955ecc17dba6c1c45caabfb5b3c0703e58f941adc7661356c2a103a315d5baa740fa6142ac6519eacda35ac062b9f4498607de9eeef4
-  data.tar.gz: 128ca1ff31b19f594075e1a671f321f8f62aad440d2708afeb6d727179b6909eaac085acbcac6129c7e5f2f3e59632b167577699aefacd0f5d87b38a86f554cc
+  metadata.gz: 20be0b65e7e8536266c9ce8db6fd5b0795c2b38f2bd34802026d446e1d7ea0c0943b936c46b3214af72b0f3afeb3e2580b84773bfaccf5e0678a0c45f746de52
+  data.tar.gz: d93ce5845a287e45f97edb54ef4ec8723495710b009567c340eec8ebeb9fe3ee047f163c341661641e8ae5f6f0c389e1ca5f842f0d2c4510f7b21b098e2349bb

data/.gitignore

@@ -13,5 +13,5 @@
 *.gem
 *.DS_Store
 .ruby-version
-test/db/test.db
+test/db/*
 notes.md

data/lib/say_when/storage/active_record_strategy.rb

@@ -44,10 +44,10 @@ module SayWhen
 
         self.table_name = "#{SayWhen.options[:table_prefix]}say_when_jobs"
 
-        serialize :trigger_options
-        serialize :data
+        serialize :trigger_options, coder: YAML
+        serialize :data, coder: YAML
 
-        belongs_to :scheduled, polymorphic: true
+        belongs_to :scheduled, polymorphic: true, optional: true
         has_many :job_executions, class_name: 'SayWhen::Storage::ActiveRecordStrategy::JobExecution'
 
         before_create :set_defaults
@@ -73,10 +73,10 @@ module SayWhen
             SayWhen::Storage::ActiveRecordStrategy::Job.transaction do
               # select and lock the next job that needs executing (status waiting, and after no_later_than)
               next_job = where(status: STATE_WAITING)
-                        .where('next_fire_at < ?', no_later_than)
-                        .order(next_fire_at: 'asc')
-                        .lock(true)
-                        .first
+                         .where('next_fire_at < ?', no_later_than)
+                         .order(next_fire_at: 'asc')
+                         .lock(true)
+                         .first
 
               # set status to acquired to take it out of rotation
               next_job&.update_attribute(:status, STATE_ACQUIRED)
@@ -93,7 +93,9 @@ module SayWhen
         end
 
         def self.check_connection
-          if ActiveRecord::Base.respond_to?(:clear_active_connections!)
+          if ActiveRecord::Base.respond_to?(:connection_handler) && ActiveRecord::Base.connection_handler
+            ActiveRecord::Base.connection_handler.clear_active_connections!
+          elsif ActiveRecord::Base.respond_to?(:clear_active_connections!)
             ActiveRecord::Base.clear_active_connections!
           elsif ActiveRecord::Base.respond_to?(:verify_active_connections!)
             ActiveRecord::Base.verify_active_connections!

data/lib/say_when/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SayWhen
-  VERSION = '2.2.0'
+  VERSION = '2.2.2'
 end

data/say_when.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency('activesupport')
+  spec.add_runtime_dependency('sorted_set')
 
   spec.add_development_dependency('bundler')
   spec.add_development_dependency('rake')
@@ -28,7 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency('simplecov')
   spec.add_development_dependency('coveralls')
 
-  spec.add_development_dependency('sqlite3')
+  spec.add_development_dependency('sqlite3', '~> 1.4')
   spec.add_development_dependency('activerecord')
   spec.add_development_dependency('celluloid')
   spec.add_development_dependency('concurrent-ruby')

data/test/active_record_helper.rb

@@ -1,8 +1,5 @@
 # encoding: utf-8
 
-require 'active_record'
-require 'sqlite3'
-
 ActiveRecord::Base.logger = Logger.new('/dev/null')
 
 ActiveRecord::Base.establish_connection(

data/test/say_when/configuration_test.rb

@@ -5,10 +5,10 @@ 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"
+    expect(dos).wont_be_nil
+    expect(dos[:processor_strategy]).must_equal :simple
+    expect(dos[:storage_strategy]).must_equal :memory
+    expect(dos[:tick_length]).must_equal 5
+    expect(dos[:queue]).must_equal "default"
   end
 end

data/test/say_when/cron_expression_test.rb

@@ -8,71 +8,71 @@ 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"
+    expect(ce.expression).must_equal "* * * ? * ? *"
+    expect(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)'
+    expect(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:.*/)
+    expect(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])
+    expect(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])
+    expect(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])
+    expect(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([])
+    expect(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")
+    expect(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"))
+    expect(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'))
+      expect(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'))
+      expect(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'))
+      expect(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'))
+      expect(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'))
+      expect(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
 
@@ -83,23 +83,23 @@ describe SayWhen::CronExpression do
     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'))
+      expect(@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'))
+      expect(@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'))
+      expect(@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'))
+      expect(@ce.last_fire_at(Time.utc(2008,1,5))).must_equal Time.parse('2007-12-02 12:00:00 -0800')
+      expect(@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'))
+      expect(@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'))
+      expect(@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
 
@@ -109,32 +109,32 @@ describe SayWhen::CronExpression do
     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'))
+      expect(@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'))
+      expect(@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'))
+      expect(@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'))
+      expect(@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'))
+      expect(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'))
+      expect(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'))
+      expect(nfa).must_equal(Time.parse('2007-11-25 12:00:00 -0800'))
     end
   end
 end

data/test/say_when/poller/base_poller_test.rb

@@ -37,6 +37,6 @@ describe SayWhen::Poller::BasePoller do
   end
 
   it "defines an error tick length" do
-    poller.error_tick_length.must_equal 0
+    expect(poller.error_tick_length).must_equal 0
   end
 end

data/test/say_when/poller/celluloid_poller_test.rb

@@ -6,7 +6,7 @@ describe SayWhen::Poller::CelluloidPoller do
   let (:poller) { SayWhen::Poller::CelluloidPoller.new(100) }
 
   it 'should instantiate the poller' do
-    poller.tick_length.must_equal 100
+    expect(poller.tick_length).must_equal 100
   end
 
   it 'should start the poller running, and can stop it' do

data/test/say_when/poller/concurrent_poller_test.rb

@@ -8,7 +8,7 @@ describe SayWhen::Poller::ConcurrentPoller do
   let (:poller) { SayWhen::Poller::ConcurrentPoller.new(100) }
 
   it 'should instantiate the poller' do
-    poller.tick_length.must_equal 100
+    expect(poller.tick_length).must_equal 100
   end
 
   it 'should start the poller running, and can stop it' do

data/test/say_when/poller/simple_poller_test.rb

@@ -7,21 +7,21 @@ describe SayWhen::Poller::SimplePoller do
   let (:poller) { SayWhen::Poller::SimplePoller.new }
 
   it 'should instantiate the poller' do
-    poller.wont_be_nil
+    expect(poller).wont_be_nil
   end
 
   it 'can check if poller is running' do
-    poller.wont_be :running?
+    expect(poller).wont_be :running?
   end
 
   it 'should start the poller running, and can stop it' do
-    poller.wont_be :running
+    expect(poller).wont_be :running
 
     Thread.start{ poller.start }
     sleep(0.2)
-    poller.must_be :running
+    expect(poller).must_be :running
 
     poller.stop
-    poller.wont_be :running
+    expect(poller).wont_be :running
   end
 end

data/test/say_when/processor/active_job_strategy_test.rb

@@ -21,11 +21,11 @@ describe SayWhen::Processor::ActiveJobStrategy do
       job_method: 'execute'
     }
 
-    SayWhen::Test::TestTask.wont_be :executed?
+    expect(SayWhen::Test::TestTask).wont_be :executed?
 
     job = SayWhen::Storage::MemoryStrategy.create(options)
     processor.process(job)
 
-    SayWhen::Test::TestTask.must_be :executed?
+    expect(SayWhen::Test::TestTask).must_be :executed?
   end
 end

data/test/say_when/processor/simple_strategy_test.rb

@@ -10,6 +10,6 @@ describe SayWhen::Processor::SimpleStrategy do
   it 'process a job by sending a message' do
     job = Minitest::Mock.new
     job.expect(:execute, 'done!')
-    processor.process(job).must_equal 'done!'
+    expect(processor.process(job)).must_equal 'done!'
   end
 end

data/test/say_when/scheduler_test.rb

@@ -7,35 +7,35 @@ describe SayWhen::Scheduler do
   let (:scheduler) { SayWhen::Scheduler.new }
 
   it 'has a logger' do
-    scheduler.logger.must_be_instance_of Logger
+    expect(scheduler.logger).must_be_instance_of Logger
   end
 
   it 'extracts data' do
-    scheduler.extract_data({}).must_be_nil
-    scheduler.extract_data(data: 'data').must_equal 'data'
+    expect(scheduler.extract_data({})).must_be_nil
+    expect(scheduler.extract_data(data: 'data')).must_equal 'data'
   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'
+    expect(scheduler.extract_job_method({})).must_equal 'execute'
+    expect(scheduler.extract_job_method(job_method: 'just_doit')).must_equal 'just_doit'
+    expect(scheduler.extract_job_method(method: 'doit')).must_equal 'doit'
   end
 
   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'
+    expect(scheduler.extract_job_class(job_class: 'foo')).must_equal 'foo'
+    expect(scheduler.extract_job_class(class: 'foo')).must_equal 'foo'
+    expect(scheduler.extract_job_class(SayWhen::Test::TestTask)).must_equal 'SayWhen::Test::TestTask'
+    expect(scheduler.extract_job_class('SayWhen::Test::TestTask')).must_equal 'SayWhen::Test::TestTask'
   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 }
+    keys.each{|k| expect(opts[k]).must_equal k.to_s }
 
-    lambda do
+    expect(lambda do
       scheduler.job_options(bar: 'foo')
-    end.must_raise RuntimeError
+    end).must_raise RuntimeError
   end
 
   it 'can schedule a new job' do
@@ -45,15 +45,15 @@ describe SayWhen::Scheduler do
       job_class: 'SayWhen::Test::TestTask',
       job_method: 'execute'
     )
-    job.wont_be_nil
+    expect(job).wont_be_nil
   end
 
   it 'can schedule a cron job' do
     job = scheduler.schedule_cron("0 0 12 ? * * *", SayWhen::Test::TestTask)
-    job.wont_be_nil
+    expect(job).wont_be_nil
   end
 
   it 'should provide the storage strategy' do
-    scheduler.storage.must_equal SayWhen::Storage::MemoryStrategy
+    expect(scheduler.storage).must_equal SayWhen::Storage::MemoryStrategy
   end
 end

data/test/say_when/storage/active_record_strategy_test.rb

@@ -21,40 +21,40 @@ describe SayWhen::Storage::ActiveRecordStrategy do
 
   it 'job can be created' do
     j = strategy.create(valid_attributes)
-    j.wont_be_nil
+    expect(j).wont_be_nil
   end
 
   it 'job can be serialized' do
-    strategy.serialize(job).must_equal job
-    strategy.deserialize(job).must_equal job
+    expect(strategy.serialize(job)).must_equal job
+    expect(strategy.deserialize(job)).must_equal job
   end
 
   it 'can execute the task for the job' do
-    job.execute_job( { result: 1 } ).must_equal 1
+    expect(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
+    expect(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
+    expect(t.trigger).wont_be_nil
+    expect(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
+    expect(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
+    expect(j.status).must_equal SayWhen::Storage::BaseJob::STATE_WAITING
+    expect(j.next_fire_at).must_equal ce.next_fire_at
   end
 
   it 'can acquire and release the next job' do
@@ -71,14 +71,14 @@ describe SayWhen::Storage::ActiveRecordStrategy do
     now = Time.now.change(hour: 0)
     Time.stub(:now, now) do
       j1 = strategy.create(valid_attributes)
-      j1.wont_be_nil
+      expect(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
+      expect(next_job.status).must_equal "acquired"
+      expect(next_job).must_equal j2
       strategy.release(next_job)
-      next_job.status.must_equal "waiting"
+      expect(next_job.status).must_equal "waiting"
     end
   end
 
@@ -87,12 +87,12 @@ describe SayWhen::Storage::ActiveRecordStrategy do
     j = strategy.create(valid_attributes)
     j.update(status: 'acquired', updated_at: old, created_at: old)
 
-    j.status.must_equal 'acquired'
+    expect(j.status).must_equal 'acquired'
 
     strategy.reset_acquired(3600)
 
     j.reload
-    j.status.must_equal 'waiting'
+    expect(j.status).must_equal 'waiting'
   end
 
   it 'can be fired' do
@@ -107,28 +107,28 @@ describe SayWhen::Storage::ActiveRecordStrategy do
     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
+      expect(j.next_fire_at).must_equal ce.next_fire_at(now)
+      expect(j.last_fire_at).must_equal now
+      expect(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?
+      expect(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
+        expect(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
+      expect(job[:scheduled]).must_equal taas
     end
   end
 end

data/test/say_when/storage/memory_strategy_test.rb

@@ -23,31 +23,31 @@ describe SayWhen::Storage::MemoryStrategy do
 
   it 'job can be created' do
     j = strategy.create(valid_attributes)
-    j.wont_be_nil
+    expect(j).wont_be_nil
   end
 
   it 'can execute the task for the job' do
-    job.execute_job( { result: 1 } ).must_equal 1
+    expect(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
+    expect(j.execute).must_equal 1
   end
 
   it 'can serialize' do
     j = strategy.create(valid_attributes)
-    j.to_hash[:job_class].must_equal 'SayWhen::Test::TestTask'
+    expect(j.to_hash[:job_class]).must_equal 'SayWhen::Test::TestTask'
   end
 
   it 'can acquire and release the next job' do
     j = strategy.create(valid_attributes)
-    j.wont_be_nil
+    expect(j).wont_be_nil
     next_job  = strategy.acquire_next(2.days.since)
-    next_job.wont_be_nil
-    next_job.status.must_equal "acquired"
+    expect(next_job).wont_be_nil
+    expect(next_job.status).must_equal "acquired"
     strategy.release(next_job)
-    next_job.status.must_equal "waiting"
+    expect(next_job.status).must_equal "waiting"
   end
 
   it 'can reset acquired jobs' do
@@ -55,7 +55,7 @@ describe SayWhen::Storage::MemoryStrategy do
     j.status = 'acquired'
     j.updated_at = 2.hours.ago
     strategy.reset_acquired(3600)
-    j.status.must_equal 'waiting'
+    expect(j.status).must_equal 'waiting'
   end
 
   it 'can be fired' do
@@ -70,20 +70,20 @@ describe SayWhen::Storage::MemoryStrategy do
     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
+      expect(j.next_fire_at).must_equal ce.next_fire_at(now)
+      expect(j.last_fire_at).must_equal now
+      expect(j.status).must_equal SayWhen::Storage::BaseJob::STATE_WAITING
     end
   end
 
   it "can be serialized to a hash" do
     j = strategy.create(valid_attributes)
-    strategy.serialize(j).class.must_equal Hash
+    expect(strategy.serialize(j).class).must_equal Hash
   end
 
   it "can be deserialized from a hash" do
     j = strategy.deserialize(valid_attributes)
-    j.class.must_equal SayWhen::Storage::MemoryStrategy::Job
+    expect(j.class).must_equal SayWhen::Storage::MemoryStrategy::Job
   end
 
   it "can reset acquired jobs" do
@@ -91,6 +91,6 @@ describe SayWhen::Storage::MemoryStrategy do
     j.status = 'acquired'
     j.updated_at = 2.hours.ago
     SayWhen::Storage::MemoryStrategy::Job.reset_acquired(3600)
-    j.status.must_equal 'waiting'
+    expect(j.status).must_equal 'waiting'
   end
 end

data/test/say_when/triggers/cron_strategy_test.rb

@@ -6,6 +6,6 @@ require 'say_when/triggers/cron_strategy'
 describe SayWhen::Triggers::CronStrategy do
   it 'should be constucted with a cron expression' do
     t = SayWhen::Triggers::CronStrategy.new(expression: '0 0 * ? * * *', job: {})
-    t.wont_be_nil
+    expect(t).wont_be_nil
   end
 end

data/test/say_when/triggers/instance_strategy_test.rb

@@ -8,6 +8,6 @@ describe SayWhen::Triggers::InstanceStrategy do
     job = Minitest::Mock.new
     job.expect(:scheduled, true)
     t = SayWhen::Triggers::InstanceStrategy.new(next_at_method: 'test_next_at_method', job: job)
-    t.wont_be_nil
+    expect(t).wont_be_nil
   end
 end

data/test/say_when/triggers/once_strategy_test.rb

@@ -8,16 +8,16 @@ 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, job: {})
-    o.wont_be_nil
-    o.once_at.must_equal time_at
+    expect(o).wont_be_nil
+    expect(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, job: {})
-    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
+    expect(o).wont_be_nil
+    expect(o.next_fire_at).must_equal time_at
+    expect(o.next_fire_at(time_at + 10.second)).must_be_nil
+    expect(o.next_fire_at(time_at - 10.second)).must_equal time_at
   end
 end

data/test/say_when_test.rb

@@ -5,16 +5,16 @@ require 'minitest_helper'
 describe SayWhen do
 
   it 'provides a default logger' do
-    SayWhen.logger.wont_be_nil
+    expect(SayWhen.logger).wont_be_nil
   end
 
   it 'can set a new logger' do
     l = Logger.new('/dev/null')
     SayWhen.logger = l
-    l.must_equal l
+    expect(l).must_equal l
   end
 
   it 'provides the scheduler' do
-    SayWhen.scheduler.wont_be_nil
+    expect(SayWhen.scheduler).wont_be_nil
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: say_when
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.2
 platform: ruby
 authors:
 - Andrew Kuklewicz
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-05 00:00:00.000000000 Z
+date: 2024-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sorted_set
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -126,16 +140,16 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -255,7 +269,7 @@ homepage: https://github.com/kookster/say_when
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -270,8 +284,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.5.9
+signing_key:
 specification_version: 4
 summary: Scheduling system for programmatically defined and stored jobs.
 test_files: