resque-bus 0.3.2 → 0.7.0

data/spec/publish_spec.rb

@@ -1,72 +1,96 @@
 require 'spec_helper'
 
 describe "Publishing an event" do
-  
+
   before(:each) do
     Timecop.freeze
-    ResqueBus.stub(:generate_uuid).and_return("idfhlkj")
+    QueueBus.stub(:generate_uuid).and_return("idfhlkj")
   end
   after(:each) do
     Timecop.return
   end
-  let(:bus_attrs) { {"bus_published_at" => Time.now.to_i,
+  let(:bus_attrs) { {"bus_class_proxy"=>"QueueBus::Driver",
+                     "bus_published_at" => Time.now.to_i,
                      "bus_id"=>"#{Time.now.to_i}-idfhlkj",
                      "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
-  
+
   it "should add it to Redis" do
     hash = {:one => 1, "two" => "here", "id" => 12 }
     event_name = "event_name"
-    
-    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     val.should == nil
-    
-    ResqueBus.publish(event_name, hash)
-    
-    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+
+    QueueBus.publish(event_name, hash)
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
-    hash["class"].should == "ResqueBus::Driver"
-    hash["args"].should == [ {"bus_event_type" => event_name, "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs) ]
-    
+    hash["class"].should == "QueueBus::Worker"
+    hash["args"].size.should == 1
+    JSON.parse(hash["args"].first).should == {"bus_event_type" => event_name, "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs)
+
   end
-  
+
   it "should use the id if given" do
     hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
     event_name = "event_name"
-    
-    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     val.should == nil
-    
-    ResqueBus.publish(event_name, hash)
-    
-    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+
+    QueueBus.publish(event_name, hash)
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
-    hash["class"].should == "ResqueBus::Driver"
-    hash["args"].should == [ {"bus_event_type" => event_name, "two"=>"here", "one"=>1}.merge(bus_attrs).merge("bus_id" => 'app-given') ]
+    hash["class"].should == "QueueBus::Worker"
+    hash["args"].size.should == 1
+    JSON.parse(hash["args"].first).should == {"bus_event_type" => event_name, "two"=>"here", "one"=>1}.merge(bus_attrs).merge("bus_id" => 'app-given')
+  end
+
+  it "should add metadata via callback" do
+    myval = 0
+    QueueBus.before_publish = lambda { |att|
+      att["mine"] = 4
+      myval += 1
+    }
+
+    hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
+    event_name = "event_name"
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val.should == nil
+
+    QueueBus.publish(event_name, hash)
+
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    hash = JSON.parse(val)
+    att = JSON.parse(hash["args"].first)
+    att["mine"].should == 4
+    myval.should == 1
   end
-  
 
-  
   it "should set the timezone and locale if available" do
     defined?(I18n).should be_nil
-    Time.respond_to?(:zone).should be_false
-    
+    Time.respond_to?(:zone).should eq(false)
+
     stub_const("I18n", Class.new)
-    I18n.should_receive(:locale).and_return("jp")
-    
-    Time.should_receive(:zone).and_return(double('zone', :name => "EST"))
-    
+    I18n.stub(:locale).and_return("jp")
+
+    Time.stub(:zone).and_return(double('zone', :name => "EST"))
+
     hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
     event_name = "event_name"
-    
-    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     val.should == nil
-    
-    ResqueBus.publish(event_name, hash)
-    
-    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+
+    QueueBus.publish(event_name, hash)
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
-    hash["class"].should == "ResqueBus::Driver"
-    att = hash["args"].first
+    hash["class"].should == "QueueBus::Worker"
+    att = JSON.parse(hash["args"].first)
     att["bus_locale"].should == "jp"
     att["bus_timezone"].should == "EST"
   end

data/spec/publisher_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module QueueBus
+  describe Publisher do
+    it "should call publish as expected"
+  end
+end

data/spec/rider_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
-module ResqueBus
+module QueueBus
   describe Rider do
     it "should call execute" do
-      ResqueBus.should_receive(:dispatcher_execute)
+      QueueBus.should_receive(:dispatcher_execute)
       Rider.perform("bus_rider_app_key" => "app", "bus_rider_sub_key" => "sub", "ok" => true, "bus_event_type" => "event_name")
     end
-    
+
     it "should change the value" do
-      ResqueBus.dispatch("r1") do
+      QueueBus.dispatch("r1") do
         subscribe "event_name" do |attributes|
           Runner1.run(attributes)
         end
@@ -18,74 +18,22 @@ module ResqueBus
       Rider.perform("bus_rider_app_key" => "other", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
       Runner1.value.should == 1
     end
-    
+
     it "should set the timezone and locale if present" do
+      QueueBus.dispatch("r1") do
+        subscribe "event_name" do |attributes|
+          Runner1.run(attributes)
+        end
+      end
+
       defined?(I18n).should be_nil
-      Time.respond_to?(:zone).should be_false
+      Time.respond_to?(:zone).should eq(false)
 
       stub_const("I18n", Class.new)
       I18n.should_receive(:locale=).with("en")
       Time.should_receive(:zone=).with("PST")
-      
+
       Rider.perform("bus_locale" => "en", "bus_timezone" => "PST", "bus_rider_app_key" => "r1", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
     end
-    
-    context "Integration Test" do
-      before(:each) do
-        Resque.redis = "example.com/bad"
-        ResqueBus.original_redis =  Resque.redis
-        ResqueBus.redis = "localhost:6379"
-        
-        
-        ResqueBus.enqueue_to("testing", "::ResqueBus::Rider", { "bus_rider_app_key" => "r2", "bus_rider_sub_key" => "event_name", "bus_event_type" => "event_name", "ok" => true, "bus_rider_queue" => "testing" })
-        
-        # like the job does
-        Resque.redis = ResqueBus.redis
-        
-        @worker = Resque::Worker.new(:testing)
-        @worker.register_worker
-      end
-      
-      it "should use the app's redis within the rider" do
-        host = Resque.redis.instance_variable_get("@redis").instance_variable_get("@client").host
-        host.should == "localhost"
-        
-        ResqueBus.dispatch("r2") do
-          subscribe "event_name" do |attributes|
-            host = Resque.redis.instance_variable_get("@redis").instance_variable_get("@client").host
-            if host == "example.com"
-              Runner1.run(attributes)
-            end
-          end
-        end
-        
-        host = Resque.redis.instance_variable_get("@redis").instance_variable_get("@client").host
-        host.should == "localhost"
-        
-        
-        Runner1.value.should == 0
-        perform_next_job @worker
-        Runner1.value.should == 1
-      end
-      
-      it "should put it in the failed jobs" do
- 
-        ResqueBus.dispatch("r2") do
-          subscribe "event_name" do |attributes|
-            raise "boo!"
-          end
-        end
-        
-        perform_next_job @worker
-        Resque.info[:processed].should == 1
-        Resque.info[:failed].should == 1
-        Resque.info[:pending].should == 1 # requeued
-
-        perform_next_job @worker
-        Resque.info[:processed].should == 2
-        Resque.info[:failed].should == 2
-        Resque.info[:pending].should == 0
-      end
-    end    
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,73 +1,70 @@
 require 'timecop'
-require 'resque-bus'
-require 'resque/scheduler'
+require 'queue-bus'
+require 'adapter/support'
 
-module ResqueBus
+reset_test_adapter
+
+module QueueBus
   class Runner
     def self.value
       @value ||= 0
     end
-    
+
     def self.attributes
       @attributes
     end
-    
+
     def self.run(attrs)
       @value ||= 0
       @value += 1
       @attributes = attrs
     end
-    
+
     def self.reset
       @value = nil
       @attributes = nil
     end
   end
-  
+
   class Runner1 < Runner
   end
-  
+
   class Runner2 < Runner
   end
 end
 
-def perform_next_job(worker, &block)
-  return unless job = @worker.reserve
-  @worker.perform(job, &block)
-  @worker.done_working
-end
-
 def test_sub(event_name, queue="default")
   matcher = {"bus_event_type" => event_name}
-  ResqueBus::Subscription.new(queue, event_name, "::ResqueBus::Rider", matcher, nil)
+  QueueBus::Subscription.new(queue, event_name, "::QueueBus::Rider", matcher, nil)
 end
 
 def test_list(*args)
-  out = ResqueBus::SubscriptionList.new
+  out = QueueBus::SubscriptionList.new
   args.each do |sub|
     out.add(sub)
   end
   out
 end
 
-
-Resque::Scheduler.mute = true
-
 RSpec.configure do |config|
-  config.mock_framework = :rspec
-  
+  config.mock_with :rspec do |c|
+    c.syntax = :should
+  end
+  config.expect_with :rspec do |c|
+    c.syntax = :should
+  end
+
   config.before(:each) do
-    ResqueBus.send(:reset)
+    reset_test_adapter
+    ResqueBus.show_deprecations = true
   end
   config.after(:each) do
     begin
-      ResqueBus.redis.flushall
+      QueueBus.redis { |redis| redis.flushall }
     rescue
     end
-    ResqueBus.send(:reset)
-    ResqueBus::Runner1.reset
-    ResqueBus::Runner2.reset
+    QueueBus.send(:reset)
+    QueueBus::Runner1.reset
+    QueueBus::Runner2.reset
   end
 end
-
-ResqueBus.redis.namespace = "resquebus_test"

data/spec/subscriber_spec.rb

@@ -1,78 +1,82 @@
 require 'spec_helper'
 
-class SubscriberTest1
-  include ResqueBus::Subscriber
-  @queue = "myqueue"
-  
-  application :my_thing
-  subscribe :thing_filter, :x => "y"
-  subscribe :event_sub
-  
-  def event_sub(attributes)
-    ResqueBus::Runner1.run(attributes)
-  end
-  
-  def thing_filter(attributes)
-    ResqueBus::Runner2.run(attributes)
-  end
-end
-
-class SubscriberTest2
-  include ResqueBus::Subscriber
-  application :test2
-  subscribe :test2,  "value" => :present
-  transform :make_an_int
-  
-  def self.make_an_int(attributes)
-    attributes["value"].to_s.length
-  end
-  
-  def test2(int)
-    ResqueBus::Runner1.run("transformed"=>int)
-  end
-end
-
-module SubModule
-  class SubscriberTest3
-    include ResqueBus::Subscriber
-    
-    subscribe_queue :sub_queue1, :test3, :bus_event_type => "the_event"
-    subscribe_queue :sub_queue2, :the_event
-    subscribe :other, :bus_event_type => "other_event"
-    
-    def test3(attributes)
-      ResqueBus::Runner1.run(attributes)
-    end
-    
-    def the_event(attributes)
-      ResqueBus::Runner2.run(attributes)
-    end
-  end
-  
-  class SubscriberTest4
-    include ResqueBus::Subscriber
-    
-    subscribe_queue :sub_queue1, :test4
-  end
-end
-
-module ResqueBus
-  describe Subscriber do
+  describe QueueBus::Subscriber do
     let(:attributes) { {"x" => "y"} }
     let(:bus_attrs) { {"bus_driven_at" => Time.now.to_i} }
-    
+
     before(:each) do
-      ResqueBus::TaskManager.new(false).subscribe!
+      class SubscriberTest1
+        include QueueBus::Subscriber
+        @queue = "myqueue"
+
+        application :my_thing
+        subscribe :thing_filter, :x => "y"
+        subscribe :event_sub
+
+        def event_sub(attributes)
+          QueueBus::Runner1.run(attributes)
+        end
+
+        def thing_filter(attributes)
+          QueueBus::Runner2.run(attributes)
+        end
+      end
+
+      class SubscriberTest2
+        include QueueBus::Subscriber
+        application :test2
+        subscribe :test2,  "value" => :present
+        transform :make_an_int
+
+        def self.make_an_int(attributes)
+          attributes["value"].to_s.length
+        end
+
+        def test2(int)
+          QueueBus::Runner1.run("transformed"=>int)
+        end
+      end
+
+      module SubModule
+        class SubscriberTest3
+          include QueueBus::Subscriber
+
+          subscribe_queue :sub_queue1, :test3, :bus_event_type => "the_event"
+          subscribe_queue :sub_queue2, :the_event
+          subscribe :other, :bus_event_type => "other_event"
+
+          def test3(attributes)
+            QueueBus::Runner1.run(attributes)
+          end
+
+          def the_event(attributes)
+            QueueBus::Runner2.run(attributes)
+          end
+        end
+
+        class SubscriberTest4
+          include QueueBus::Subscriber
+
+          subscribe_queue :sub_queue1, :test4
+        end
+      end
+
+      Timecop.freeze
+      QueueBus::TaskManager.new(false).subscribe!
     end
-    
+
+    after(:each) do
+      Timecop.return
+    end
+
     it "should have the application" do
       SubscriberTest1.app_key.should == "my_thing"
       SubModule::SubscriberTest3.app_key.should == "sub_module"
       SubModule::SubscriberTest4.app_key.should == "sub_module"
     end
-    
+
     it "should be able to transform the attributes" do
-      dispatcher = ResqueBus.dispatcher_by_key("test2")
+      dispatcher = QueueBus.dispatcher_by_key("test2")
       all = dispatcher.subscriptions.all
       all.size.should == 1
 
@@ -82,154 +86,169 @@ module ResqueBus
       sub.key.should == "SubscriberTest2.test2"
       sub.matcher.filters.should == {"value"=>"bus_special_value_present"}
 
-      Driver.perform(attributes.merge("bus_event_type" => "something2", "value"=>"nice"))
-
-      hash = JSON.parse(ResqueBus.redis.lpop("queue:test2_default"))
-      hash["class"].should == "SubscriberTest2"
-      hash["args"].should == [ {"bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
-                               "bus_event_type" => "something2", "value"=>"nice", "x"=>"y"}.merge(bus_attrs) ]
-                               
-      Runner1.value.should == 0
-      Runner2.value.should == 0
-      Util.constantize(hash["class"]).perform(*hash["args"])
-      Runner1.value.should == 1
-      Runner2.value.should == 0
-      
-      Runner1.attributes.should == {"transformed" => 4}
-      
-      
-      Driver.perform(attributes.merge("bus_event_type" => "something2", "value"=>"12"))
-      
-      hash = JSON.parse(ResqueBus.redis.lpop("queue:test2_default"))
-      hash["class"].should == "SubscriberTest2"
-      hash["args"].should == [ {"bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
-                               "bus_event_type" => "something2", "value"=>"12", "x"=>"y"}.merge(bus_attrs) ]
-                               
-      Runner1.value.should == 1
-      Runner2.value.should == 0
-      Util.constantize(hash["class"]).perform(*hash["args"])
-      Runner1.value.should == 2
-      Runner2.value.should == 0
-      
-      Runner1.attributes.should == {"transformed" => 2}
+      QueueBus::Driver.perform(attributes.merge("bus_event_type" => "something2", "value"=>"nice"))
+
+      hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:test2_default") })
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should eq({"bus_class_proxy" => "SubscriberTest2", "bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
+                               "bus_event_type" => "something2", "value"=>"nice", "x"=>"y"}.merge(bus_attrs))
+
+      QueueBus::Runner1.value.should == 0
+      QueueBus::Runner2.value.should == 0
+      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
+      QueueBus::Runner1.value.should == 1
+      QueueBus::Runner2.value.should == 0
+
+      QueueBus::Runner1.attributes.should == {"transformed" => 4}
+
+
+      QueueBus::Driver.perform(attributes.merge("bus_event_type" => "something2", "value"=>"12"))
+
+      hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:test2_default") })
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubscriberTest2", "bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
+                               "bus_event_type" => "something2", "value"=>"12", "x"=>"y"}.merge(bus_attrs)
+
+      QueueBus::Runner1.value.should == 1
+      QueueBus::Runner2.value.should == 0
+      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
+      QueueBus::Runner1.value.should == 2
+      QueueBus::Runner2.value.should == 0
+
+      QueueBus::Runner1.attributes.should == {"transformed" => 2}
     end
-      
-    
+
+
     it "should put in a different queue" do
-      dispatcher = ResqueBus.dispatcher_by_key("sub_module")
+      dispatcher = QueueBus.dispatcher_by_key("sub_module")
       all = dispatcher.subscriptions.all
       all.size.should == 4
-      
+
       sub = all.select{ |s| s.key == "SubModule::SubscriberTest3.test3"}.first
       sub.queue_name.should == "sub_queue1"
       sub.class_name.should == "SubModule::SubscriberTest3"
       sub.key.should == "SubModule::SubscriberTest3.test3"
       sub.matcher.filters.should == {"bus_event_type"=>"the_event"}
-      
+
       sub = all.select{ |s| s.key == "SubModule::SubscriberTest3.the_event"}.first
       sub.queue_name.should == "sub_queue2"
       sub.class_name.should == "SubModule::SubscriberTest3"
       sub.key.should == "SubModule::SubscriberTest3.the_event"
       sub.matcher.filters.should == {"bus_event_type"=>"the_event"}
-      
+
       sub = all.select{ |s| s.key == "SubModule::SubscriberTest3.other"}.first
       sub.queue_name.should == "sub_module_default"
       sub.class_name.should == "SubModule::SubscriberTest3"
       sub.key.should == "SubModule::SubscriberTest3.other"
       sub.matcher.filters.should == {"bus_event_type"=>"other_event"}
-      
+
       sub = all.select{ |s| s.key == "SubModule::SubscriberTest4.test4"}.first
       sub.queue_name.should == "sub_queue1"
       sub.class_name.should == "SubModule::SubscriberTest4"
       sub.key.should == "SubModule::SubscriberTest4.test4"
       sub.matcher.filters.should == {"bus_event_type"=>"test4"}
-      
-      Driver.perform(attributes.merge("bus_event_type" => "the_event"))
-
-      hash = JSON.parse(ResqueBus.redis.lpop("queue:sub_queue1"))
-      hash["class"].should == "SubModule::SubscriberTest3"
-      hash["args"].should == [ {"bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.test3", "bus_rider_queue" => "sub_queue1", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
-                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs) ]
-                                
-      Runner1.value.should == 0
-      Runner2.value.should == 0
-      Util.constantize(hash["class"]).perform(*hash["args"])
-      Runner1.value.should == 1
-      Runner2.value.should == 0
-      
-      hash = JSON.parse(ResqueBus.redis.lpop("queue:sub_queue2"))
-      hash["class"].should == "SubModule::SubscriberTest3"
-      hash["args"].should == [ {"bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.the_event", "bus_rider_queue" => "sub_queue2", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
-                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs) ]
-                                
-      Runner1.value.should == 1
-      Runner2.value.should == 0
-      Util.constantize(hash["class"]).perform(*hash["args"])
-      Runner1.value.should == 1
-      Runner2.value.should == 1
+
+      QueueBus::Driver.perform(attributes.merge("bus_event_type" => "the_event"))
+
+      hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:sub_queue1") })
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubModule::SubscriberTest3", "bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.test3", "bus_rider_queue" => "sub_queue1", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
+                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs)
+
+      QueueBus::Runner1.value.should == 0
+      QueueBus::Runner2.value.should == 0
+      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
+      QueueBus::Runner1.value.should == 1
+      QueueBus::Runner2.value.should == 0
+
+      hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:sub_queue2") })
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubModule::SubscriberTest3", "bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.the_event", "bus_rider_queue" => "sub_queue2", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
+                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs)
+
+      QueueBus::Runner1.value.should == 1
+      QueueBus::Runner2.value.should == 0
+      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
+      QueueBus::Runner1.value.should == 1
+      QueueBus::Runner2.value.should == 1
     end
-    
+
     it "should subscribe to default and attributes" do
-      dispatcher = ResqueBus.dispatcher_by_key("my_thing")
+      dispatcher = QueueBus.dispatcher_by_key("my_thing")
       all = dispatcher.subscriptions.all
-      
+
       sub = all.select{ |s| s.key == "SubscriberTest1.event_sub"}.first
       sub.queue_name.should == "myqueue"
       sub.class_name.should == "SubscriberTest1"
       sub.key.should == "SubscriberTest1.event_sub"
       sub.matcher.filters.should == {"bus_event_type"=>"event_sub"}
-      
+
       sub = all.select{ |s| s.key == "SubscriberTest1.thing_filter"}.first
       sub.queue_name.should == "myqueue"
       sub.class_name.should == "SubscriberTest1"
       sub.key.should == "SubscriberTest1.thing_filter"
       sub.matcher.filters.should == {"x"=>"y"}
-      
-      Driver.perform(attributes.merge("bus_event_type" => "event_sub"))
-      ResqueBus.redis.smembers("queues").should =~ ["myqueue"]
-
-      hash = JSON.parse(ResqueBus.redis.lpop("queue:myqueue"))
-      hash["class"].should == "SubscriberTest1"
-      hash["args"].should == [ {"bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.event_sub", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
-                                "bus_event_type" => "event_sub", "x" => "y"}.merge(bus_attrs) ]
-                                
-      Runner1.value.should == 0
-      Runner2.value.should == 0
-      Util.constantize(hash["class"]).perform(*hash["args"])
-      Runner1.value.should == 1
-      Runner2.value.should == 0
-      
-      hash = JSON.parse(ResqueBus.redis.lpop("queue:myqueue"))
-      hash["class"].should == "SubscriberTest1"
-      hash["args"].should == [ {"bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
-                                "bus_event_type" => "event_sub", "x" => "y"}.merge(bus_attrs) ]
-                                
-      Runner1.value.should == 1
-      Runner2.value.should == 0
-      Util.constantize(hash["class"]).perform(*hash["args"])
-      Runner1.value.should == 1
-      Runner2.value.should == 1
-      
-      Driver.perform(attributes.merge("bus_event_type" => "event_sub_other"))
-      ResqueBus.redis.smembers("queues").should =~ ["myqueue"]
-      
-      hash = JSON.parse(ResqueBus.redis.lpop("queue:myqueue"))
-      hash["class"].should == "SubscriberTest1"
-      hash["args"].should == [ {"bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
-                                "bus_event_type" => "event_sub_other", "x" => "y"}.merge(bus_attrs) ]
-                                
-      Runner1.value.should == 1
-      Runner2.value.should == 1
-      Util.constantize(hash["class"]).perform(*hash["args"])
-      Runner1.value.should == 1
-      Runner2.value.should == 2
-      
-      Driver.perform({"x"=>"z"}.merge("bus_event_type" => "event_sub_other"))
-      ResqueBus.redis.smembers("queues").should =~ ["myqueue"]
-      
-      ResqueBus.redis.lpop("queue:myqueue").should be_nil
+
+      QueueBus::Driver.perform(attributes.merge("bus_event_type" => "event_sub"))
+      QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["myqueue"]
+
+      pop1 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:myqueue") })
+      pop2 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:myqueue") })
+
+      if JSON.parse(pop1["args"].first)["bus_rider_sub_key"] == "SubscriberTest1.thing_filter"
+        hash1 = pop1
+        hash2 = pop2
+      else
+        hash1 = pop2
+        hash2 = pop1
+      end
+
+      hash1["class"].should == "QueueBus::Worker"
+      JSON.parse(hash1["args"].first).should eq({"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
+                                "bus_event_type" => "event_sub", "x" => "y"}.merge(bus_attrs))
+
+      QueueBus::Runner1.value.should == 0
+      QueueBus::Runner2.value.should == 0
+      QueueBus::Util.constantize(hash1["class"]).perform(*hash1["args"])
+      QueueBus::Runner1.value.should == 0
+      QueueBus::Runner2.value.should == 1
+
+      hash2["class"].should == "QueueBus::Worker"
+      hash2["args"].size.should == 1
+      JSON.parse(hash2["args"].first).should == {"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.event_sub", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
+                                "bus_event_type" => "event_sub", "x" => "y"}.merge(bus_attrs)
+
+      QueueBus::Runner1.value.should == 0
+      QueueBus::Runner2.value.should == 1
+      QueueBus::Util.constantize(hash2["class"]).perform(*hash2["args"])
+      QueueBus::Runner1.value.should == 1
+      QueueBus::Runner2.value.should == 1
+
+      QueueBus::Driver.perform(attributes.merge("bus_event_type" => "event_sub_other"))
+      QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["myqueue"]
+
+      hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:myqueue") })
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
+                                "bus_event_type" => "event_sub_other", "x" => "y"}.merge(bus_attrs)
+
+      QueueBus::Runner1.value.should == 1
+      QueueBus::Runner2.value.should == 1
+      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
+      QueueBus::Runner1.value.should == 1
+      QueueBus::Runner2.value.should == 2
+
+      QueueBus::Driver.perform({"x"=>"z"}.merge("bus_event_type" => "event_sub_other"))
+      QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["myqueue"]
+
+      QueueBus.redis { |redis| redis.lpop("queue:myqueue") }.should be_nil
     end
-    
+
     describe ".perform" do
       let(:attributes) { {"bus_rider_sub_key"=>"SubscriberTest1.event_sub", "bus_locale" => "en", "bus_timezone" => "PST"} }
       it "should call the method based on key" do
@@ -238,15 +257,14 @@ module ResqueBus
       end
       it "should set the timezone and locale if present" do
         defined?(I18n).should be_nil
-        Time.respond_to?(:zone).should be_false
+        Time.respond_to?(:zone).should eq(false)
 
         stub_const("I18n", Class.new)
         I18n.should_receive(:locale=).with("en")
         Time.should_receive(:zone=).with("PST")
-        
+
         SubscriberTest1.any_instance.should_receive(:event_sub)
         SubscriberTest1.perform(attributes)
       end
     end
   end
-end