rufus-scheduler 1.0.5 → 1.0.6

data/test/scheduler_1_test.rb

@@ -16,78 +16,73 @@ require 'openwfe/util/scheduler'
 
 class Scheduler1Test < Test::Unit::TestCase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
-    def test_0
+  def test_0
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.sstart
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.sstart
 
-        job_id = scheduler.schedule_every "500", :tags => "Avery" do
-            # don't do a thing
-        end
-
-        sleep 0.300
-
-        successful = true
+    job_id = scheduler.schedule_every "500", :tags => "Avery" do
+      # don't do a thing
+    end
 
-        200000.times do
-            #assert_not_nil scheduler.get_job(job_id)
-            if scheduler.get_job(job_id) == nil
-                successful = false
-                break
-            end
-        end
+    sleep 0.300
 
-        scheduler.sstop
+    count = nil
 
-        assert successful
+    200_000.times do |i|
+      break if scheduler.get_job(job_id) == nil
+      count = i + 1
     end
 
-    def test_1
+    scheduler.sstop
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.sstart
+    assert_equal 200_000, count
+  end
 
-        job_id = scheduler.schedule_every "500", :tags => "Avery" do
-            # don't do a thing
-        end
+  def test_1
 
-        sleep 0.300
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.sstart
 
-        successful = true
+    job_id = scheduler.schedule_every "500", :tags => "Avery" do
+      # don't do a thing
+    end
 
-        200000.times do
-            #assert_equal 1, scheduler.find_jobs("Avery").size
-            if scheduler.find_jobs("Avery").size != 1
-                successful = false
-                break
-            end
-        end
+    sleep 0.300
 
-        scheduler.sstop
+    count = 1
 
-        assert successful
+    200_000.times do
+      #assert_equal 1, scheduler.find_jobs("Avery").size
+      count = scheduler.find_jobs("Avery").size
+      break if count != 1
     end
 
-    #
-    # testing "deviation", if I may call it like that...
-    #
-    def _test_2
-
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.sstart
-        last = nil
-        job_id = scheduler.schedule_every "1s" do
-            t = Time.now
-            puts t.to_f
-        end
-        sleep 4 * 60
-        scheduler.sstop
+    scheduler.sstop
+
+    assert_equal 1, count
+  end
+
+  #
+  # testing "deviation", if I may call it like that...
+  #
+  def _test_2
+
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.sstart
+    last = nil
+    job_id = scheduler.schedule_every "1s" do
+      t = Time.now
+      puts t.to_f
     end
+    sleep 4 * 60
+    scheduler.sstop
+  end
 
 end

data/test/scheduler_2_test.rb

@@ -16,108 +16,108 @@ require 'openwfe/util/scheduler'
 
 class Scheduler2Test < Test::Unit::TestCase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
-    def test_0
+  def test_0
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.sstart
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.sstart
 
-        counter = 0
-        $error_counter = 0
+    counter = 0
+    $error_counter = 0
 
-        def scheduler.lwarn (&block)
-            #puts block.call
-            $error_counter += 1
-        end
-
-        job_id = scheduler.schedule_every "500" do
-            counter += 1
-            raise "exception!"
-        end
-
-        sleep 2.300
-
-        scheduler.sstop
+    def scheduler.lwarn (&block)
+      #puts block.call
+      $error_counter += 1
+    end
 
-        assert_equal 4, counter, "execution count wrong"
-        assert_equal 4, $error_counter, "error count wrong"
+    job_id = scheduler.schedule_every "500" do
+      counter += 1
+      raise "exception!"
     end
 
-    def test_1
+    sleep 2.300
 
-        # repeating myself
+    scheduler.sstop
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.sstart
+    assert_equal 4, counter, "execution count wrong"
+    assert_equal 4, $error_counter, "error count wrong"
+  end
 
-        counter = 0
-        $error_counter = 0
+  def test_1
 
-        def scheduler.lwarn (&block)
-            #puts block.call
-            $error_counter += 1
-        end
+    # repeating myself
 
-        job_id = scheduler.schedule_every "500", :try_again => false do
-            counter += 1
-            raise "exception?"
-        end
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.sstart
 
-        sleep 2.300
+    counter = 0
+    $error_counter = 0
 
-        scheduler.sstop
+    def scheduler.lwarn (&block)
+      #puts block.call
+      $error_counter += 1
+    end
 
-        assert_equal 1, counter, "execution count wrong"
-        assert_equal 1, $error_counter, "error count wrong"
+    job_id = scheduler.schedule_every "500", :try_again => false do
+      counter += 1
+      raise "exception?"
     end
 
-    def test_2
+    sleep 2.300
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.sstart
+    scheduler.sstop
 
-        def scheduler.lwarn (&block)
-            puts block.call
-        end
+    assert_equal 1, counter, "execution count wrong"
+    assert_equal 1, $error_counter, "error count wrong"
+  end
 
-        counter = 0
+  def test_2
 
-        job_id = scheduler.schedule_every "500" do |job_id, at, params|
-            counter += 1
-            params[:dont_reschedule] = true if counter == 2
-        end
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.sstart
 
-        sleep 3.000
+    def scheduler.lwarn (&block)
+      puts block.call
+    end
+
+    counter = 0
 
-        assert_equal 2, counter
+    job_id = scheduler.schedule_every "500" do |job_id, at, params|
+      counter += 1
+      params[:dont_reschedule] = true if counter == 2
     end
 
-    def test_3
+    sleep 3.000
 
-        # repeating myself ...
+    assert_equal 2, counter
+  end
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.sstart
+  def test_3
 
-        def scheduler.lwarn (&block)
-            puts block.call
-        end
+    # repeating myself ...
 
-        counter = 0
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.sstart
 
-        job_id = scheduler.schedule_every "500" do |job_id, at, params|
-            counter += 1
-            params[:every] = "1s" if counter == 2
-        end
+    def scheduler.lwarn (&block)
+      puts block.call
+    end
 
-        sleep 5.000
+    counter = 0
 
-        assert_equal 2 + 3, counter
+    job_id = scheduler.schedule_every "500" do |job_id, at, params|
+      counter += 1
+      params[:every] = "1s" if counter == 2
     end
 
+    sleep 5.000
+
+    assert_equal 2 + 3, counter
+  end
+
 end

data/test/scheduler_3_test.rb

@@ -13,57 +13,57 @@ require 'openwfe/util/scheduler'
 
 class Scheduler3Test < Test::Unit::TestCase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
-    #
-    # Testing tags
-    #
-    def test_0
+  #
+  # Testing tags
+  #
+  def test_0
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.start
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.start
 
-        value = nil
+    value = nil
 
-        scheduler.schedule_in "3s", :tags => "fish" do
-            value = "fish"
-        end
+    scheduler.schedule_in "3s", :tags => "fish" do
+      value = "fish"
+    end
 
-        sleep 0.300 # let the job get really scheduled
+    sleep 0.300 # let the job get really scheduled
 
-        assert_equal [], scheduler.find_jobs('deer')
-        assert_equal 1, scheduler.find_jobs('fish').size
+    assert_equal [], scheduler.find_jobs('deer')
+    assert_equal 1, scheduler.find_jobs('fish').size
 
-        scheduler.schedule "* * * * *", :tags => "fish" do
-            value = "cron-fish"
-        end
-        scheduler.schedule "* * * * *", :tags => "vegetable" do
-            value = "daikon"
-        end
+    scheduler.schedule "* * * * *", :tags => "fish" do
+      value = "cron-fish"
+    end
+    scheduler.schedule "* * * * *", :tags => "vegetable" do
+      value = "daikon"
+    end
 
-        sleep 0.300 # let the jobs get really scheduled
+    sleep 0.300 # let the jobs get really scheduled
 
-        assert_equal 2, scheduler.find_jobs('fish').size
-        #puts scheduler.find_jobs('fish')
+    assert_equal 2, scheduler.find_jobs('fish').size
+    #puts scheduler.find_jobs('fish')
 
-        scheduler.find_jobs('fish').each do |job|
-            scheduler.unschedule(job.job_id)
-        end
+    scheduler.find_jobs('fish').each do |job|
+      scheduler.unschedule(job.job_id)
+    end
 
-        sleep 0.300 # give it some time to unschedule
+    sleep 0.300 # give it some time to unschedule
 
-        assert_equal [], scheduler.find_jobs('fish')
-        assert_equal 1, scheduler.find_jobs('vegetable').size
+    assert_equal [], scheduler.find_jobs('fish')
+    assert_equal 1, scheduler.find_jobs('vegetable').size
 
-        scheduler.find_jobs('vegetable')[0].unschedule
+    scheduler.find_jobs('vegetable')[0].unschedule
 
-        sleep 0.300 # give it some time to unschedule
+    sleep 0.300 # give it some time to unschedule
 
-        assert_equal 0, scheduler.find_jobs('vegetable').size
-    end
+    assert_equal 0, scheduler.find_jobs('vegetable').size
+  end
 
 end

data/test/scheduler_4_test.rb

@@ -13,69 +13,69 @@ require 'rufus/scheduler'
 
 class Scheduler4Test < Test::Unit::TestCase
 
-    #def setup
-    #end
-
-    #def teardown
-    #end
-
-    #
-    # Checking that a sleep in a schedule won't raise any exception
-    #
-    def test_0
-
-        s = Rufus::Scheduler.new
-        s.start
-
-        $exception = nil
-
-        class << s
-            def lwarn (&block)
-                $exception = block.call
-            end
-        end
-
-        counters = Counters.new
-        
-        s.schedule_every "2s" do
-            counters.inc :a
-            sleep 4
-            counters.inc :b
-        end
-        s.schedule_every "3s" do
-            counters.inc :c
-        end
-        #p Time.now.to_f
-
-        sleep 10.300
-
-        s.stop
-
-        assert_equal({ :a => 3, :b => 2, :c => 3 }, counters.counters)
-        assert_nil $exception
+  #def setup
+  #end
+
+  #def teardown
+  #end
+
+  #
+  # Checking that a sleep in a schedule won't raise any exception
+  #
+  def test_0
+
+    s = Rufus::Scheduler.new
+    s.start
+
+    $exception = nil
+
+    class << s
+      def lwarn (&block)
+        $exception = block.call
+      end
     end
 
-    protected
+    counters = Counters.new
 
-        class Counters
+    s.schedule_every "2s" do
+      counters.inc :a
+      sleep 4
+      counters.inc :b
+    end
+    s.schedule_every "3s" do
+      counters.inc :c
+    end
+    #p Time.now.to_f
 
-            attr_reader :counters
+    sleep 10.300
 
-            def initialize
+    s.stop
 
-                @counters = {}
-            end
+    assert_equal({ :a => 3, :b => 2, :c => 3 }, counters.counters)
+    assert_nil $exception
+  end
 
-            def inc (counter)
+  protected
 
-                @counters[counter] ||= 0
-                @counters[counter] += 1
+    class Counters
 
-                #puts(
-                #    "#{counter} _ " +
-                #    "#{Time.now.to_f}  #{@counters.inspect} " +
-                #    "(#{Thread.current.object_id})")
-            end
-        end
+      attr_reader :counters
+
+      def initialize
+
+        @counters = {}
+      end
+
+      def inc (counter)
+
+        @counters[counter] ||= 0
+        @counters[counter] += 1
+
+        #puts(
+        #  "#{counter} _ " +
+        #  "#{Time.now.to_f}  #{@counters.inspect} " +
+        #  "(#{Thread.current.object_id})")
+      end
+    end
 
 end