deferrer 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3177ff9473fe3ddecdc6579a2adcde3fa02112f5
-  data.tar.gz: de0bbbd3540ec14e50061ed917d633dd27be62d1
+  metadata.gz: 47517fb6ffc62ca2b600c64f1a0a5ae5e2379239
+  data.tar.gz: 06110ea8a1dbdf20002f5627798a33ac5fd550e8
 SHA512:
-  metadata.gz: 5db8302690c0707b3d0ce6ae0ef03c87e26be05024565bd579121deb222cc4987788fd832d7366842a1d56e32acaea1abfc9702fef965c5c513e05427522f04c
-  data.tar.gz: f3cd63d60f6d37c4275781fb58a0ace53dcb730b5af152744de7059000ec4d2f4b9fc84785e5bbe45efc05d51ace50bf893a84938b18b8ddee1d1ee99f8620a2
+  metadata.gz: 47f4549a640efb122f2726e3fdf052c7f9998f748d978f608cd440f74c8b5b352a157918423a5001d4f5688c617ca30a3fa89256c5d879e80e4cbece5cade884
+  data.tar.gz: 1f330b0d1a8e6bae1a27dbb66fb0c69b5c0b83ca1818d4a3012ff2ef11738f34ff032753f55701d39548ce887cff9082a2f0a50cea7af87e620f0ed875f0ad3f

data/README.md

@@ -2,64 +2,86 @@
 
 # Deferrer
 
-Defer executions and run only the last update at the scheduled time
-
+Deferrer is a library for deferring work units for a time period or to a specific time. When time reaches, only the last work unit will be processed. Usually, the last work unit should be the one that summarizes all the previous ones. An example scenario would be sending live updates that happen *very* frequently and we want to limit them by sending an update every x seconds.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'deferrer'
+```
+gem 'deferrer'
+```
 
 And then execute:
 
-    $ bundle install
+```
+$ bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install deferrer
-
+```
+$ gem install deferrer
+```
 
 
 ## Usage
 
-Configure redis
+Configure deferrer (redis connection, logger)
+
+```ruby
+Deferrer.redis_config = { :host => "localhost", :port => 6379 }
+Deferrer.logger = Logger.new(STDOUT)
+```
+
+
+Define deferrer worker that must respond to call method
+
+```ruby
+Deferrer.worker = lambda do |klass, *args|
+  # do some work
+  # Resque.enqueue(klass, *args)
+end
+```
 
-    Deferrer.redis_config = { :host => "localhost", :port => 6379 }
+Deferrer is usually used in combination with background processing tools like sidekiq and resque. If that's the case, Deferrer.worker can be light-weight and responsible only for pushing work to a background job.
 
 
-Define deferrer class (must have perform class method)
+Start a worker process.
 
-    class NameDeferrer
-      def self.perform(first_name, last_name)
-        puts "#{first_name} #{last_name}".upcase
-      end
-    end
+```ruby
+Deferrer.run(options = {})
 
+# Following `options` are available:
+#   loop_frequency - sleep between loops, default to 0.1 seconds
+#   single_run     - process items only for a single loop, useful for testing
+#   ignore_time    - don't wait for time period to expire, useful for testing
+```
 
-Start a worker process. It needs to have redis configured and access to deferrer classes.
 
-    Deferrer.run(options = {})
+Defer some executions:
 
-    # Following `options` are available:
-    #   loop_frequency - sleep between loops, default to 0.1 seconds
-    #   logger         - logging mechanism, needs to respond to `info` and `error`
-    #   before_each    - callback to run before processing an item, needs to respond to `call`
-    #   after_each     - callback to run after processing an item, needs to respond to `call`
-    #   single_run     - process items only for a single loop, useful for testing
+```ruby
+Deferrer.defer_in(5, 'identifier', Worker, 'update 1')
+Deferrer.defer_in(6, 'identifier', Worker, 'update 2')
+Deferrer.defer_in(9, 'identifier', Worker, 'update 3')
+```
 
 
-Defer some executions
+It will stack all defered executions per identifier until first timeout expires (5 seconds) and then it will only execute the last update for the expired identifier, calling the deferrer worker:
 
-    Deferrer.defer_in(5, 'identifier', NameDeferrer, 'User', '1')
-    Deferrer.defer_in(6, 'identifier', NameDeferrer, 'User', '2')
-    Deferrer.defer_in(9, 'identifier', NameDeferrer, 'User', '3')
+```ruby
+Deferrer.worker.call('Worker', 'update 3')
+```
 
 
-It will stack all defered executions per identifier until first timeout expires (5 seconds) and then it will only execute the last update for the expired identifier:
+## Testing
 
-    NameDeferrer.perform('User', '3') => USER 3
+For testing, two options of the `run` method are useful. `single_run` will run the loop only once and `ignore_time` will not wait for time period to expire but execute to job now.
 
+```ruby
+Deferrer.run(single_run: true, ignore_time: true)
+```
 
 
 ## Contributing

data/deferrer.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Deferrer::VERSION
   spec.authors       = ["Dalibor Nasevic"]
   spec.email         = ["dalibor.nasevic@gmail.com"]
-  spec.description   = %q{Defer executions and run only the last update}
-  spec.summary       = %q{Defer executions and run only the last update at the scheduled time}
+  spec.description   = %q{Defer work units and process only the last one}
+  spec.summary       = %q{Defer work units and process only the last work unit when time comes}
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -22,5 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "multi_json"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 2.14.1"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
 end

data/example/client.rb

@@ -1,8 +1,6 @@
 require 'deferrer'
-require_relative './name_deferrer'
+require_relative './common'
 
-Deferrer.redis_config = { :host => "localhost", :port => 6379 }
-
-Deferrer.defer_in(5, 'identifier', NameDeferrer, 'User', '1')
-Deferrer.defer_in(6, 'identifier', NameDeferrer, 'User', '2')
-Deferrer.defer_in(9, 'identifier', NameDeferrer, 'User', '3')
+1.upto(5) do |i|
+  Deferrer.defer_in(i + 3, 'identifier', "update #{i}")
+end

data/example/common.rb

@@ -0,0 +1,2 @@
+# setup redis
+Deferrer.redis_config = { :host => "localhost", :port => 6379, db: 15 }

data/example/runner.rb

@@ -1,21 +1,14 @@
 require 'deferrer'
-require_relative './name_deferrer'
-
-Deferrer.redis_config = { :host => "localhost", :port => 6379 }
-
-class Logger
-  def self.info(message)
-    puts "INFO: #{message}"
-  end
-
-  def self.error(message)
-    puts "ERROR: #{message}"
-  end
-end
+require 'logger'
+require_relative './common'
 
 puts 'Runner started'
 
+Deferrer.redis_config = { :host => "localhost", :port => 6379, :db => 15 }
+Deferrer.logger = Logger.new(STDOUT)
+Deferrer.worker = lambda do |*args|
+  p args
+end
 Deferrer.run({
   :loop_frequency => 0.5,
-  :logger => Logger
 })

data/lib/deferrer.rb

@@ -2,12 +2,21 @@ require 'redis'
 require "deferrer/version"
 
 module Deferrer
-
   autoload :Configuration, 'deferrer/configuration'
   autoload :JsonEncoding,  'deferrer/json_encoding'
-  autoload :Deferral,      'deferrer/deferral'
+  autoload :Runner,        'deferrer/runner'
+  autoload :Job,           'deferrer/job'
+
+  LIST_KEY        = 'deferred_list'
+  ITEM_KEY_PREFIX = 'deferred'
 
   extend Configuration
   extend JsonEncoding
-  extend Deferral
+  extend Runner
+
+  class WorkerNotConfigured < NotImplementedError
+    def initialize
+      super("Deferrer worker not configured")
+    end
+  end
 end

data/lib/deferrer/configuration.rb

@@ -1,14 +1,13 @@
 module Deferrer
   module Configuration
 
+    attr_reader :redis
+    attr_accessor :logger
+    attr_accessor :worker
+
     # Deferrer.redis_config = { :host => "localhost", :port => 6379 }
     def redis_config=(config)
       @redis = Redis.new(config)
     end
-
-    # Returns the configured Redis instance
-    def redis
-      @redis
-    end
   end
 end

data/lib/deferrer/json_encoding.rb

@@ -3,18 +3,12 @@ require 'multi_json'
 module Deferrer
   module JsonEncoding
 
-    class DecodeException < StandardError; end
-
     def encode(item)
       MultiJson.dump(item)
     end
 
     def decode(item)
-      begin
-        MultiJson.load(item)
-      rescue ::MultiJson::DecodeError => e
-        raise DecodeException, e.message, e.backtrace
-      end
+      MultiJson.load(item)
     end
   end
 end

data/lib/deferrer/runner.rb

@@ -0,0 +1,103 @@
+module Deferrer
+  module Runner
+    def run(options = {})
+      loop_frequency = options.fetch(:loop_frequency, 0.1)
+      single_run     = options.fetch(:single_run, false)
+      @ignore_time   = options.fetch(:ignore_time, false)
+
+      raise WorkerNotConfigured unless worker
+
+      loop do
+        begin
+          while item = next_item
+            process_item(item)
+          end
+        rescue StandardError => e
+          log(:error, "Error: #{e.class}: #{e.message}")
+        rescue Exception => e
+          log(:error, "Error: #{e.class}: #{e.message}")
+          raise
+        end
+
+        break if single_run
+        sleep loop_frequency
+      end
+    end
+
+    def next_item
+      item         = nil
+      decoded_item = nil
+      key          = next_key
+
+      if key
+        item = redis.rpop(key)
+        if item
+          decoded_item = decode(item)
+          decoded_item['key'] = key
+        end
+
+        remove(key)
+      end
+
+      decoded_item
+    end
+
+    def defer_in(number_of_seconds_from_now, identifier, *args)
+      timestamp = Time.now + number_of_seconds_from_now
+      defer_at(timestamp, identifier, *args)
+    end
+
+    def defer_at(timestamp, identifier, *args)
+      key  = item_key(identifier)
+      item = { 'args' => args }
+
+      push_item(key, item, timestamp)
+    end
+
+    private
+    def process_item(item)
+      log(:info, "Processing: #{item['key']}")
+      worker.call(*item['args'])
+    end
+
+    def item_key(identifier)
+      "#{ITEM_KEY_PREFIX}:#{identifier}"
+    end
+
+    def push_item(key, item, timestamp)
+      count = redis.rpush(key, encode(item))
+
+      # set score only on first update
+      if count == 1
+        score = calculate_score(timestamp)
+        redis.zadd(LIST_KEY, score, key)
+      end
+    end
+
+    def next_key
+      if @ignore_time
+        redis.zrange(LIST_KEY, 0, 1).first
+      else
+        score = calculate_score(Time.now)
+        redis.zrangebyscore(LIST_KEY, '-inf', score, :limit => [0, 1]).first
+      end
+    end
+
+    def calculate_score(timestamp)
+      timestamp.to_f
+    end
+
+    def remove(key)
+      redis.watch(key)
+      redis.multi do
+        redis.del(key)
+        redis.zrem(LIST_KEY, key)
+      end
+      redis.unwatch
+    end
+
+    def log(type, message)
+      logger.send(type, message) if logger
+    end
+  end
+end

data/lib/deferrer/version.rb

@@ -1,3 +1,3 @@
 module Deferrer
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/spec/deferrer/runner_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+require 'logger'
+
+describe Deferrer::Runner do
+  let(:identifier) { 'some_identifier' }
+  let(:redis) { Deferrer.redis }
+  let(:list_key) { Deferrer::LIST_KEY }
+  let(:logger) { Logger.new(STDOUT) }
+
+  describe ".run" do
+    it "processes jobs" do
+      expect(Deferrer.worker).to receive(:call).with('TestWorker', 'test')
+
+      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      Deferrer.run(single_run: true)
+    end
+
+    it "correctly sets arguments and converts symbols to strings for hashes" do
+      expect(Deferrer.worker).to receive(:call).with('TestWorker', 1, 'arg1', { "a" => "b"})
+
+      Deferrer.defer_in(-1, identifier, 'TestWorker', 1, 'arg1', { a: :b })
+      Deferrer.run(single_run: true)
+    end
+
+    it "rescues standard errors" do
+      allow(Deferrer).to receive(:next_item) { raise RuntimeError.new('error') }
+
+      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      Deferrer.run(single_run: true)
+    end
+
+    it "rescues exceptions and logs error messages" do
+      expect(logger).to receive(:error).with("Error: Exception: error")
+      allow(Deferrer).to receive(:next_item) { raise Exception.new('error') }
+
+      Deferrer.logger = logger
+      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      expect { Deferrer.run(single_run: true) }.to raise_error(Exception)
+    end
+
+    it "raises error if worker not configured" do
+      Deferrer.worker = nil
+      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+
+      expect { Deferrer.run(single_run: true) }.to raise_error(Deferrer::WorkerNotConfigured)
+    end
+
+    it "ignores time to wait and performs jobs" do
+      expect(Deferrer.worker).to receive(:call).with('Worker', { "c" => "d"})
+
+      Deferrer.defer_in(100, identifier, 'Worker', { a: :b })
+      Deferrer.defer_in(100, identifier, 'Worker', { c: :d })
+
+      Deferrer.run(single_run: true, ignore_time: true)
+    end
+  end
+
+  describe ".defer_at" do
+    it "deferrs at given time" do
+      Deferrer.defer_at(Time.now, identifier, 'TestWorker', 'test')
+
+      expect(redis.zrangebyscore(list_key, '-inf', Time.now.to_f, :limit => [0, 1]).first).not_to be_nil
+      expect(redis.exists(item_key(identifier))).to be_truthy
+    end
+  end
+
+  describe ".defer_in" do
+    it "defers in given interval" do
+      Deferrer.defer_in(1, identifier, 'TestWorker', 'test')
+
+      expect(redis.zrangebyscore(list_key, '-inf', (Time.now + 1).to_f, :limit => [0, 1]).first).not_to be_nil
+      expect(redis.exists(item_key(identifier))).to be_truthy
+    end
+  end
+
+  describe ".next_item" do
+    it "returns the next item" do
+      Deferrer.defer_at(Time.now, identifier, 'TestWorker', 'test')
+
+      item = Deferrer.next_item
+
+      expect(item['args']).to eq(['TestWorker', 'test'])
+    end
+
+    it "returns last update of an item" do
+      Deferrer.defer_at(Time.now - 3, identifier, 'TestWorker', 'update1')
+      Deferrer.defer_at(Time.now - 2, identifier, 'TestWorker', 'update2')
+
+      item = Deferrer.next_item
+
+      expect(item['args']).to eq(['TestWorker', 'update2'])
+    end
+
+    it "returns nil when no next item" do
+      expect(Deferrer.next_item).to be_nil
+    end
+
+    it "removes values from redis" do
+      Deferrer.defer_at(Time.now, identifier, 'TestWorker', 'test')
+
+      item = Deferrer.next_item
+
+      expect(redis.zrangebyscore(list_key, '-inf', Time.now.to_f, :limit => [0, 1]).first).to be_nil
+      expect(redis.exists(item_key(identifier))).to be_falsey
+      expect(Deferrer.next_item).to be_nil
+    end
+
+    it "doesn't block on empty lists" do
+      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      redis.del(item_key(identifier))
+
+      expect(Deferrer.next_item).to be_nil
+      expect(redis.zrangebyscore(list_key, '-inf', 'inf', :limit => [0, 1]).first).to be_nil
+    end
+  end
+
+  describe ".logger" do
+    before :each do
+      Deferrer.logger = logger
+    end
+
+    it "logs info messages" do
+      expect(logger).to receive(:info).with("Processing: deferred:#{identifier}")
+
+      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      Deferrer.run(single_run: true)
+    end
+
+    it "logs error messages" do
+      expect(logger).to receive(:error).with("Error: RuntimeError: error")
+      allow(Deferrer).to receive(:next_item) { raise RuntimeError.new('error') }
+
+      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      Deferrer.run(single_run: true)
+    end
+
+    it "logs error messages on exceptions" do
+      expect(logger).to receive(:error).with("Error: Exception: error")
+      allow(Deferrer).to receive(:next_item) { raise Exception.new('error') }
+
+      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      expect { Deferrer.run(single_run: true) }.to raise_error
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,21 @@
 require 'deferrer'
 
 Deferrer.redis_config = { :host => "localhost", :port => 6379 }
+
+
+ROOT = File.expand_path('../', File.dirname(__FILE__))
+
+# Load support files
+Dir["#{ROOT}/spec/support/**/*.rb"].each { |f| require f }
+
+
+RSpec.configure do |config|
+  config.include Helpers
+
+  config.before :each do
+    Deferrer.redis.flushdb
+    Deferrer.logger = nil
+    Deferrer.worker = lambda { |klass, *args| }
+  end
+end
+

data/spec/support/helpers.rb

@@ -0,0 +1,5 @@
+module Helpers
+  def item_key(identifier)
+    "#{Deferrer::ITEM_KEY_PREFIX}:#{identifier}"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deferrer
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Dalibor Nasevic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-08 00:00:00.000000000 Z
+date: 2014-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -72,15 +72,15 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.1
-description: Defer executions and run only the last update
+        version: 3.0.0
+description: Defer work units and process only the last one
 email:
 - dalibor.nasevic@gmail.com
 executables: []
@@ -97,15 +97,16 @@ files:
 - deferrer.gemspec
 - example/README.md
 - example/client.rb
-- example/name_deferrer.rb
+- example/common.rb
 - example/runner.rb
 - lib/deferrer.rb
 - lib/deferrer/configuration.rb
-- lib/deferrer/deferral.rb
 - lib/deferrer/json_encoding.rb
+- lib/deferrer/runner.rb
 - lib/deferrer/version.rb
-- spec/deferrer/deferral_spec.rb
+- spec/deferrer/runner_spec.rb
 - spec/spec_helper.rb
+- spec/support/helpers.rb
 homepage: ''
 licenses:
 - MIT
@@ -129,8 +130,9 @@ rubyforge_project:
 rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
-summary: Defer executions and run only the last update at the scheduled time
+summary: Defer work units and process only the last work unit when time comes
 test_files:
-- spec/deferrer/deferral_spec.rb
+- spec/deferrer/runner_spec.rb
 - spec/spec_helper.rb
+- spec/support/helpers.rb
 has_rdoc: 

data/example/name_deferrer.rb

@@ -1,9 +0,0 @@
-# setup redis
-Deferrer.redis_config = { :host => "localhost", :port => 6379 }
-
-# define deferrer class (must have perform class method)
-class NameDeferrer
-  def self.perform(first_name, last_name)
-    puts "#{first_name} #{last_name}".upcase
-  end
-end

data/lib/deferrer/deferral.rb

@@ -1,100 +0,0 @@
-module Deferrer
-  module Deferral
-
-    LIST_KEY = :deferred_list
-
-    def run(options = {})
-      loop_frequency = options.fetch(:loop_frequency, 0.1)
-      logger         = options.fetch(:logger, nil)
-      before_each    = options.fetch(:before_each, nil)
-      after_each     = options.fetch(:after_each, nil)
-      single_run     = options.fetch(:single_run, false)
-
-      loop do
-        while item = next_item
-          process_item(item, logger, before_each, after_each)
-        end
-
-        break if single_run
-        sleep loop_frequency
-      end
-    end
-
-    def next_item
-      item = nil
-      decoded_item = nil
-      score = calculate_score(Time.now)
-
-      key = redis.zrangebyscore(LIST_KEY, '-inf', score, :limit => [0, 1]).first
-
-      if key
-        item = redis.rpop(key)
-        if item
-          decoded_item = decode(item)
-          decoded_item['key'] = key
-        end
-
-        remove(key)
-      end
-
-      decoded_item
-    end
-
-    def constantize(klass_string)
-      klass_string.split('::').inject(Object) {|memo,name| memo = memo.const_get(name); memo}
-    end
-
-    def defer_in(number_of_seconds_from_now, identifier, klass, *args)
-      timestamp = Time.now + number_of_seconds_from_now
-      defer_at(timestamp, identifier, klass, *args)
-    end
-
-    def defer_at(timestamp, identifier, klass, *args)
-      item = build_item(klass, args)
-      key = item_key(identifier)
-      score = calculate_score(timestamp)
-
-      count = redis.rpush(key, encode(item))
-
-      # set score only on first update
-      if count == 1
-        redis.zadd(LIST_KEY, score, key)
-      end
-    end
-
-    def item_key(identifier)
-      "deferred:#{identifier}"
-    end
-
-    private
-    def process_item(item, logger, before_each, after_each)
-      before_each.call if before_each
-      klass = constantize(item['class'])
-      args  = item['args']
-
-      logger.info("Executing: #{item['key']}") if logger
-
-      klass.send(:perform, *args)
-      after_each.call if after_each
-    rescue Exception => e
-      logger.error("Error: #{e.class}: #{e.message}") if logger
-    end
-
-    def build_item(klass, args)
-      {'class' => klass.to_s, 'args' => args}
-    end
-
-    def calculate_score(timestamp)
-      timestamp.to_f
-    end
-
-    def remove(key)
-      redis.watch(key)
-      redis.multi do
-        redis.del(key)
-        redis.zrem(LIST_KEY, key)
-      end
-      redis.unwatch
-    end
-  end
-end

data/spec/deferrer/deferral_spec.rb

@@ -1,133 +0,0 @@
-require 'spec_helper'
-require 'timeout'
-
-class CarDeferrer
-  def self.perform(car)
-  end
-
-  def self.callback
-  end
-end
-
-class Logger
-  def self.info(message)
-  end
-
-  def self.error(message)
-  end
-end
-
-class InvalidLogger
-  def self.error(message)
-  end
-end
-
-describe Deferrer::Deferral do
-  let(:car) { 'car' }
-  let(:car2) { 'car2' }
-  let(:identifier) { 'car1' }
-  let(:redis) { Deferrer.redis }
-  let(:list_key) { Deferrer::Deferral::LIST_KEY }
-
-  before :each do
-    redis.flushdb
-  end
-
-  describe "run" do
-    it "processes jobs" do
-      CarDeferrer.should_receive(:perform).with(car)
-      Deferrer.defer_in(-1, identifier, CarDeferrer, car)
-      Deferrer.run(single_run: true)
-    end
-
-    it "logs info messages if logger provided" do
-      Logger.should_receive(:info).with("Executing: deferred:#{identifier}")
-      Deferrer.defer_in(-1, identifier, CarDeferrer, car)
-      Deferrer.run(single_run: true, logger: Logger)
-    end
-
-    it "logs error messages if logger provided" do
-      InvalidLogger.should_receive(:error).with("Error: NoMethodError: undefined method `info' for InvalidLogger:Class")
-      Deferrer.defer_in(-1, identifier, CarDeferrer, car)
-      Deferrer.run(single_run: true, logger: InvalidLogger)
-    end
-
-    it "runs before callback" do
-      CarDeferrer.should_receive(:callback)
-      Deferrer.defer_in(-1, identifier, CarDeferrer, car)
-      Deferrer.run(single_run: true, before_each: Proc.new { CarDeferrer.callback })
-    end
-
-    it "runs after callback" do
-      CarDeferrer.should_receive(:callback)
-      Deferrer.defer_in(-1, identifier, CarDeferrer, car)
-      Deferrer.run(single_run: true, after_each: Proc.new { CarDeferrer.callback })
-    end
-  end
-
-  describe ".defer_at" do
-    it "deferrs at given time" do
-      Deferrer.defer_at(Time.now, identifier, CarDeferrer, car)
-
-      redis.zrangebyscore(list_key, '-inf', Time.now.to_f, :limit => [0, 1]).first.should_not be_nil
-      redis.exists(Deferrer.item_key(identifier)).should be_true
-    end
-
-    it "defers in given interval" do
-      Deferrer.defer_in(1, identifier, CarDeferrer, car)
-
-      redis.zrangebyscore(list_key, '-inf', (Time.now + 1).to_f, :limit => [0, 1]).first.should_not be_nil
-      redis.exists(Deferrer.item_key(identifier)).should be_true
-    end
-  end
-
-  describe ".next_item" do
-    it "returns the next item" do
-      Deferrer.defer_at(Time.now, identifier, CarDeferrer, car)
-
-      item = Deferrer.next_item
-
-      item['class'].should == CarDeferrer.to_s
-      item['args'].should == [car]
-    end
-
-    it "returns last update of an item" do
-      Deferrer.defer_at(Time.now - 3, identifier, CarDeferrer, car)
-      Deferrer.defer_at(Time.now - 2, identifier, CarDeferrer, car2)
-
-      item = Deferrer.next_item
-
-      item['class'].should == CarDeferrer.to_s
-      item['args'].should == [car2]
-    end
-
-    it "keep the old score value" do
-      Deferrer.defer_at(Time.now - 3, identifier, CarDeferrer, car)
-      Deferrer.defer_at(Time.now + 1, identifier, CarDeferrer, car2)
-
-      Deferrer.next_item.should_not be_nil
-    end
-
-    it "returns nil when no next item" do
-      Deferrer.next_item.should be_nil
-    end
-
-    it "removes values from redis" do
-      Deferrer.defer_at(Time.now, identifier, CarDeferrer, car)
-
-      item = Deferrer.next_item
-
-      redis.zrangebyscore(list_key, '-inf', Time.now.to_f, :limit => [0, 1]).first.should be_nil
-      redis.exists(Deferrer.item_key(identifier)).should be_false
-      Deferrer.next_item.should be_nil
-    end
-
-    it "doesn't block on empty lists" do
-      Deferrer.defer_in(-1, identifier, CarDeferrer, car)
-      redis.del Deferrer.item_key(identifier)
-
-      Timeout::timeout(2) { Deferrer.next_item.should be_nil }
-      redis.zrangebyscore(list_key, '-inf', 'inf', :limit => [0, 1]).first.should be_nil
-    end
-  end
-end