worker_roulette 0.1.6 → 0.1.7

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NzQ2MGVkMWQ0ZDcwYTQzOGM0OGJlMDM5M2I1OGU2YjkzZTU2MzIzZA==
+    M2EzZmZkYTllZGYwMjA1MDI1MzVmZDU5ODk1ZGRiNzYzMjQzMjQ1OQ==
   data.tar.gz: !binary |-
-    Mjc3ZTk1YTJjOWMxMzYyNmE3YTdhNTNiZjM4ZWRhMTEwN2ZjNjAxNA==
+    NDZmNjhjMTJjZDJhMjJlNzI5MjE2MjllZjFkMGQ1ZDIxODExNTQ4NQ==
 SHA512:
   metadata.gz: !binary |-
-    NjA4NmI3NTc1M2MwNjg3N2FmZDIxNjIyZGQ1YjA4NTFjMzBlNzVmZDhhNjZi
-    ZWU5NjI5NmY1MmYzZWFjNTZjOWY5OTRhMGZkNzY3ODVjNDVhN2ViOGEzZGE2
-    NzU3MDdiYmM4MzY1YjU2NDI0YjFlMGU0NjAzYWY0ZDNmMjdjNDg=
+    NjAyNTBlZDUxNmM5M2Y1MGMwMGYyNzdkNDUzNDEzMGQxNTI0ODY4NTlhY2U1
+    YjRiYjQ1MWI3YzMxNDdmZWM3ZjE1Y2ViZDg1M2FhYTA1ZjhmYzNhYWYwMjY2
+    ZThkODM4ZjY0MmE5NzlmMTdlZTRiMzRhMzUwMWFjMGJkM2NlYTU=
   data.tar.gz: !binary |-
-    MjE2Nzc5YmE3MDBhZWQ5YjdmMzdmNDZlY2U4ZmQ3NmI2NzQ4OTFkNjFjNDZj
-    YjU2M2M0MmViZjdiN2I0ZDE0MGJmZjk3YmQ3NWMxZjk5ZGMxY2MzNGM3MzMz
-    NmRlMzJlMmNmZTg0YjA2ODRiYjI3Njk5NzUyY2U5MTAxMGY5ZTM=
+    ODUxMmQwNWNhOWI5NTBkMmQ2NzFlMzUzY2Q4NjZlZTYzZDE4ZmQ2NGZiODJk
+    ZWNkMzc3ZmUxY2UzOTk4OTJjZjlmNDZkMjU4N2Y3ZGVjMmUzYzIxOTdmMzg2
+    MDJlZjAzNGFiN2JjMGMzNWEwYWVlNmY3OTQ4MjE0NjliY2ViOTE=

data/.gitignore

@@ -16,4 +16,6 @@ test/tmp
 test/version_tmp
 tmp
 tmp/*
-coverage/*
+coverage/*
+vendor/bundle
+results.xml

data/Gemfile

@@ -2,3 +2,8 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in worker_roulette.gemspec
 gemspec
+
+# Gemfile
+group :development do
+  gem 'evented-spec', :git => 'https://github.com/ruby-amqp/evented-spec.git'
+end

data/lib/worker_roulette/a_tradesman.rb

@@ -1,6 +1,8 @@
 require_relative './tradesman'
 module WorkerRoulette
   class ATradesman < Tradesman
+    attr_reader :timer
+
     def wait_for_work_orders(on_subscribe_callback = nil, &on_message_callback)
       @redis_pubsub ||= WorkerRoulette.new_redis_pubsub #cannot use connection pool bc redis expects each obj to own its own pubsub connection for the life of the subscription
       @redis_pubsub.on(:subscribe) {|channel, subscription_count| on_subscribe_callback.call(channel, subscription_count) if on_subscribe_callback}
@@ -23,8 +25,8 @@ module WorkerRoulette
       end
     end
 
-  private
-    attr_reader :timer
+    private
+
     def get_messages(message, channel, on_message_callback)
       return unless on_message_callback
       work_orders! do |work_orders_1|

data/lib/worker_roulette/foreman.rb

@@ -2,6 +2,34 @@ module WorkerRoulette
   class Foreman
     attr_reader :sender
 
+    LUA_ENQUEUE_WORK_ORDERS = <<-HERE
+        local counter_key       = KEYS[1]
+        local job_board_key     = KEYS[2]
+        local sender_key        = KEYS[3]
+        local channel           = KEYS[4]
+
+        local work_order        = ARGV[1]
+        local job_notification  = ARGV[2]
+        local redis_call        = redis.call
+        local zscore            = 'ZSCORE'
+        local incr              = 'INCR'
+        local zadd              = 'ZADD'
+        local rpush             = 'RPUSH'
+        local publish           = 'PUBLISH'
+
+        local function enqueue_work_orders(work_order, job_notification)
+          if (redis_call(zscore, job_board_key, sender_key) == false) then
+            local count     = redis_call(incr, counter_key)
+            redis_call(zadd, job_board_key, count, sender_key)
+          end
+
+          redis_call(rpush,sender_key, work_order)
+          redis_call(publish, channel, job_notification)
+        end
+
+        enqueue_work_orders(work_order, job_notification)
+    HERE
+
     def initialize(sender, redis_pool, namespace = nil)
       @sender     = sender
       @namespace  = namespace
@@ -16,7 +44,7 @@ module WorkerRoulette
 
     def enqueue_work_order_without_headers(work_order, &callback)
       Lua.call(self.class.lua_enqueue_work_orders, [counter_key, job_board_key, sender_key, @channel],
-                   [WorkerRoulette.dump(work_order),  WorkerRoulette::JOB_NOTIFICATIONS], &callback)
+               [WorkerRoulette.dump(work_order),  WorkerRoulette::JOB_NOTIFICATIONS], &callback)
     end
 
     def job_board_key
@@ -27,7 +55,8 @@ module WorkerRoulette
       @counter_key ||= WorkerRoulette.counter_key(@namespace)
     end
 
-  private
+    private
+
     def sender_key
       @sender_key = WorkerRoulette.sender_key(sender, @namespace)
     end
@@ -37,33 +66,7 @@ module WorkerRoulette
     end
 
     def self.lua_enqueue_work_orders
-      <<-HERE
-        local counter_key       = KEYS[1]
-        local job_board_key     = KEYS[2]
-        local sender_key        = KEYS[3]
-        local channel           = KEYS[4]
-
-        local work_order        = ARGV[1]
-        local job_notification  = ARGV[2]
-        local redis_call        = redis.call
-        local zscore            = 'ZSCORE'
-        local incr              = 'INCR'
-        local zadd              = 'ZADD'
-        local rpush             = 'RPUSH'
-        local publish           = 'PUBLISH'
-
-        local function enqueue_work_orders(work_order, job_notification)
-          if (redis_call(zscore, job_board_key, sender_key) == false) then
-            local count     = redis_call(incr, counter_key)
-            redis_call(zadd, job_board_key, count, sender_key)
-          end
-
-          redis_call(rpush,sender_key, work_order)
-          redis_call(publish, channel, job_notification)
-        end
-
-        enqueue_work_orders(work_order, job_notification)
-      HERE
+      LUA_ENQUEUE_WORK_ORDERS
     end
   end
-end
+end

data/lib/worker_roulette/tradesman.rb

@@ -1,43 +1,8 @@
 module WorkerRoulette
   class Tradesman
     attr_reader :last_sender
-    def initialize(client_pool, pubsub_pool, namespace = nil)
-      @client_pool = client_pool
-      @pubsub_pool = pubsub_pool
-      @namespace   = namespace
-      @channel     = namespace || WorkerRoulette::JOB_NOTIFICATIONS
-    end
-
-    def wait_for_work_orders(on_subscribe_callback = nil, &block)
-      @pubsub_pool.with do |redis|
-        redis.subscribe(@channel) do |on|
-          on.subscribe {on_subscribe_callback.call if on_subscribe_callback}
-          on.message   {block.call(work_orders! + work_orders!) if block}
-        end
-      end
-    end
-
-    def work_orders!(&callback)
-      Lua.call(self.class.lua_drain_work_orders, [job_board_key, @last_sender], [nil]) do |results|
-        results ||= []
-        @last_sender = (results.first || '').split(':').first
-        work = (results[1] || []).map {|work_order| WorkerRoulette.load(work_order)}
-        callback.call work if callback
-        work
-      end
-    end
-
-    def unsubscribe
-      @pubsub_pool.with {|redis| redis.unsubscribe(@channel)}
-    end
 
-    def job_board_key
-      @job_board_key ||= WorkerRoulette.job_board_key(@namespace)
-    end
-
-  private
-    def self.lua_drain_work_orders
-      <<-HERE
+    LUA_DRAIN_WORK_ORDERS = <<-HERE
         local empty_string      = ""
         local job_board_key     = KEYS[1]
         local last_sender_key   = KEYS[2] or empty_string
@@ -88,7 +53,46 @@ module WorkerRoulette
         end
 
         return drain_work_orders(job_board_key, last_sender_key, empty_string)
-      HERE
+    HERE
+
+    def initialize(client_pool, pubsub_pool, namespace = nil)
+      @client_pool = client_pool
+      @pubsub_pool = pubsub_pool
+      @namespace   = namespace
+      @channel     = namespace || WorkerRoulette::JOB_NOTIFICATIONS
+    end
+
+    def wait_for_work_orders(on_subscribe_callback = nil, &block)
+      @pubsub_pool.with do |redis|
+        redis.subscribe(@channel) do |on|
+          on.subscribe {on_subscribe_callback.call if on_subscribe_callback}
+          on.message   {block.call(work_orders! + work_orders!) if block}
+        end
+      end
+    end
+
+    def work_orders!(&callback)
+      Lua.call(self.class.lua_drain_work_orders, [job_board_key, @last_sender], [nil]) do |results|
+        results ||= []
+        @last_sender = (results.first || '').split(':').first
+        work = (results[1] || []).map {|work_order| WorkerRoulette.load(work_order)}
+        callback.call work if callback
+        work
+      end
+    end
+
+    def unsubscribe
+      @pubsub_pool.with {|redis| redis.unsubscribe(@channel)}
+    end
+
+    def job_board_key
+      @job_board_key ||= WorkerRoulette.job_board_key(@namespace)
+    end
+
+    private
+
+    def self.lua_drain_work_orders
+      LUA_DRAIN_WORK_ORDERS
     end
   end
-end
+end

data/lib/worker_roulette/version.rb

@@ -1,3 +1,3 @@
 module WorkerRoulette
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/lib/worker_roulette.rb

@@ -13,7 +13,7 @@ module WorkerRoulette
   JOB_NOTIFICATIONS = "new_job_ready"
 
   def self.start(config = {})
-    @redis_config               = {host: 'localhost', port: 6379, db: 14, driver: :hiredis, timeout: 5, evented: false, pool_size: 10}.merge(config)
+    @redis_config               = { host: 'localhost', port: 6379, db: 14, driver: :hiredis, timeout: 5, evented: false, pool_size: 10 }.merge(config)
     @pool_config                = Hash[size: @redis_config.delete(:pool_size), timeout: @redis_config.delete(:timeout)]
     @evented                    = @redis_config.delete(:evented)
 
@@ -80,7 +80,9 @@ module WorkerRoulette
   def self.counter_key(sender, namespace = nil)
     "#{namespace + ':' if namespace}counter_key"
   end
-private
+
+  private
+
   def self.new_redis
     if @evented
       require 'eventmachine'
@@ -93,7 +95,7 @@ private
 
   def self.new_redis_pubsub
     if @evented
-     new_redis.pubsub
+      new_redis.pubsub
     else
       new_redis
     end

data/spec/integration/evented_worker_roulette_spec.rb

@@ -20,19 +20,20 @@ describe WorkerRoulette do
   context "Evented Foreman" do
     let(:subject) {WorkerRoulette.a_foreman(sender)}
 
-    it "should enqueue work" do
+    it "enqueues work" do
       called = false
-      foreman      = WorkerRoulette.a_foreman('foreman')
+      foreman = WorkerRoulette.a_foreman('foreman')
       foreman.enqueue_work_order('some old fashion work') do |redis_response, stuff|
         called = true
       end
-      done(0.1) {called.should == true}
+      done(0.1) { expect(called).to be_truthy }
     end
 
     it "should enqueue_work_order two work_orders in the sender's slot in the job board" do
       subject.enqueue_work_order(work_orders.first) do
         subject.enqueue_work_order(work_orders.last) do
-          redis.lrange(sender, 0, -1).should == work_orders.map {|m| WorkerRoulette.dump(default_headers.merge({'payload' => m})) }
+          expected = work_orders.map { |m| WorkerRoulette.dump(default_headers.merge({'payload' => m})) }
+          expect(redis.lrange(sender, 0, -1)).to eq(expected)
           done
         end
       end
@@ -40,14 +41,14 @@ describe WorkerRoulette do
 
     it "should enqueue_work_order an array of work_orders without headers in the sender's slot in the job board" do
       subject.enqueue_work_order_without_headers(work_orders) do
-        redis.lrange(sender, 0, -1).should == [WorkerRoulette.dump(work_orders)]
+        expect(redis.lrange(sender, 0, -1)).to eq([WorkerRoulette.dump(work_orders)])
         done
       end
     end
 
     it "should enqueue_work_order an array of work_orders with default headers in the sender's slot in the job board" do
       subject.enqueue_work_order(work_orders) do
-        redis.lrange(sender, 0, -1).should == jsonized_work_orders_with_headers
+        expect(redis.lrange(sender, 0, -1)).to eq(jsonized_work_orders_with_headers)
         done
       end
     end
@@ -56,7 +57,7 @@ describe WorkerRoulette do
       extra_headers = {'foo' => 'bars'}
       subject.enqueue_work_order(work_orders, extra_headers) do
         work_orders_with_headers['headers'].merge!(extra_headers)
-        redis.lrange(sender, 0, -1).should == [WorkerRoulette.dump(work_orders_with_headers)]
+        expect(redis.lrange(sender, 0, -1)).to eq([WorkerRoulette.dump(work_orders_with_headers)])
         done
       end
     end
@@ -66,7 +67,7 @@ describe WorkerRoulette do
       first_foreman.enqueue_work_order('foo') do
         subject.enqueue_work_order(work_orders.first) do
           subject.enqueue_work_order(work_orders.last) do
-            redis.zrange(subject.job_board_key, 0, -1, with_scores: true).should == [["first_foreman", 1.0], ["katie_80", 2.0]]
+            expect(redis.zrange(subject.job_board_key, 0, -1, with_scores: true)).to eq([["first_foreman", 1.0], ["katie_80", 2.0]])
             done
           end
         end
@@ -75,13 +76,13 @@ describe WorkerRoulette do
 
     it "should generate a monotically increasing score for senders not on the job board, but not for senders already there" do
       first_foreman = WorkerRoulette.a_foreman('first_foreman')
-      redis.get(subject.counter_key).should == nil
+      expect(redis.get(subject.counter_key)).to be_nil
       first_foreman.enqueue_work_order(work_orders.first) do
-        redis.get(subject.counter_key).should == "1"
+        expect(redis.get(subject.counter_key)).to eq("1")
         first_foreman.enqueue_work_order(work_orders.last) do
-          redis.get(subject.counter_key).should == "1"
+          expect(redis.get(subject.counter_key)).to eq("1")
           subject.enqueue_work_order(work_orders.first) do
-            redis.get(subject.counter_key).should == "2"
+            expect(redis.get(subject.counter_key)).to eq("2")
             done
           end
         end
@@ -93,7 +94,7 @@ describe WorkerRoulette do
       subscriber = WorkerRoulette.new_redis_pubsub
       subscriber.subscribe(WorkerRoulette::JOB_NOTIFICATIONS) do |message|
         subscriber.unsubscribe(WorkerRoulette::JOB_NOTIFICATIONS)
-        message.should == WorkerRoulette::JOB_NOTIFICATIONS
+        expect(message).to eq(WorkerRoulette::JOB_NOTIFICATIONS)
         done
       end.callback { subject.enqueue_work_order(work_orders) }
     end
@@ -106,7 +107,7 @@ describe WorkerRoulette do
     it "should be working on behalf of a sender" do
       foreman.enqueue_work_order(work_orders) do
         subject.work_orders! do |r|
-          subject.last_sender.should == sender
+          expect(subject.last_sender).to eq(sender)
           done
         end
       end
@@ -116,9 +117,9 @@ describe WorkerRoulette do
     it "should drain one set of work_orders from the sender's slot in the job board" do
       foreman.enqueue_work_order(work_orders) do
         subject.work_orders! do |r|
-          r.should == [work_orders_with_headers]
-          subject.work_orders! do |r| r.should == []
-            subject.work_orders! {|r| r.should == []; done} #does not throw an error if queue is alreay empty
+          expect(r).to eq([work_orders_with_headers])
+          subject.work_orders! do |r| expect(r).to be_empty
+          subject.work_orders! {|r| expect(r).to be_empty; done} #does not throw an error if queue is alreay empty
           end
         end
       end
@@ -130,19 +131,19 @@ describe WorkerRoulette do
         most_recent_sender = 'most_recent_sender'
         most_recent_foreman = WorkerRoulette.a_foreman(most_recent_sender)
         most_recent_foreman.enqueue_work_order(work_orders) do
-          redis.zrange(subject.job_board_key, 0, -1).should == [oldest_sender, most_recent_sender]
-          subject.work_orders! { redis.zrange(subject.job_board_key, 0, -1).should == [most_recent_sender]; done }
+          expect(redis.zrange(subject.job_board_key, 0, -1)).to eq([oldest_sender, most_recent_sender])
+          subject.work_orders! { expect(redis.zrange(subject.job_board_key, 0, -1)).to eq([most_recent_sender]); done }
         end
       end
     end
 
     it "should get the work_orders from the next queue when a new job is ready" do
-      subject.should_receive(:work_orders!).twice.and_call_original
+      expect(subject).to receive(:work_orders!).twice.and_call_original
       publish = proc {foreman.enqueue_work_order(work_orders)}
 
       subject.wait_for_work_orders(publish) do |redis_work_orders, message, channel|
-        redis_work_orders.should   == [work_orders_with_headers]
-        subject.last_sender.should == nil
+        expect(redis_work_orders).to eq([work_orders_with_headers])
+        expect(subject.last_sender).to be_nil
         done
       end
     end
@@ -160,19 +161,19 @@ describe WorkerRoulette do
       good_publish = proc {good_foreman.enqueue_work_order('some old fashion work')}
       bad_publish  = proc {bad_foreman.enqueue_work_order('evil biddings you should not carry out')}
 
-      tradesman.should_receive(:work_orders!).twice.and_call_original
-      evil_tradesman.should_receive(:work_orders!).twice.and_call_original
+      expect(tradesman).to receive(:work_orders!).twice.and_call_original
+      expect(evil_tradesman).to receive(:work_orders!).twice.and_call_original
 
       #They are double subscribing; is it possible that it is the connection pool?
 
       tradesman.wait_for_work_orders(good_publish) do |good_work|
-        good_work.to_s.should match("old fashion")
-        good_work.to_s.should_not match("evil")
+        expect(good_work.to_s).to match("old fashion")
+        expect(good_work.to_s).not_to match("evil")
       end
 
       evil_tradesman.wait_for_work_orders(bad_publish) do |bad_work|
-        bad_work.to_s.should_not match("old fashion")
-        bad_work.to_s.should match("evil")
+        expect(bad_work.to_s).not_to match("old fashion")
+        expect(bad_work.to_s).to match("evil")
       end
 
       done(0.2)
@@ -183,51 +184,49 @@ describe WorkerRoulette do
       subject.wait_for_work_orders(publish) do |redis_work_orders, message, channel|
         subject.unsubscribe {done}
       end
-      EM::Hiredis::PubsubClient.any_instance.should_receive(:close_connection).and_call_original
+      expect_any_instance_of(EM::Hiredis::PubsubClient).to receive(:close_connection).and_call_original
     end
 
     it "should periodically (random time between 20 and 25 seconds?) poll the job board for new work, in case it missed a notification" do
-      EM::PeriodicTimer.should_receive(:new) {|time| time.should be_within(2.5).of(22.5)}
+      expect(EM::PeriodicTimer).to receive(:new) {|time| expect(time).to be_within(2.5).of(22.5)}
       publish = proc {foreman.enqueue_work_order('foo')}
       subject.wait_for_work_orders(publish) {done}
     end
 
-    xit "should cancel the old timer when the on_message callback is called" do
+    pending "cancels the old timer when the on_message callback is called" do
       publish = proc {foreman.enqueue_work_order('foo')}
       subject.wait_for_work_orders(publish) do
-        subject.send(:timer).should_receive(:cancel).and_call_original
+        expect(subject.send(:timer)).to receive(:cancel).and_call_original
         done
       end
     end
 
     it "should pull off work orders for more than one sender" do
-      tradesman         = WorkerRoulette.a_tradesman('good_channel')
+      tradesman = WorkerRoulette.a_tradesman('good_channel')
 
-      good_foreman      = WorkerRoulette.a_foreman('good_foreman', 'good_channel')
-      lazy_foreman      = WorkerRoulette.a_foreman('lazy_foreman', 'good_channel')
+      good_foreman = WorkerRoulette.a_foreman('good_foreman', 'good_channel')
+      lazy_foreman = WorkerRoulette.a_foreman('lazy_foreman', 'good_channel')
 
       got_good = false
       got_lazy  = false
       good_foreman.enqueue_work_order('do good work') do
         tradesman.work_orders! do |r|
           got_good = true
-          r.first['payload'].should == ('do good work')
+          expect(r.first['payload']).to eq('do good work')
         end
       end
       lazy_foreman.enqueue_work_order('just get it done') do
         tradesman.work_orders! do |r|
           got_lazy = true
-          r.first['payload'].should == ('just get it done')
+          expect(r.first['payload']).to eq('just get it done')
         end
       end
 
-      done(0.2) {(got_good && got_lazy).should == true}
+      done(0.2) {expect(got_good && got_lazy).to eq(true)}
     end
   end
 
-  xit "should return a hash with a string in the payload if OJ cannot parse the json" do
-
-  end
+  pending "should return a hash with a string in the payload if OJ cannot parse the json"
 
   context "Failure" do
     it "should not put the sender_id and work_orders back if processing fails bc new work_orders may have been processed while that process failed" do; done; end

data/spec/integration/worker_roulette_spec.rb

@@ -16,54 +16,54 @@ describe WorkerRoulette do
   end
 
   it "should exist" do
-    WorkerRoulette.should_not be_nil
+    expect(WorkerRoulette).not_to be_nil
   end
 
   context Foreman do
     let(:subject) {WorkerRoulette.foreman(sender)}
 
     it "should be working on behalf of a sender" do
-      subject.sender.should == sender
+      expect(subject.sender).to eq(sender)
     end
 
     it "should enqueue_work_order two work_orders in the sender's slot in the switchboard" do
       subject.enqueue_work_order(work_orders.first) {}
       subject.enqueue_work_order(work_orders.last) {}
-      redis.lrange(sender, 0, -1).should == work_orders.map {|m| WorkerRoulette.dump(default_headers.merge({'payload' => m})) }
+      expect(redis.lrange(sender, 0, -1)).to eq(work_orders.map {|m| WorkerRoulette.dump(default_headers.merge({'payload' => m})) })
     end
 
     it "should enqueue_work_order an array of work_orders without headers in the sender's slot in the switchboard" do
       subject.enqueue_work_order_without_headers(work_orders)
-      redis.lrange(sender, 0, -1).should == [WorkerRoulette.dump(work_orders)]
+      expect(redis.lrange(sender, 0, -1)).to eq([WorkerRoulette.dump(work_orders)])
     end
 
     it "should enqueue_work_order an array of work_orders with default headers in the sender's slot in the switchboard" do
       subject.enqueue_work_order(work_orders)
-      redis.lrange(sender, 0, -1).should == jsonized_work_orders_with_headers
+      expect(redis.lrange(sender, 0, -1)).to eq(jsonized_work_orders_with_headers)
     end
 
     it "should enqueue_work_order an array of work_orders with additional headers in the sender's slot in the switchboard" do
       extra_headers = {'foo' => 'bars'}
       subject.enqueue_work_order(work_orders, extra_headers)
       work_orders_with_headers['headers'].merge!(extra_headers)
-      redis.lrange(sender, 0, -1).should == [WorkerRoulette.dump(work_orders_with_headers)]
+      expect(redis.lrange(sender, 0, -1)).to eq([WorkerRoulette.dump(work_orders_with_headers)])
     end
 
     it "should post the sender's id to the job board with an order number" do
       subject.enqueue_work_order(work_orders.first)
       WorkerRoulette.foreman('other_forman').enqueue_work_order(work_orders.last)
-      redis.zrange(subject.job_board_key, 0, -1, with_scores: true).should == [[sender, 1.0], ["other_forman", 2.0]]
+      expect(redis.zrange(subject.job_board_key, 0, -1, with_scores: true)).to eq([[sender, 1.0], ["other_forman", 2.0]])
     end
 
     it "should generate a monotically increasing score for senders not on the job board, but not for senders already there" do
       other_forman = WorkerRoulette.foreman('other_forman')
-      redis.get(subject.counter_key).should == nil
+      expect(redis.get(subject.counter_key)).to be_nil
       subject.enqueue_work_order(work_orders.first)
-      redis.get(subject.counter_key).should == "1"
+      expect(redis.get(subject.counter_key)).to eq("1")
       subject.enqueue_work_order(work_orders.last)
-      redis.get(subject.counter_key).should == "1"
+      expect(redis.get(subject.counter_key)).to eq("1")
       other_forman.enqueue_work_order(work_orders.last)
-      redis.get(other_forman.counter_key).should == "2"
+      expect(redis.get(other_forman.counter_key)).to eq("2")
     end
 
     it "should publish a notification that a new job is ready" do
@@ -80,7 +80,7 @@ describe WorkerRoulette do
         end
       end
 
-      result.should == WorkerRoulette::JOB_NOTIFICATIONS
+      expect(result).to eq(WorkerRoulette::JOB_NOTIFICATIONS)
     end
   end
 
@@ -93,27 +93,27 @@ describe WorkerRoulette do
     end
 
     it "should have a last sender if it found messages" do
-      subject.work_orders!.length.should == 1
-      subject.last_sender.should == sender
+      expect(subject.work_orders!.length).to eq(1)
+      expect(subject.last_sender).to eq(sender)
     end
 
     it "should not have a last sender if it found no messages" do
-      subject.work_orders!.length.should == 1
-      subject.work_orders!.length.should == 0
-      subject.last_sender.should == nil
+      expect(subject.work_orders!.length).to eq(1)
+      expect(subject.work_orders!.length).to eq(0)
+      expect(subject.last_sender).to be_nil
     end
 
     it "should drain one set of work_orders from the sender's slot in the switchboard" do
-      subject.work_orders!.should == [work_orders_with_headers]
-      subject.work_orders!.should == []
-      subject.work_orders!.should == [] #does not throw an error if queue is alreay empty
+      expect(subject.work_orders!).to eq([work_orders_with_headers])
+      expect(subject.work_orders!).to be_empty
+      expect(subject.work_orders!).to be_empty #does not throw an error if queue is already empty
     end
 
     it "should drain all the work_orders from the sender's slot in the switchboard" do
       foreman.enqueue_work_order(work_orders)
-      subject.work_orders!.should == [work_orders_with_headers, work_orders_with_headers]
-      subject.work_orders!.should == []
-      subject.work_orders!.should == [] #does not throw an error if queue is alreay empty
+      expect(subject.work_orders!).to eq([work_orders_with_headers, work_orders_with_headers])
+      expect(subject.work_orders!).to be_empty
+      expect(subject.work_orders!).to be_empty #does not throw an error if queue is already empty
     end
 
     it "should take the oldest sender off the job board (FIFO)" do
@@ -121,26 +121,26 @@ describe WorkerRoulette do
       most_recent_sender = 'most_recent_sender'
       most_recent_foreman = WorkerRoulette.foreman(most_recent_sender)
       most_recent_foreman.enqueue_work_order(work_orders)
-      redis.zrange(subject.job_board_key, 0, -1).should == [oldest_sender, most_recent_sender]
+      expect(redis.zrange(subject.job_board_key, 0, -1)).to eq([oldest_sender, most_recent_sender])
       subject.work_orders!
-      redis.zrange(subject.job_board_key, 0, -1).should == [most_recent_sender]
+      expect(redis.zrange(subject.job_board_key, 0, -1)).to eq([most_recent_sender])
     end
 
     it "should get the work_orders from the next queue when a new job is ready" do
       subject.work_orders!
-      subject.should_receive(:work_orders!).twice.and_call_original
+      expect(subject).to receive(:work_orders!).twice.and_call_original
 
       publisher = -> {foreman.enqueue_work_order(work_orders); subject.unsubscribe}
 
       subject.wait_for_work_orders(publisher) do |redis_work_orders|
-        redis_work_orders.should == [work_orders_with_headers]
-        subject.last_sender.should == nil
+        expect(redis_work_orders).to eq([work_orders_with_headers])
+        expect(subject.last_sender).to be_nil
       end
     end
 
     it "should publish and subscribe on custom channels" do
       tradesman         = WorkerRoulette.tradesman('good_channel')
-      tradesman.should_receive(:work_orders!).twice.and_call_original
+      expect(tradesman).to receive(:work_orders!).twice.and_call_original
 
       good_foreman      = WorkerRoulette.foreman('foreman', 'good_channel')
       bad_foreman       = WorkerRoulette.foreman('foreman', 'bad_channel')
@@ -153,9 +153,9 @@ describe WorkerRoulette do
       end
 
       tradesman.wait_for_work_orders(publish) do |work|
-        work.to_s.should match("some old fashion work")
-        work.to_s.should_not match("evil")
-        tradesman.last_sender.should == nil
+        expect(work.to_s).to match("some old fashion work")
+        expect(work.to_s).not_to match("evil")
+        expect(tradesman.last_sender).to be_nil
       end
     end
 
@@ -169,7 +169,7 @@ describe WorkerRoulette do
           Thread.new {WorkerRoulette.tradesman_connection_pool.with {|pooled_redis| pooled_redis.get("foo")}}
         end.each(&:join)
         WorkerRoulette.tradesman_connection_pool.with do |pooled_redis|
-          pooled_redis.info["connected_clients"].to_i.should > (WorkerRoulette.pool_size)
+          expect(pooled_redis.info["connected_clients"].to_i).to be > (WorkerRoulette.pool_size)
         end
       end
 

data/spec/unit/evented_readlock_spec.rb

@@ -24,14 +24,14 @@ module WorkerRoulette
 
     it "should lock a queue when it reads from it" do
       evented_readlock_preconditions do
-        redis.get(lock_key).should_not be_nil
+        expect(redis.get(lock_key)).not_to be_nil
         done
       end
     end
 
     it "should set the lock to expire in 1 second" do
       evented_readlock_preconditions do
-        redis.ttl(lock_key).should == 1
+        expect(redis.ttl(lock_key)).to eq(1)
         done
       end
     end
@@ -39,7 +39,7 @@ module WorkerRoulette
     it "should not read a locked queue" do
       evented_readlock_preconditions do
         foreman.enqueue_work_order(work_orders) do #locked
-          subject_two.work_orders! {|work |work.should == []; done}
+          subject_two.work_orders! { |work| expect(work).to be_empty; done}
         end
       end
     end
@@ -48,7 +48,7 @@ module WorkerRoulette
        evented_readlock_preconditions do
          foreman.enqueue_work_order(work_orders) do    #locked
            number_two.enqueue_work_order(work_orders) do  #unlocked
-            subject_two.work_orders!{|work| work.first['headers']['sender'].should == 'number_two'; done}
+            subject_two.work_orders!{|work| expect(work.first['headers']['sender']).to eq('number_two'); done}
           end
          end
        end
@@ -57,10 +57,10 @@ module WorkerRoulette
     it "should release its last lock when it asks for its next work order from another sender" do
       evented_readlock_preconditions do
         number_two.enqueue_work_order(work_orders) do #unlocked
-          subject.last_sender.should == sender
+          expect(subject.last_sender).to eq(sender)
           subject.work_orders! do |work|
-            work.first['headers']['sender'].should == 'number_two'
-            redis.get(lock_key).should == nil
+            expect(work.first['headers']['sender']).to eq('number_two')
+            expect(redis.get(lock_key)).to be_nil
             done
           end
         end
@@ -71,9 +71,9 @@ module WorkerRoulette
       evented_readlock_preconditions do
         foreman.enqueue_work_order(work_orders) do #locked
           subject.work_orders! do |work|
-            work.should == [work_orders_with_headers]
-            subject.last_sender.should == sender
-            redis.get(lock_key).should_not == nil
+            expect(work).to eq([work_orders_with_headers])
+            expect(subject.last_sender).to eq(sender)
+            expect(redis.get(lock_key)).not_to be_nil
             done
           end
         end
@@ -83,11 +83,11 @@ module WorkerRoulette
     it "should not take out another lock if there is no work to do" do
       evented_readlock_preconditions do
         foreman.enqueue_work_order(work_orders) do #locked
-          subject.work_orders! do |work|
-            work.should == [work_orders_with_headers]
+          subject.work_orders! do |work_order|
+            expect(work_order).to eq([work_orders_with_headers])
             subject.work_orders! do |work|
-              work.should == []
-              redis.get(lock_key).should == nil
+              expect(work).to be_empty
+              expect(redis.get(lock_key)).to be_nil
               done
             end
           end
@@ -99,9 +99,9 @@ module WorkerRoulette
   def evented_readlock_preconditions(&spec_block)
     foreman.enqueue_work_order(work_orders) do
       subject.work_orders! do |work|
-        work.should == [work_orders_with_headers]
+        expect(work).to eq([work_orders_with_headers])
         spec_block.call
       end
     end
   end
-end
+end

data/spec/unit/lua_spec.rb

@@ -17,22 +17,22 @@ module WorkerRoulette
     it "should load and call a lua script" do
       lua_script = 'return redis.call("SET", KEYS[1], ARGV[1])'
       Lua.call(lua_script, ['foo'], ['daddy']) do |result|
-        Lua.cache.keys.first.should == lua_script
-        Lua.cache.values.first.should == Digest::SHA1.hexdigest(lua_script)
-        result.should == "OK"
+        expect(Lua.cache.keys.first).to eq(lua_script)
+        expect(Lua.cache.values.first).to eq(Digest::SHA1.hexdigest(lua_script))
+        expect(result).to eq("OK")
         done
       end
     end
 
     it "should send a sha instead of a script once the script has been cached" do
       lua_script = 'return KEYS'
-      Lua.should_receive(:eval).and_call_original
+      expect(Lua).to receive(:eval).and_call_original
 
       Lua.call(lua_script) do |result|
+        expect(Lua).not_to receive(:eval)
 
-        Lua.should_not_receive(:eval)
-        Lua.call(lua_script) do |result|
-          result.should == []
+        Lua.call(lua_script) do |inner_result|
+          expect(inner_result).to be_empty
           done
         end
       end
@@ -46,4 +46,4 @@ module WorkerRoulette
       done
     end
   end
-end
+end

data/spec/unit/readlock_spec.rb

@@ -19,56 +19,54 @@ module WorkerRoulette
       redis.script(:flush)
       redis.flushdb
       foreman.enqueue_work_order(work_orders)
-      subject.work_orders!.should == [work_orders_with_headers]
+      expect(subject.work_orders!).to eq([work_orders_with_headers])
     end
 
     it "should lock a queue when it reads from it" do
-      redis.get(lock_key).should_not be_nil
+      expect(redis.get(lock_key)).not_to be_nil
     end
 
     it "should set the lock to expire in 1 second" do
-      redis.ttl(lock_key).should == 1
+      expect(redis.ttl(lock_key)).to eq(1)
     end
 
     it "should not read a locked queue" do
       foreman.enqueue_work_order(work_orders)    #locked
-      subject_two.work_orders!.should == []
+      expect(subject_two.work_orders!).to be_empty
     end
 
     it "should read from the first available queue that is not locked" do
        foreman.enqueue_work_order(work_orders)     #locked
        number_two.enqueue_work_order(work_orders)  #unlocked
-       subject_two.work_orders!.first['headers']['sender'].should == 'number_two'
+       expect(subject_two.work_orders!.first['headers']['sender']).to eq('number_two')
     end
 
     it "should release its previous lock when it asks for work from another sender" do
       number_two.enqueue_work_order(work_orders)    #unlocked
-      subject.last_sender.should == sender
-      subject.work_orders!.first['headers']['sender'].should == 'number_two'
-      redis.get(lock_key).should == nil
+      expect(subject.last_sender).to eq(sender)
+      expect(subject.work_orders!.first['headers']['sender']).to eq('number_two')
+      expect(redis.get(lock_key)).to be_nil
     end
 
     it "should not release its lock when it asks for work from the same sender" do
       foreman.enqueue_work_order(work_orders)    #locked
-      subject.work_orders!.should == [work_orders_with_headers]
-      subject.last_sender.should == sender
+      expect(subject.work_orders!).to eq([work_orders_with_headers])
+      expect(subject.last_sender).to eq(sender)
 
       foreman.enqueue_work_order(work_orders)    #locked
-      subject.work_orders!.should == [work_orders_with_headers]
-      subject.last_sender.should == sender
+      expect(subject.work_orders!).to eq([work_orders_with_headers])
+      expect(subject.last_sender).to eq(sender)
 
-      redis.get(lock_key).should_not == nil
+      expect(redis.get(lock_key)).not_to be_nil
     end
 
     it "should release its previous lock if there is no work to do from the same sender" do
       foreman.enqueue_work_order(work_orders)    #locked
-      subject.work_orders!.should == [work_orders_with_headers]
-      subject.work_orders!.should == []
-      redis.get(lock_key).should == nil
+      expect(subject.work_orders!).to eq([work_orders_with_headers])
+      expect(subject.work_orders!).to be_empty
+      expect(redis.get(lock_key)).to be_nil
     end
 
-    xit "pubsub should clean up one contention orremove the lock on the same sender queue automaticly" do
-
-    end
+    pending "pubsub should clean up one contention or remove the lock on the same sender queue automaticly"
   end
-end
+end

data/worker_roulette.gemspec

@@ -4,18 +4,18 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'worker_roulette/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "worker_roulette"
+  spec.name          = 'worker_roulette'
   spec.version       = WorkerRoulette::VERSION
-  spec.authors       = ["Paul Saieg"]
-  spec.email         = ["classicist@gmail.com"]
-  spec.description   = %q{Write a gem description}
-  spec.summary       = %q{Write a gem summary}
-  spec.homepage      = "https://github.com/nexiahome/worker_roulette"
+  spec.authors       = ['Paul Saieg']
+  spec.email         = ['classicist@gmail.com']
+  spec.description   = %q{Pub Sub Queue for Redis that ensures ordered processing}
+  spec.summary       = %q{Pub Sub Queue for Redis that ensures ordered processing}
+  spec.homepage      = 'https://github.com/nexiahome/worker_roulette'
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(spec)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   spec.add_dependency 'oj'
   spec.add_dependency 'redis', '~> 3.0.7'
@@ -24,14 +24,13 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'connection_pool'
   spec.add_dependency 'eventmachine', '~> 1.0.3'
 
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0.0'
   spec.add_development_dependency 'pry-debugger'
   spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'simplecov-rcov'
   spec.add_development_dependency 'rspec_junit_formatter'
-  spec.add_development_dependency 'evented-spec'
   spec.add_development_dependency 'guard'
   spec.add_development_dependency 'guard-rspec'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worker_roulette
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Paul Saieg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-13 00:00:00.000000000 Z
+date: 2014-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -126,16 +126,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: pry-debugger
   requirement: !ruby/object:Gem::Requirement
@@ -192,20 +192,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: evented-spec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -234,7 +220,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Write a gem description
+description: Pub Sub Queue for Redis that ensures ordered processing
 email:
 - classicist@gmail.com
 executables: []
@@ -287,7 +273,7 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Write a gem summary
+summary: Pub Sub Queue for Redis that ensures ordered processing
 test_files:
 - spec/benchmark/perf_test.rb
 - spec/helpers/.gitkeep