clockwork 0.7.7 → 1.0.0

data/test/database_events/sync_performer_test.rb

@@ -0,0 +1,283 @@
+require 'contest'
+require 'mocha/setup'
+require 'time'
+require 'active_support/time'
+
+require_relative '../../lib/clockwork'
+require_relative '../../lib/clockwork/database_events'
+require_relative 'test_helpers'
+
+module DatabaseEvents
+
+  class SyncPerformerTest < Test::Unit::TestCase
+
+    setup do
+      @now = Time.now
+      DatabaseEventModelClass.delete_all
+      DatabaseEventModelClass2.delete_all
+
+      Clockwork.manager = @manager = Clockwork::DatabaseEvents::Manager.new
+      class << @manager
+        def log(msg); end # silence log output
+      end
+    end
+
+    describe "setup" do
+      setup do
+        @subject = Clockwork::DatabaseEvents::SyncPerformer
+      end
+
+      describe "arguments" do
+        def test_does_not_raise_error_with_valid_arguments
+          @subject.setup(model: DatabaseEventModelClass, every: 1.minute) {}
+        end
+
+        def test_raises_argument_error_if_model_is_not_set
+          error = assert_raises KeyError do
+            @subject.setup(every: 1.minute) {}
+          end
+          assert_equal error.message, ":model must be set to the model class"
+        end
+
+        def test_raises_argument_error_if_every_is_not_set
+          error = assert_raises KeyError do
+            @subject.setup(model: DatabaseEventModelClass) {}
+          end
+          assert_equal error.message, ":every must be set to the database sync frequency"
+        end
+      end
+
+      context "when database reload frequency is greater than model frequency period" do
+        setup do
+          @events_run = []
+          @sync_frequency = 1.minute
+        end
+
+        def test_fetches_and_registers_event_from_database
+          DatabaseEventModelClass.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          tick_at(@now, :and_every_second_for => 1.second)
+          
+          assert_equal ["DatabaseEventModelClass:1"], @events_run
+        end
+
+        def test_multiple_events_from_database_can_be_registered
+          DatabaseEventModelClass.create(:frequency => 10)
+          DatabaseEventModelClass.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          tick_at(@now, :and_every_second_for => 1.second)
+
+          assert_equal ["DatabaseEventModelClass:1", "DatabaseEventModelClass:2"], @events_run
+        end
+
+        def test_event_from_database_does_not_run_again_before_frequency_specified_in_database
+          model = DatabaseEventModelClass.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          tick_at(@now, :and_every_second_for => model.frequency - 1.second)
+          assert_equal 1, @events_run.length
+        end
+
+        def test_event_from_database_runs_repeatedly_with_frequency_specified_in_database
+          model = DatabaseEventModelClass.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          tick_at(@now, :and_every_second_for => (2 * model.frequency) + 1.second)
+
+          assert_equal 3, @events_run.length
+        end
+
+        def test_reloaded_events_from_database_run_repeatedly
+          model = DatabaseEventModelClass.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          tick_at(@now, :and_every_second_for => @sync_frequency - 1)
+
+          model.update(:name => "DatabaseEventModelClass:1:Reloaded")
+
+          tick_at(@now + @sync_frequency, :and_every_second_for => model.frequency * 2)
+
+          assert_equal ["DatabaseEventModelClass:1:Reloaded", "DatabaseEventModelClass:1:Reloaded"], @events_run[-2..-1]
+        end
+
+        def test_reloading_events_from_database_with_modified_frequency_will_run_with_new_frequency
+          model = DatabaseEventModelClass.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          tick_at(@now, :and_every_second_for => @sync_frequency - 1.second)
+          model.update(:frequency => 5)
+          tick_at(@now + @sync_frequency, :and_every_second_for => 6.seconds)
+
+          # model runs at: 1, 11, 21, 31, 41, 51 (6 runs)
+          # database sync happens at: 60
+          # modified model runs at: 61 (next tick after reload) and then 66 (2 runs)
+          assert_equal 8, @events_run.length
+        end
+
+        def test_stops_running_deleted_events_from_database
+          model = DatabaseEventModelClass.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          tick_at(@now, :and_every_second_for => (@sync_frequency - 1.second))
+          before = @events_run.dup
+          model.delete!
+          tick_at(@now + @sync_frequency, :and_every_second_for => @sync_frequency)
+          after = @events_run
+
+          assert_equal before, after
+        end
+
+        def test_event_from_database_with_edited_name_switches_to_new_name
+          model = DatabaseEventModelClass.create(:frequency => 10.seconds)
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          tick_at @now, :and_every_second_for => @sync_frequency - 1.second
+          @events_run.clear
+          model.update(:name => "DatabaseEventModelClass:1_modified")
+          tick_at @now + @sync_frequency, :and_every_second_for => (model.frequency * 2)
+
+          assert_equal ["DatabaseEventModelClass:1_modified", "DatabaseEventModelClass:1_modified"], @events_run
+        end
+
+        def test_event_from_database_with_edited_frequency_switches_to_new_frequency
+          model = DatabaseEventModelClass.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          tick_at @now, :and_every_second_for => @sync_frequency - 1.second
+          @events_run.clear
+          model.update(:frequency => 30)
+          tick_at @now + @sync_frequency, :and_every_second_for => @sync_frequency - 1.seconds
+
+          assert_equal 2, @events_run.length
+        end
+
+        def test_event_from_database_with_edited_at_runs_at_new_at
+          model = DatabaseEventModelClass.create(:frequency => 1.day, :at => '10:30')
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          assert_will_run 'jan 1 2010 10:30:00'
+          assert_wont_run 'jan 1 2010 09:30:00'
+
+          model.update(:at => '09:30')
+          tick_at @now, :and_every_second_for => @sync_frequency + 1.second
+
+          assert_will_run 'jan 1 2010 09:30:00'
+          assert_wont_run 'jan 1 2010 10:30:00'
+        end
+
+        def test_daily_event_from_database_with_at_should_only_run_once
+          DatabaseEventModelClass.create(:frequency => 1.day, :at => next_minute(@now).strftime('%H:%M'))
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          # tick from now, though specified :at time
+          tick_at(@now, :and_every_second_for => (2 * @sync_frequency) + 1.second)
+
+          assert_equal 1, @events_run.length
+        end
+
+        def test_event_from_databse_with_comma_separated_at_leads_to_multiple_event_ats
+          DatabaseEventModelClass.create(:frequency => 1.day, :at => '16:20, 18:10')
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          tick_at @now, :and_every_second_for => 1.second
+
+          assert_wont_run 'jan 1 2010 16:19:59'
+          assert_will_run 'jan 1 2010 16:20:00'
+          assert_wont_run 'jan 1 2010 16:20:01'
+
+          assert_wont_run 'jan 1 2010 18:09:59'
+          assert_will_run 'jan 1 2010 18:10:00'
+          assert_wont_run 'jan 1 2010 18:10:01'
+        end
+
+        def test_syncing_multiple_database_models_works
+          DatabaseEventModelClass.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+
+          DatabaseEventModelClass2.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModelClass2, :every => @sync_frequency, :events_run => @events_run)
+
+          tick_at(@now, :and_every_second_for => 1.second)
+
+          assert_equal ["DatabaseEventModelClass:1", "DatabaseEventModelClass2:1"], @events_run
+        end
+      end
+
+      context "when database reload frequency is less than model frequency period" do
+        setup do
+          @events_run = []
+        end
+
+        def test_the_event_only_runs_once_within_the_model_frequency_period
+          DatabaseEventModelClass.create(:frequency => 5.minutes)
+          setup_sync(model: DatabaseEventModelClass, :every => 1.minute, :events_run => @events_run)
+
+          tick_at(@now, :and_every_second_for => 5.minutes)
+
+          assert_equal 1, @events_run.length
+        end
+      end
+
+      context "with database event with :at as empty string" do
+        setup do
+          @events_run = []
+
+          DatabaseEventModelClass.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModelClass, :every => 1.minute, :events_run => @events_run)
+        end
+
+        def test_it_does_not_raise_an_error
+          begin
+            tick_at(Time.now, :and_every_second_for => 10.seconds)
+          rescue => e
+            assert false, "Raised an error: #{e.message}"
+          end
+        end
+
+        def test_the_event_runs
+          begin
+            tick_at(Time.now, :and_every_second_for => 10.seconds)
+          rescue => e
+          end
+          assert_equal 1, @events_run.length
+        end
+      end
+
+      context "with task that respond to `tz`" do
+        setup do
+          @events_run = []
+          @utc_time_now = Time.now.utc
+          
+          DatabaseEventModelClass.create(:frequency => 1.days, :at => @utc_time_now.strftime('%H:%M'), :tz => 'America/Montreal')
+          setup_sync(model: DatabaseEventModelClass, :every => 1.minute, :events_run => @events_run)
+        end
+
+        def test_it_does_not_raise_an_error
+          begin
+            tick_at(@utc_time_now, :and_every_second_for => 10.seconds)
+          rescue => e
+            assert false, "Raised an error: #{e.message}"
+          end
+        end
+
+        def test_it_do_not_runs_the_task_as_utc
+          begin
+            tick_at(@utc_time_now, :and_every_second_for => 3.hours)
+          rescue => e
+          end
+          assert_equal 0, @events_run.length
+        end
+
+        def test_it_does_runs_the_task_as_est
+          begin
+            tick_at(@utc_time_now, :and_every_second_for => 5.hours)
+          rescue => e
+          end
+          assert_equal 1, @events_run.length
+        end
+      end
+    end
+  end
+end

data/test/database_events/test_helpers.rb

@@ -0,0 +1,101 @@
+def setup_sync(options={})
+  model_class = options.fetch(:model) { raise KeyError, ":model must be set to the model class" }
+  frequency = options.fetch(:every) { raise KeyError, ":every must be set to the database sync frequency" }
+  events_run = options.fetch(:events_run) { raise KeyError, ":events_run must be provided"}
+
+  Clockwork::DatabaseEvents::SyncPerformer.setup model: model_class, every: frequency do |model|
+    events_run << model.name
+  end
+end
+
+def assert_will_run(t)
+  assert_equal 1, @manager.tick(normalize_time(t)).size
+end
+
+def assert_wont_run(t)
+  assert_equal 0, @manager.tick(normalize_time(t)).size
+end
+
+def tick_at(now = Time.now, options = {})
+  seconds_to_tick_for = options[:and_every_second_for] || 0
+  number_of_ticks = 1 + seconds_to_tick_for
+  number_of_ticks.times{|i| @manager.tick(now + i) }
+end
+
+def next_minute(now = Time.now)
+  Time.at((now.to_i / 60 + 1) * 60)
+end
+
+def normalize_time t
+  t.is_a?(String) ? Time.parse(t) : t
+end
+
+
+class ActiveRecordFake
+  attr_accessor :id, :name, :at, :frequency, :tz
+
+  class << self
+    def create *args
+      new *args
+    end
+
+    def add instance
+      @events << instance
+    end
+
+    def remove instance
+      @events.delete(instance)
+    end
+
+    def next_id
+      id = @next_id
+      @next_id += 1
+      id
+    end
+
+    def reset_id
+      @next_id = 1
+    end
+
+    def delete_all
+      @events.clear
+      reset_id
+    end
+
+    def all
+      @events.dup
+    end
+  end
+
+  def initialize options={}
+    @id = options.fetch(:id) { self.class.next_id }
+    @name = options.fetch(:name) { nil }
+    @at = options.fetch(:at) { nil }        
+    @frequency = options.fetch(:frequency) { raise KeyError, ":every must be supplied" }
+    @tz = options.fetch(:tz) { nil }
+
+    self.class.add self
+  end
+
+  def name
+    @name || "#{self.class}:#{id}"
+  end
+
+  def delete!
+    self.class.remove(self)
+  end
+
+  def update options={}
+    options.each{|attr, value| self.send("#{attr}=".to_sym, value) }
+  end
+end
+
+class DatabaseEventModelClass < ActiveRecordFake
+  @events = []
+  @next_id = 1
+end
+
+class DatabaseEventModelClass2 < ActiveRecordFake
+  @events = []
+  @next_id = 1
+end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clockwork
 version: !ruby/object:Gem::Version
-  version: 0.7.7
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - Adam Wiggins
@@ -10,134 +9,118 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-05 00:00:00.000000000 Z
+date: 2014-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: daemons
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: contest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A scheduler process to replace cron, using a more flexible Ruby syntax
@@ -152,61 +135,62 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - bin/clockwork
 - bin/clockworkd
 - clockwork.gemspec
+- clockworkd.1
 - example.rb
 - gemfiles/activesupport3.gemfile
 - gemfiles/activesupport4.gemfile
 - lib/clockwork.rb
 - lib/clockwork/at.rb
+- lib/clockwork/database_events.rb
+- lib/clockwork/database_events/event.rb
+- lib/clockwork/database_events/manager.rb
+- lib/clockwork/database_events/registry.rb
+- lib/clockwork/database_events/sync_performer.rb
 - lib/clockwork/event.rb
 - lib/clockwork/manager.rb
-- lib/clockwork/manager_with_database_tasks.rb
 - test/at_test.rb
 - test/clockwork_test.rb
+- test/database_events/sync_performer_test.rb
+- test/database_events/test_helpers.rb
 - test/event_test.rb
 - test/manager_test.rb
-- test/manager_with_database_tasks_test.rb
 homepage: http://github.com/tomykaira/clockwork
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1006563675732551945
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1006563675732551945
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A scheduler process to replace cron.
 test_files:
 - test/at_test.rb
 - test/clockwork_test.rb
+- test/database_events/sync_performer_test.rb
+- test/database_events/test_helpers.rb
 - test/event_test.rb
 - test/manager_test.rb
-- test/manager_with_database_tasks_test.rb