deferrer 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 455d09ae4793d235d895e80dff0d81f90bbef7ef
-  data.tar.gz: ba33ec69ad5f8d7144c3235585e436141e0fe21d
+  metadata.gz: 1bc1f7b9f8b06d8c607e75b51a267f77b017e493
+  data.tar.gz: b5ace0f90bf10f7ab04e8bfefa63fdd22fbef02c
 SHA512:
-  metadata.gz: a05628c41c9700e8330db18872f32c9d42c53843407aa8c8dd92997c67115b5e66766640992c20998e81ea3276cc9f189a47b04340eb1bd0f986f334b3187e69
-  data.tar.gz: 16906be529bd41cd0e5ec9304f5749a004f20d55fa5078a464a9bd91f9c382c5620a39a590077aed05ff630dc2e951bd0d0117421456b09b6a4fa9b42b6fac8a
+  metadata.gz: 424bb4d6787044ae36c91f1e05da72dc7c25700a0a9862e87a0fd493a617593046d4202cc129ba8781f5122e57664ace03e1a1ef829e88839dcc782422a25bdb
+  data.tar.gz: 978dbb2dceed7aa36ffe56a9906bdaba02d998b3cc168874a70fcbfb4dfeb382c6f5f0d39f6050e58ad736c418186294314608c0bdc230036e49f5cd51325f06

data/README.md

@@ -35,19 +35,21 @@ Deferrer.logger = Logger.new(STDOUT)
 ```
 
 
-Define deferrer worker that must respond to call method
+Define Deferrer worker (must respond to peform method):
 
 ```ruby
-Deferrer.worker = lambda do |klass, *args|
-  # do some work
-  # Resque.enqueue(klass, *args)
+class WorkDeferrer
+  include Deferrer::Worker
+
+  def perform(*args)
+  end
 end
 ```
 
-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.
+Deferrer is usually used in combination with background processing tools like sidekiq and resque where the Deferrer worker is a light-weight worker that just pushed jobs on the queue.
 
 
-Start a worker process.
+Start the runner.
 
 ```ruby
 Deferrer.run(options = {})
@@ -58,20 +60,19 @@ Deferrer.run(options = {})
 #   ignore_time    - don't wait for time period to expire, useful for testing
 ```
 
-
 Defer some executions:
 
 ```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')
+WorkDeferrer.perform_in(5, 'identifier', 'update 1')
+WorkDeferrer.perform_in(6, 'identifier', 'update 2')
+WorkDeferrer.perform_in(9, 'identifier', 'update 3')
 ```
 
 
-It will stack all defered executions per identifier until first timeout expires (5 seconds) and then it will only process the last update for the expired identifier, calling the deferrer worker:
+It will stack all defered work units per identifier until first timeout expires (5 seconds) and then it will only process the last update for the expired identifier, calling the deferrer worker:
 
 ```ruby
-Deferrer.worker.call('Worker', 'update 3')
+WorkDeferrer.new.perform('update 3')
 ```
 
 

data/example/client.rb

@@ -2,5 +2,5 @@ require 'deferrer'
 require_relative './common'
 
 1.upto(5) do |i|
-  Deferrer.defer_in(i + 3, 'identifier', "update #{i}")
+  WorkDeferrer.perform_in(i + 3, 'identifier', "update #{i}")
 end

data/example/common.rb

@@ -1,2 +1,10 @@
 # setup redis
 Deferrer.redis_config = { :host => "localhost", :port => 6379, db: 15 }
+
+class WorkDeferrer
+  include Deferrer::Worker
+
+  def perform(update)
+    p update
+  end
+end

data/example/runner.rb

@@ -6,9 +6,6 @@ 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,
 })

data/lib/deferrer.rb

@@ -3,20 +3,12 @@ require "deferrer/version"
 
 module Deferrer
   autoload :Configuration, 'deferrer/configuration'
-  autoload :JsonEncoding,  'deferrer/json_encoding'
   autoload :Runner,        'deferrer/runner'
-  autoload :Job,           'deferrer/job'
-
-  LIST_KEY        = 'deferred_list'
-  ITEM_KEY_PREFIX = 'deferred'
+  autoload :Worker,        'deferrer/worker'
+  autoload :Item,          'deferrer/item'
+  autoload :Queue,         'deferrer/queue'
+  autoload :Processor,     'deferrer/processor'
 
   extend Configuration
-  extend JsonEncoding
   extend Runner
-
-  class WorkerNotConfigured < NotImplementedError
-    def initialize
-      super("Deferrer worker not configured")
-    end
-  end
 end

data/lib/deferrer/configuration.rb

@@ -3,12 +3,15 @@ module Deferrer
 
     attr_reader :redis
     attr_accessor :logger
-    attr_accessor :worker
     attr_accessor :inline
 
     # Deferrer.redis_config = { :host => "localhost", :port => 6379 }
     def redis_config=(config)
       @redis = Redis.new(config)
     end
+
+    def log(type, message)
+      logger.send(type, message) if logger
+    end
   end
 end

data/lib/deferrer/item.rb

@@ -0,0 +1,32 @@
+require 'multi_json'
+
+module Deferrer
+  class Item
+
+    attr_reader :id, :class_name, :args
+
+    def self.from_json(json)
+      item = MultiJson.load(json)
+      new(item['id'], item['class'], item['args'])
+    end
+
+    def initialize(id, class_name, args)
+      @id         = id
+      @class_name = class_name
+      @args       = args
+    end
+
+    def to_json
+      MultiJson.dump(to_hash)
+    end
+
+    def to_hash
+      { 'id' => id, 'class' => class_name, 'args' => args }
+    end
+
+    def ==(object)
+      object.id == self.id
+    end
+  end
+end
+

data/lib/deferrer/processor.rb

@@ -0,0 +1,23 @@
+module Deferrer
+  class Processor
+
+    def initialize(item)
+      @item = item
+    end
+
+    def process
+      Deferrer.log(:info, "Processing: #{@item.id}")
+      klass = constantize(@item.class_name)
+      klass.new.send(:perform, *@item.args)
+    end
+
+    private
+    def constantize(klass_string)
+      klass_string.split('::').inject(Object) do |object, name|
+        object = object.const_get(name)
+        object
+      end
+    end
+  end
+end
+

data/lib/deferrer/queue.rb

@@ -0,0 +1,73 @@
+module Deferrer
+  class Queue
+    LIST_KEY        = 'deferred_list'
+    ITEM_KEY_PREFIX = 'deferred'
+
+    class << self
+      def push(item, timestamp)
+        key = item_key(item.id)
+        count = redis.rpush(key, item.to_json)
+
+        # set score only on first update
+        if count == 1
+          score = calculate_score(timestamp)
+          redis.zadd(LIST_KEY, score, key)
+        end
+      end
+
+      def pop(ignore_time = false)
+        find(next_key(ignore_time))
+      end
+
+      def find_by_id(id)
+        return nil unless id
+        find(item_key(id))
+      end
+
+      def find(key)
+        return nil unless key
+
+        item = nil
+
+        if json = redis.rpop(key)
+          item = Item.from_json(json)
+        end
+
+        remove(key)
+
+        item
+      end
+
+      private
+      def next_key(ignore_time)
+        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 remove(key)
+        redis.watch(key)
+        redis.multi do
+          redis.del(key)
+          redis.zrem(LIST_KEY, key)
+        end
+        redis.unwatch
+      end
+
+      def calculate_score(timestamp)
+        timestamp.to_f
+      end
+
+      def item_key(id)
+        "#{ITEM_KEY_PREFIX}:#{id}"
+      end
+
+      def redis
+        Deferrer.redis
+      end
+    end
+  end
+end

data/lib/deferrer/runner.rb

@@ -1,17 +1,15 @@
 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)
-      @inline        = options.fetch(:inline, false)
-
-      raise WorkerNotConfigured unless worker
+      ignore_time    = options.fetch(:ignore_time, false)
 
       loop do
         begin
-          while item = next_item
-            process_item(item)
+          while item = Deferrer::Queue.pop(ignore_time)
+            Processor.new(item).process
           end
         rescue StandardError => e
           log(:error, "Error: #{e.class}: #{e.message}")
@@ -24,82 +22,5 @@ module Deferrer
         sleep loop_frequency
       end
     end
-
-    def next_item(key = next_key)
-      return nil unless key
-
-      item         = nil
-      decoded_item = nil
-
-      item = redis.rpop(key)
-      if item
-        decoded_item = decode(item)
-        decoded_item['key'] = key
-      end
-
-      remove(key)
-
-      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)
-
-      process_item(next_item(key)) if @inline
-    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.1.1"
+  VERSION = "0.2.0"
 end

data/lib/deferrer/worker.rb

@@ -0,0 +1,25 @@
+module Deferrer
+  module Worker
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def perform_in(number_of_seconds_from_now, id, *args)
+        timestamp = Time.now + number_of_seconds_from_now
+        perform_at(timestamp, id, *args)
+      end
+
+      def perform_at(timestamp, id, *args)
+        item = Item.new(id, name, args)
+        Deferrer::Queue.push(item, timestamp)
+
+        if Deferrer.inline
+          item = Deferrer::Queue.find_by_id(item.id)
+          Processor.new(item).process
+        end
+      end
+    end
+  end
+end

data/spec/deferrer/item_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Deferrer::Item do
+
+  let(:item_hash) { {'id' => 1, 'class' => 'TestWorker', 'args' => [1, 2]} }
+  let(:item_json) { MultiJson.dump(item_hash) }
+
+  it "can create a new" do
+    item = Deferrer::Item.new(1, 'TestWorker', [1, 2])
+    expect(item.id).to eq(1)
+    expect(item.class_name).to eq('TestWorker')
+    expect(item.args).to eq([1, 2])
+  end
+
+  it "can create new item from json" do
+    item = Deferrer::Item.from_json(item_json)
+
+    expect(item.id).to eq(1)
+    expect(item.class_name).to eq('TestWorker')
+    expect(item.args).to eq([1, 2])
+  end
+
+  it "can test if two objects are equal" do
+    item1 = Deferrer::Item.new(1, 'TestWorker', [1, 2])
+    item2 = Deferrer::Item.from_json(item_json)
+
+    expect(item1).to eq(item2)
+  end
+
+  it "can convert to hash" do
+    item = Deferrer::Item.new(1, 'TestWorker', [1, 2])
+    expect(item.to_hash).to eq(item_hash)
+  end
+
+  it "can convert to json" do
+    item = Deferrer::Item.new(1, 'TestWorker', [1, 2])
+    expect(item.to_json).to eq(item_json)
+  end
+end

data/spec/deferrer/processor_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Deferrer::Processor do
+  it "can process item" do
+    expect_any_instance_of(TestWorker).to receive(:perform).with(1, 2)
+    item = Deferrer::Item.new(1, 'TestWorker', [1, 2])
+    Deferrer::Processor.new(item).process
+  end
+end

data/spec/deferrer/queue_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Deferrer::Queue do
+  let(:queue) { Deferrer::Queue }
+  let(:id) { 'some_id' }
+  let(:redis) { Deferrer.redis }
+  let(:list_key) { Deferrer::Queue::LIST_KEY }
+
+  describe ".push" do
+    it "can push items" do
+      item1 = Deferrer::Item.new('1', 'TestWorker', [1])
+      item2 = Deferrer::Item.new('2', 'TestWorker', [2])
+
+      queue.push(item1, Time.now - 1)
+      queue.push(item2, Time.now - 2)
+
+      expect(queue.pop).to eq(item2)
+      expect(queue.pop).to eq(item1)
+    end
+  end
+
+  describe ".pop" do
+    it "returns the next item" do
+      TestWorker.perform_at(Time.now, id, 'test')
+
+      item = queue.pop
+
+      expect(item.class_name).to eq('TestWorker')
+      expect(item.args).to eq(['test'])
+    end
+
+    it "returns last update of an item" do
+      TestWorker.perform_at(Time.now - 3, id, 'update1')
+      TestWorker.perform_at(Time.now - 2, id, 'update2')
+
+      item = queue.pop
+
+      expect(item.class_name).to eq('TestWorker')
+      expect(item.args).to eq(['update2'])
+    end
+
+    it "returns nil when no next item" do
+      expect(queue.pop).to be_nil
+    end
+
+    it "removes values from redis" do
+      TestWorker.perform_at(Time.now, id, 'test')
+
+      item = queue.pop
+
+      expect(redis.zrangebyscore(list_key, '-inf', Time.now.to_f, :limit => [0, 1]).first).to be_nil
+      expect(redis.exists(item_key(id))).to be_falsey
+      expect(queue.pop).to be_nil
+    end
+
+    it "doesn't block on empty lists" do
+      TestWorker.perform_in(-1, id, 'test')
+      redis.del(item_key(id))
+
+      expect(queue.pop).to be_nil
+      expect(redis.zrangebyscore(list_key, '-inf', 'inf', :limit => [0, 1]).first).to be_nil
+    end
+  end
+
+  describe ".find_by_id" do
+    it "can find by id" do
+      item1 = Deferrer::Item.new('1', 'TestWorker', [1])
+      item2 = Deferrer::Item.new('2', 'TestWorker', [2])
+
+      queue.push(item1, Time.now)
+      queue.push(item2, Time.now)
+
+      expect(queue.find_by_id(item1.id)).to eq(item1)
+      expect(queue.find_by_id(item2.id)).to eq(item2)
+    end
+  end
+
+  describe ".find" do
+    it "can find by key" do
+      item1 = Deferrer::Item.new('1', 'TestWorker', [1])
+      item2 = Deferrer::Item.new('2', 'TestWorker', [2])
+
+      queue.push(item1, Time.now)
+      queue.push(item2, Time.now)
+
+      expect(queue.find(item_key(item1.id))).to eq(item1)
+      expect(queue.find(item_key(item2.id))).to eq(item2)
+    end
+  end
+end

data/spec/deferrer/runner_spec.rb

@@ -2,153 +2,78 @@ require 'spec_helper'
 require 'logger'
 
 describe Deferrer::Runner do
-  let(:identifier) { 'some_identifier' }
-  let(:redis) { Deferrer.redis }
-  let(:list_key) { Deferrer::LIST_KEY }
+  let(:id) { 'some_id' }
   let(:logger) { Logger.new(STDOUT) }
 
   describe ".run" do
     it "processes jobs" do
-      expect(Deferrer.worker).to receive(:call).with('TestWorker', 'test')
+      expect_any_instance_of(TestWorker).to receive(:perform).with('test')
 
-      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      TestWorker.perform_in(-1, id, '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"})
+      expect_any_instance_of(TestWorker).to receive(:perform).with(1, 'arg1', { "a" => "b"})
 
-      Deferrer.defer_in(-1, identifier, 'TestWorker', 1, 'arg1', { a: :b })
+      TestWorker.perform_in(-1, id, 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') }
+      expect(logger).to receive(:error).with("Error: RuntimeError: error")
+      expect(Deferrer::Queue).to receive(:pop) { raise RuntimeError.new('error') }
 
-      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      TestWorker.perform_in(-1, id, 'test')
+      Deferrer.logger = logger
       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') }
+      expect(Deferrer::Queue).to receive(:pop) { raise Exception.new('error') }
 
+      TestWorker.perform_in(-1, id, 'test')
       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"})
+      expect_any_instance_of(TestWorker).to receive(:perform).with({ "c" => "d"})
 
-      Deferrer.defer_in(100, identifier, 'Worker', { a: :b })
-      Deferrer.defer_in(100, identifier, 'Worker', { c: :d })
+      TestWorker.perform_in(100, id, { a: :b })
+      TestWorker.perform_in(100, id, { 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}")
+      expect(logger).to receive(:info).with("Processing: #{id}")
 
-      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      TestWorker.perform_in(-1, id, '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') }
+      allow(Deferrer::Queue).to receive(:pop) { raise RuntimeError.new('error') }
 
-      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      TestWorker.perform_in(-1, id, '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') }
+      allow(Deferrer::Queue).to receive(:pop) { raise Exception.new('error') }
 
-      Deferrer.defer_in(-1, identifier, 'TestWorker', 'test')
+      TestWorker.perform_in(-1, id, 'test')
       expect { Deferrer.run(single_run: true) }.to raise_error
     end
   end
-
-  describe ".inline" do
-    it "ignores time to wait and performs jobs" do
-      Deferrer.inline = true
-      expect(Deferrer.worker).to receive(:call).with('Worker', { "c" => "d"})
-
-      Deferrer.defer_in(100, identifier, 'Worker', { c: :d })
-    end
-  end
 end

data/spec/deferrer/worker_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Deferrer::Worker do
+  let(:id) { 'some_id' }
+  let(:redis) { Deferrer.redis }
+  let(:list_key) { Deferrer::Queue::LIST_KEY }
+
+  describe ".perform_at" do
+    it "deferrs at given time" do
+      TestWorker.perform_at(Time.now, id, 'test')
+
+      expect(redis.zrangebyscore(list_key, '-inf', Time.now.to_f, :limit => [0, 1]).first).not_to be_nil
+      expect(redis.exists(item_key(id))).to be_truthy
+    end
+  end
+
+  describe ".perform_in" do
+    it "defers in given interval" do
+      TestWorker.perform_in(1, id, '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(id))).to be_truthy
+    end
+  end
+
+  describe ".inline" do
+    it "ignores time to wait and performs jobs" do
+      Deferrer.inline = true
+      expect_any_instance_of(TestWorker).to receive(:perform).with({ "c" => "d"})
+
+      TestWorker.perform_in(100, id, { c: :d })
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -16,7 +16,6 @@ RSpec.configure do |config|
     Deferrer.redis.flushdb
     Deferrer.logger = nil
     Deferrer.inline = false
-    Deferrer.worker = lambda { |klass, *args| }
   end
 end
 

data/spec/support/helpers.rb

@@ -1,5 +1,12 @@
 module Helpers
   def item_key(identifier)
-    "#{Deferrer::ITEM_KEY_PREFIX}:#{identifier}"
+    "#{Deferrer::Queue::ITEM_KEY_PREFIX}:#{identifier}"
+  end
+end
+
+class TestWorker
+  include Deferrer::Worker
+
+  def perform(*args)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deferrer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Dalibor Nasevic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-28 00:00:00.000000000 Z
+date: 2014-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -101,10 +101,17 @@ files:
 - example/runner.rb
 - lib/deferrer.rb
 - lib/deferrer/configuration.rb
-- lib/deferrer/json_encoding.rb
+- lib/deferrer/item.rb
+- lib/deferrer/processor.rb
+- lib/deferrer/queue.rb
 - lib/deferrer/runner.rb
 - lib/deferrer/version.rb
+- lib/deferrer/worker.rb
+- spec/deferrer/item_spec.rb
+- spec/deferrer/processor_spec.rb
+- spec/deferrer/queue_spec.rb
 - spec/deferrer/runner_spec.rb
+- spec/deferrer/worker_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers.rb
 homepage: ''
@@ -132,7 +139,11 @@ signing_key:
 specification_version: 4
 summary: Defer work units and process only the last work unit when time comes
 test_files:
+- spec/deferrer/item_spec.rb
+- spec/deferrer/processor_spec.rb
+- spec/deferrer/queue_spec.rb
 - spec/deferrer/runner_spec.rb
+- spec/deferrer/worker_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers.rb
 has_rdoc: 

data/lib/deferrer/json_encoding.rb

@@ -1,14 +0,0 @@
-require 'multi_json'
-
-module Deferrer
-  module JsonEncoding
-
-    def encode(item)
-      MultiJson.dump(item)
-    end
-
-    def decode(item)
-      MultiJson.load(item)
-    end
-  end
-end