redis-scheduler 0.7 → 0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: afd06d80f04150ef2250553dd178039364be4115
-  data.tar.gz: 4e415b9297295a1a6c2d6a63b2faaf9d9f9659f6
+  metadata.gz: d4c61ee6608f6112456f84933f3b209f879a3401
+  data.tar.gz: ae05d544a25078cd248a0e70ea005fca7df1e629
 SHA512:
-  metadata.gz: c1c4f5e1ce194abf48e5064d39c3be94f752db8ac724ea365e2f7e5a2460ae78e631d7bd031784412522999caefed5b8e098c4c8632681908b5c35a0cf2df7ce
-  data.tar.gz: 6fb59c26621545b5a5fa63752e513781a7167af1d1c7291b323e581fa1e33388c302711c2e0716a1dc8b8395a77a2dae2deb5756852d1ad11f578939e9db9f78
+  metadata.gz: ce8cd9ee9ba8b78a436bb1e680cb7f34b6fb3bdb41907a4bb8825053371e286e8082935f768b1fe727b3b509848d1405c44a12aaffd7ad4ca99c4a189e40765a
+  data.tar.gz: 257cbd5324c02e216ee497a72ea4adbe3c9fa74d9795d7fd4143be41b3d186d08559883d969f29ce97837dd99e52a7bff0a2bd09f52e4197ace5122f7000b9e9

data/README

@@ -1,24 +1,22 @@
-RedisScheduler is a chronological scheduler for Redis. It allows you to schedule
-items to be processed at arbitrary points in time (via RedisScheduler#schedule!)
-and easily retrieve only those items that are due to be processed (via
-RedisScheduler#each).
+A simple, production-ready chronological scheduler for Redis. It allows you to
+schedule items to be processed at arbitrary points in the future, and easily
+retrieve only those items that are due to be processed.
 
 It does everything you'd expect from a production scheduler:
-* You can schedule items at arbitrary times.
+* You can schedule arbitrary items at arbitrary times.
 * You can iterate over ready items in either blocking or non-blocking mode.
-* It supports multiple simultaneous readers and writers.
-* A Ruby exception causes the item to be rescheduled at the original time.
-* Work items lost as part of a Ruby crash or segfault are recoverable.
+* It supports multiple concurrent producers and consumers.
+* An application exception causes the item to be rescheduled at the original time.
+* Work items lost as part of an application crash or segfault are recoverable.
 
-In non-blocking mode (the default), RedisScheduler#each will iterate only over
-those work items whose scheduled time is less than or equal to the current time,
-and then stop. In blocking mode, RedisScheduler#each will iterate over the same
-items, but will also block until items are available. In this mode, #each will
-never return.
+In non-blocking mode, RedisScheduler#each will iterate over only those items
+whose scheduled time is less than or equal to the current time, and then stop.
+In blocking mode, RedisScheduler#each will additionally wait until further
+items are available. In nonblocking mode, #each will never return.
 
 For debugging purposes, you can use RedisScheduler#items to iterate over all
-items in the queue, but note that this method is not guaranteed to be
-consistent.
+items in the queue. Note that this method is not guaranteed to be consistent in
+the presence of contemporaneous producers or consumers.
 
 For error recovery purposes, you can use RedisScheduler#processing_set_items
 to iterate over all the items in the processing set to determine whether any
@@ -41,6 +39,10 @@ of them are the result of a process crash.
   20.06058172: c
   ... waits forever ...
 
+== Documentation
+
+See RedisScheduler's #initiatilize, schedule! and #each methods.
+
 == Implementation
 
 See http://masanjin.net/blog/using-redis-for-scheduling for some details.

data/test/redis-scheduler.rb

@@ -0,0 +1,118 @@
+require 'minitest/autorun'
+require 'redis'
+require 'redis-scheduler'
+require 'timecop'
+
+## WARNING! This currently writes a bunch of keys to the Redis running on the
+## default location. The keys are prefixed with
+## "test-8ee2027983915ec78acc45027d874316/" and
+## "test-8ee2027983915ec78acc45027d874317/" to avoid colliding with anything
+## important, but this is not a great strategy, eh?
+
+class RedisSchedulerTest < Minitest::Test
+  TIME = Time.local 2012, 1, 1, 15, 0, 0
+
+  def setup
+    super
+    @redis = Redis.new
+    @scheduler = RedisScheduler.new @redis, namespace: "test-8ee2027983915ec78acc45027d874316/", blocking: false
+    @uniq_scheduler  = RedisScheduler.new @redis, namespace: "test-8ee2027983915ec78acc45027d874317/", blocking: false, uniq: true
+  end
+
+  def teardown
+    super
+    @scheduler.reset!
+    @uniq_scheduler.reset!
+  end
+
+  def test_begins_empty
+    assert_equal 0, @scheduler.size
+  end
+
+  def test_stuff_waits
+    Timecop.freeze TIME do
+      @scheduler.schedule! "a", (TIME + 100)
+      got_item = false
+      @scheduler.each { got_item = true }
+      assert !got_item
+    end
+
+    Timecop.freeze(TIME + 50) do
+      got_item = false
+      @scheduler.each { got_item = true }
+      assert !got_item
+    end
+
+    Timecop.freeze(TIME + 100) do
+      got_item = false
+      @scheduler.each { got_item = true }
+      assert got_item
+    end
+  end
+
+  def test_can_get_items_later_than_their_timestamp
+    Timecop.freeze TIME do
+      @scheduler.schedule! "a", (TIME + 100)
+    end
+
+    Timecop.freeze(TIME + 200) do
+      got_item = false
+      @scheduler.each { got_item = true }
+      assert got_item
+    end
+  end
+
+  def test_ordering_is_based_on_timestamp
+    Timecop.freeze TIME do
+      @scheduler.schedule! "b", (TIME + 101)
+      @scheduler.schedule! "a", (TIME + 100)
+
+      el, ts = @scheduler.items[0]
+      assert_equal "a", el
+      assert_equal TIME + 100, ts
+
+      el, ts = @scheduler.items[1]
+      assert_equal "b", el
+      assert_equal TIME + 101, ts
+
+      assert_equal [["a", TIME + 100], ["b", TIME + 101]], @scheduler.items[0, 2]
+    end
+  end
+
+  def test_can_schedule_same_item_multiple_times
+    Timecop.freeze TIME do
+      @scheduler.schedule! "a", (TIME + 101)
+      @scheduler.schedule! "a", (TIME + 100)
+
+      assert_equal [["a", TIME + 100], ["a", TIME + 101]], @scheduler.items[0, 2]
+    end
+  end
+
+  def test_uniq_schedules_update_items_rather_than_representing_them_multiple_times
+    Timecop.freeze TIME do
+      @uniq_scheduler.schedule! "a", (TIME + 101)
+      @uniq_scheduler.schedule! "a", (TIME + 100)
+
+      assert_equal [["a", TIME + 100]], @uniq_scheduler.items[0, 2]
+    end
+  end
+
+  def test_oldest_always_wins
+    Timecop.freeze TIME do
+      @scheduler.schedule! "a", (TIME + 101)
+    end
+
+    Timecop.freeze(TIME + 50) do
+      @scheduler.schedule! "b", (TIME + 100)
+    end
+
+    Timecop.freeze(TIME + 200) do
+      items = []
+      @scheduler.each do |item, ts|
+        items << item
+      end
+
+      assert_equal ["b", "a"], items
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-scheduler
 version: !ruby/object:Gem::Version
-  version: '0.7'
+  version: '0.8'
 platform: ruby
 authors:
 - William Morgan
@@ -10,9 +10,9 @@ bindir: bin
 cert_chain: []
 date: 2014-07-28 00:00:00.000000000 Z
 dependencies: []
-description: A basic chronological scheduler for Redis. Add work items to be processed
-  at specific times in the future, and easily retrieve all items that are ready for
-  processing.
+description: |-
+  A simple, production-ready chronological scheduler for Redis. It allows you to schedule items to be processed at arbitrary points in the future, and easily
+  retrieve only those items that are due to be processed.
 email: wmorgan-redis-scheduler@masanjin.net
 executables: []
 extensions: []
@@ -21,6 +21,7 @@ files:
 - README
 - COPYING
 - lib/redis-scheduler.rb
+- test/redis-scheduler.rb
 homepage: http://gitub.com/wmorgan/redis-scheduler
 licenses: []
 metadata: {}