resque-bus 0.3.7 → 0.5.7

data/spec/application_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module ResqueBus
+module QueueBus
   describe Application do
     describe ".all" do
       it "should return empty array when none" do
@@ -10,143 +10,143 @@ module ResqueBus
         Application.new("One").subscribe(test_list(test_sub("fdksjh")))
         Application.new("Two").subscribe(test_list(test_sub("fdklhf")))
         Application.new("Three").subscribe(test_list(test_sub("fkld")))
-        
+
         Application.all.collect(&:app_key).should =~ ["one", "two", "three"]
-        
+
         Application.new("two").unsubscribe
         Application.all.collect(&:app_key).should =~ ["one", "three"]
       end
     end
-    
+
     describe ".new" do
       it "should have a key" do
         Application.new("something").app_key.should == "something"
-      
+
         Application.new("some thing").app_key.should == "some_thing"
         Application.new("some-thing").app_key.should == "some_thing"
         Application.new("some_thing").app_key.should == "some_thing"
         Application.new("Some Thing").app_key.should == "some_thing"
       end
-    
+
       it "should raise an error if not valid" do
         lambda {
           Application.new("")
         }.should raise_error
-      
+
         lambda {
           Application.new(nil)
         }.should raise_error
-      
+
         lambda {
           Application.new("/")
         }.should raise_error
       end
     end
-    
+
     describe "#read_redis_hash" do
       it "should handle old and new values" do
-        
-        ResqueBus.redis.hset("resquebus_app:myapp", "new_one", Resque.encode("queue_name" => "x", "bus_event_type" => "event_name"))
-        ResqueBus.redis.hset("resquebus_app:myapp", "old_one", "oldqueue_name")
+
+        QueueBus.redis { |redis| redis.hset("bus_app:myapp", "new_one", QueueBus::Util.encode("queue_name" => "x", "bus_event_type" => "event_name") ) }
+        QueueBus.redis { |redis| redis.hset("bus_app:myapp", "old_one", "oldqueue_name") }
         app = Application.new("myapp")
         val = app.send(:read_redis_hash)
         val.should == {"new_one" => {"queue_name" => "x", "bus_event_type" => "event_name"}, "old_one" => "oldqueue_name"}
       end
     end
-  
+
     describe "#subscribe" do
       let(:sub1) { test_sub("event_one", "default") }
       let(:sub2) { test_sub("event_two", "default") }
       let(:sub3) { test_sub("event_three", "other") }
       it "should add array to redis" do
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
         Application.new("myapp").subscribe(test_list(sub1, sub2))
-      
-        ResqueBus.redis.hgetall("resquebus_app:myapp").should == {"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}", 
-                                                                  "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"}
-        ResqueBus.redis.hkeys("resquebus_app:myapp").should =~ ["event_one", "event_two"]
-        ResqueBus.redis.smembers("resquebus_apps").should =~ ["myapp"]
+
+        QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }.should == {"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}",
+                                                                  "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"}
+        QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }.should =~ ["event_one", "event_two"]
+        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should =~ ["myapp"]
       end
       it "should add string to redis" do
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
         Application.new("myapp").subscribe(test_list(sub1))
-      
-        ResqueBus.redis.hgetall("resquebus_app:myapp").should == {"event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"}
-        ResqueBus.redis.hkeys("resquebus_app:myapp").should =~ ["event_one"]
-        ResqueBus.redis.smembers("resquebus_apps").should =~ ["myapp"]
+
+        QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }.should == {"event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"}
+        QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }.should =~ ["event_one"]
+        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should =~ ["myapp"]
       end
       it "should multiple queues to redis" do
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
         Application.new("myapp").subscribe(test_list(sub1, sub2, sub3))
-        ResqueBus.redis.hgetall("resquebus_app:myapp").should == {"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}", "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}", 
-                                                                  "event_three"=>"{\"queue_name\":\"other\",\"key\":\"event_three\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_three\"}}"}
-        ResqueBus.redis.hkeys("resquebus_app:myapp").should =~ ["event_three", "event_two", "event_one"]
-        ResqueBus.redis.smembers("resquebus_apps").should =~ ["myapp"]
+        QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }.should == {"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}", "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}",
+                                                                  "event_three"=>"{\"queue_name\":\"other\",\"key\":\"event_three\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_three\"}}"}
+        QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }.should =~ ["event_three", "event_two", "event_one"]
+        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should =~ ["myapp"]
       end
-    
+
       it "should do nothing if nil or empty" do
-      
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
-      
+
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+
         Application.new("myapp").subscribe(nil)
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
-      
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+
         Application.new("myapp").subscribe([])
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
       end
-      
+
       it "should call unsubscribe" do
         app = Application.new("myapp")
         app.should_receive(:unsubscribe)
         app.subscribe([])
       end
     end
-  
+
     describe "#unsubscribe" do
       it "should remove items" do
-        ResqueBus.redis.sadd("resquebus_apps", "myapp")
-        ResqueBus.redis.sadd("resquebus_apps", "other")
-        ResqueBus.redis.hset("resquebus_app:myapp", "event_one", "myapp_default")
-      
+        QueueBus.redis { |redis| redis.sadd("bus_apps", "myapp") }
+        QueueBus.redis { |redis| redis.sadd("bus_apps", "other") }
+        QueueBus.redis { |redis| redis.hset("bus_app:myapp", "event_one", "myapp_default") }
+
         Application.new("myapp").unsubscribe
-      
-        ResqueBus.redis.smembers("resquebus_apps").should == ["other"]
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+
+        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should == ["other"]
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
       end
     end
-    
+
     describe "#subscription_matches" do
       it "should return if it is there" do
         Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
-        
+
         subs = test_list(test_sub("one_x"), test_sub("one_y"), test_sub("one"), test_sub("two"))
         Application.new("myapp").subscribe(subs)
         Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
-        
-        Application.new("myapp").subscription_matches("bus_event_type"=>"two").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "two", "default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one", "default", "::ResqueBus::Rider"]]
+
+        Application.new("myapp").subscription_matches("bus_event_type"=>"two").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "two", "default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one", "default", "::QueueBus::Rider"]]
       end
-      
+
       it "should handle * wildcards" do
         subs = test_list(test_sub("one.+"), test_sub("one"), test_sub("one_.*"), test_sub("two"))
         Application.new("myapp").subscribe(subs)
         Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
-        
-        Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one.+", "default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one", "default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one.+","default", "::ResqueBus::Rider"], ["myapp", "one_.*", "default", "::ResqueBus::Rider"]]
+
+        Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one.+", "default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one", "default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one.+","default", "::QueueBus::Rider"], ["myapp", "one_.*", "default", "::QueueBus::Rider"]]
       end
-      
+
       it "should handle actual regular expressions" do
         subs = test_list(test_sub(/one.+/), test_sub("one"), test_sub(/one_.*/), test_sub("two"))
         Application.new("myapp").subscribe(subs)
         Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
-        
-        Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"donex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one" ,"default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::ResqueBus::Rider"], ["myapp", "(?-mix:one_.*)", "default", "::ResqueBus::Rider"]]
+
+        Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"donex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one" ,"default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"], ["myapp", "(?-mix:one_.*)", "default", "::QueueBus::Rider"]]
       end
     end
   end
-end
+end

data/spec/config_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+module QueueBus
+  module Adapters
+    class TestOne
+
+    end
+  end
+end
+
+describe "QueueBus config" do
+  it "should set the default app key" do
+    QueueBus.default_app_key.should == nil
+
+    QueueBus.default_app_key = "my_app"
+    QueueBus.default_app_key.should == "my_app"
+
+    QueueBus.default_app_key = "something here"
+    QueueBus.default_app_key.should == "something_here"
+  end
+
+  it "should set the default queue" do
+    QueueBus.default_queue.should == nil
+
+    QueueBus.default_queue = "my_queue"
+    QueueBus.default_queue.should == "my_queue"
+  end
+
+  it "should set the local mode" do
+    QueueBus.local_mode.should == nil
+    QueueBus.local_mode = :standalone
+    QueueBus.local_mode.should == :standalone
+  end
+
+  it "should set the hostname" do
+    QueueBus.hostname.should_not == nil
+    QueueBus.hostname = "whatever"
+    QueueBus.hostname.should == "whatever"
+  end
+
+  it "should set before_publish callback" do
+    QueueBus.before_publish = lambda {|attributes| 42 }
+    QueueBus.before_publish_callback({}).should == 42
+  end
+
+
+  it "should use the default Redis connection" do
+    QueueBus.redis { |redis| redis }.should_not eq(nil)
+  end
+
+  it "should default to given adapter" do
+    QueueBus.adapter.is_a?(adapter_under_test_class).should == true
+
+    # and should raise if already set
+    lambda {
+      QueueBus.adapter = :data
+    }.should raise_error
+  end
+
+  context "with a fresh load" do
+    before(:each) do
+      QueueBus.send(:reset)
+    end
+
+    it "should be able to be set to resque" do
+      QueueBus.adapter = adapter_under_test_symbol
+      QueueBus.adapter.is_a?(adapter_under_test_class).should == true
+
+      # and should raise if already set
+      lambda {
+        QueueBus.adapter = :data
+      }.should raise_error
+    end
+
+    it "should be able to be set to something else" do
+
+      QueueBus.adapter = :test_one
+      QueueBus.adapter.is_a?(QueueBus::Adapters::TestOne).should == true
+    end
+  end
+
+
+end

data/spec/dispatch_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper' 
 
-module ResqueBus
+module QueueBus
   describe Dispatch do
     it "should not start with any applications" do
       Dispatch.new("d").subscriptions.size.should == 0
@@ -29,7 +29,7 @@ module ResqueBus
     
     describe "Top Level" do
       before(:each) do
-         ResqueBus.dispatch("testit") do
+         QueueBus.dispatch("testit") do
            subscribe "event1" do |attributes|
              Runner2.run(attributes)
            end
@@ -50,16 +50,16 @@ module ResqueBus
        
       it "should register and run" do
         Runner2.value.should == 0
-        ResqueBus.dispatcher_execute("testit", "event2", "bus_event_type" => "event2")
+        QueueBus.dispatcher_execute("testit", "event2", "bus_event_type" => "event2")
         Runner2.value.should == 1
-        ResqueBus.dispatcher_execute("testit", "event1", "bus_event_type" => "event1")
+        QueueBus.dispatcher_execute("testit", "event1", "bus_event_type" => "event1")
         Runner2.value.should == 2
-        ResqueBus.dispatcher_execute("testit", "event1", "bus_event_type" => "event1")
+        QueueBus.dispatcher_execute("testit", "event1", "bus_event_type" => "event1")
         Runner2.value.should == 3
       end
       
       it "should return the subscriptions" do
-        dispatcher = ResqueBus.dispatcher_by_key("testit")
+        dispatcher = QueueBus.dispatcher_by_key("testit")
         subs = dispatcher.subscriptions.all
         tuples = subs.collect{ |sub| [sub.key, sub.queue_name]}
         tuples.should =~ [  ["event1", "testit_default"],

data/spec/driver_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module ResqueBus
+module QueueBus
   describe Driver do
     before(:each) do
       Application.new("app1").subscribe(test_list(test_sub("event1"), test_sub("event2"), test_sub("event3")))
@@ -11,81 +11,99 @@ module ResqueBus
     after(:each) do
       Timecop.return
     end
-    
-    let(:bus_attrs) { {"bus_driven_at" => Time.now.to_i, "bus_rider_class_name"=>"::ResqueBus::Rider"} }
-    
+
+    let(:bus_attrs) { {"bus_driven_at" => Time.now.to_i, "bus_rider_class_name"=>"::QueueBus::Rider", "bus_class_proxy" => "::QueueBus::Rider"} }
+
     describe ".subscription_matches" do
       it "return empty array when none" do
         Driver.subscription_matches("bus_event_type" => "else").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
         Driver.subscription_matches("bus_event_type" => "event").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
       end
       it "should return a match" do
-        Driver.subscription_matches("bus_event_type" => "event1").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app1", "event1", "default", "::ResqueBus::Rider"]]
-        Driver.subscription_matches("bus_event_type" => "event6").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event6", "default", "::ResqueBus::Rider"]]
+        Driver.subscription_matches("bus_event_type" => "event1").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app1", "event1", "default", "::QueueBus::Rider"]]
+        Driver.subscription_matches("bus_event_type" => "event6").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event6", "default", "::QueueBus::Rider"]]
       end
       it "should match multiple apps" do
-        Driver.subscription_matches("bus_event_type" => "event2").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app1", "event2", "default", "::ResqueBus::Rider"], ["app2", "event2", "other", "::ResqueBus::Rider"]]
+        Driver.subscription_matches("bus_event_type" => "event2").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app1", "event2", "default", "::QueueBus::Rider"], ["app2", "event2", "other", "::QueueBus::Rider"]]
       end
       it "should match multiple apps with patterns" do
-        Driver.subscription_matches("bus_event_type" => "event4").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event[45]", "default", "::ResqueBus::Rider"], ["app2", "event4", "more", "::ResqueBus::Rider"]]
+        Driver.subscription_matches("bus_event_type" => "event4").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event[45]", "default", "::QueueBus::Rider"], ["app2", "event4", "more", "::QueueBus::Rider"]]
       end
       it "should match multiple events in same app" do
-        Driver.subscription_matches("bus_event_type" => "event5").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event[45]", "default", "::ResqueBus::Rider"], ["app3", "event5", "default", "::ResqueBus::Rider"]]
+        Driver.subscription_matches("bus_event_type" => "event5").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event[45]", "default", "::QueueBus::Rider"], ["app3", "event5", "default", "::QueueBus::Rider"]]
       end
     end
-    
+
     describe ".perform" do
       let(:attributes) { {"x" => "y"} }
-      
+
       before(:each) do
-        ResqueBus.redis.smembers("queues").should == []
-        ResqueBus.redis.lpop("queue:app1_default").should be_nil
-        ResqueBus.redis.lpop("queue:app2_default").should be_nil
-        ResqueBus.redis.lpop("queue:app3_default").should be_nil
+        QueueBus.redis { |redis| redis.smembers("queues") }.should == []
+        QueueBus.redis { |redis| redis.lpop("queue:app1_default") }.should be_nil
+        QueueBus.redis { |redis| redis.lpop("queue:app2_default") }.should be_nil
+        QueueBus.redis { |redis| redis.lpop("queue:app3_default") }.should be_nil
       end
-      
+
       it "should do nothing when empty" do
         Driver.perform(attributes.merge("bus_event_type" => "else"))
-        ResqueBus.redis.smembers("queues").should == []
+        QueueBus.redis { |redis| redis.smembers("queues") }.should == []
       end
-      
+
       it "should queue up the riders in redis" do
-        ResqueBus.redis.lpop("queue:app1_default").should be_nil
+        QueueBus.redis { |redis| redis.lpop("queue:app1_default") }.should be_nil
         Driver.perform(attributes.merge("bus_event_type" => "event1"))
-        ResqueBus.redis.smembers("queues").should =~ ["default"]
+        QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default"]
 
-        hash = JSON.parse(ResqueBus.redis.lpop("queue:default"))
-        hash["class"].should == "::ResqueBus::Rider"
-        hash["args"].should == [ {"bus_rider_app_key"=>"app1", "x" => "y", "bus_event_type" => "event1", "bus_rider_sub_key"=>"event1", "bus_rider_queue" => "default"}.merge(bus_attrs) ]
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
+        hash["class"].should == "QueueBus::Worker"
+        hash["args"].size.should == 1
+        JSON.parse(hash["args"].first).should == {"bus_rider_app_key"=>"app1", "x" => "y", "bus_event_type" => "event1", "bus_rider_sub_key"=>"event1", "bus_rider_queue" => "default"}.merge(bus_attrs)
       end
-      
+
       it "should queue up to multiple" do
         Driver.perform(attributes.merge("bus_event_type" => "event4"))
-        ResqueBus.redis.smembers("queues").should =~ ["default", "more"]
-
-        hash = JSON.parse(ResqueBus.redis.lpop("queue:more"))
-        hash["class"].should == "::ResqueBus::Rider"
-        hash["args"].should == [ {"bus_rider_app_key"=>"app2", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event4", "bus_rider_queue" => "more"}.merge(bus_attrs) ]
-        
-        hash = JSON.parse(ResqueBus.redis.lpop("queue:default"))
-        hash["class"].should == "::ResqueBus::Rider"
-        hash["args"].should == [ {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs) ]
+        QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default", "more"]
+
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:more") })
+        hash["class"].should == "QueueBus::Worker"
+        hash["args"].size.should == 1
+        JSON.parse(hash["args"].first).should == {"bus_rider_app_key"=>"app2", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event4", "bus_rider_queue" => "more"}.merge(bus_attrs)
+
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
+        hash["class"].should == "QueueBus::Worker"
+        hash["args"].size.should == 1
+        JSON.parse(hash["args"].first).should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs)
       end
-      
+
       it "should queue up to the same" do
         Driver.perform(attributes.merge("bus_event_type" => "event5"))
-        ResqueBus.redis.smembers("queues").should =~ ["default"]
+        QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default"]
+
+        QueueBus.redis { |redis| redis.llen("queue:default") }.should == 2
+
+        pop1 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
+        pop2 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
+
+        pargs1 = JSON.parse(pop1["args"].first)
+        pargs2 = JSON.parse(pop2["args"].first)
+        if pargs1["bus_rider_sub_key"] == "event5"
+          hash1 = pop1
+          hash2 = pop2
+          args1 = pargs1
+          args2 = pargs2
+        else
+          hash1 = pop2
+          hash2 = pop1
+          args1 = pargs2
+          args2 = pargs1
+        end
 
-        ResqueBus.redis.llen("queue:default").should == 2
-        
-        hash = JSON.parse(ResqueBus.redis.lpop("queue:default"))
-        hash["class"].should == "::ResqueBus::Rider"
-        hash["args"][0].should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event5", "bus_rider_queue" => "default"}.merge(bus_attrs)
+        hash1["class"].should == "QueueBus::Worker"
+        args1.should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event5", "bus_rider_queue" => "default"}.merge(bus_attrs)
 
-        hash = JSON.parse(ResqueBus.redis.lpop("queue:default"))
-        hash["class"].should == "::ResqueBus::Rider"
-        hash["args"][0].should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs)
+        hash2["class"].should == "QueueBus::Worker"
+        args2.should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs)
       end
     end
   end
-end
+end

data/spec/heartbeat_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module ResqueBus
+module QueueBus
   describe Heartbeat do
     def now_attributes
       {
@@ -20,7 +20,7 @@ module ResqueBus
     
     it "should publish the current time once" do
       Timecop.freeze "12/12/2013 12:01:19" do
-        ResqueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
+        QueueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
         Heartbeat.perform
       end
       
@@ -31,12 +31,12 @@ module ResqueBus
     
     it "should publish a minute later" do
       Timecop.freeze "12/12/2013 12:01:19" do
-        ResqueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
+        QueueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
         Heartbeat.perform
       end
       
       Timecop.freeze "12/12/2013 12:02:01" do
-        ResqueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
+        QueueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
         Heartbeat.perform
       end
     end

data/spec/integration_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module ResqueBus
+module QueueBus
   describe "Integration" do
     it "should round trip attributes" do      
       write1 = Subscription.new("default", "key1", "MyClass1", {"bus_event_type" => "event_one"})
@@ -23,7 +23,7 @@ module ResqueBus
       app = Application.new("test")
       app.subscribe(write)
     
-      ResqueBus.send(:reset)  # reset to make sure we read from redis
+      reset_test_adapter  # reset to make sure we read from redis
       app = Application.new("test")
       read = app.send(:subscriptions)