resque-bus 0.3.2 → 0.7.0

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,90 +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"]
-
-        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)
-        first = hash["args"][0]["bus_rider_sub_key"]
-        
-        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)
-        second= hash["args"][0]["bus_rider_sub_key"]
-        
-        if first == "event[45]"
-          second.should == "event5"
+        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
-          first.should == "event5"
-          second.should == "event[45]"
+          hash1 = pop2
+          hash2 = pop1
+          args1 = pargs2
+          args2 = pargs1
         end
+
+        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)
+
+        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)
     

data/spec/matcher_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module ResqueBus
+module QueueBus
   describe Matcher do
     it "should already return false on empty filters" do
       matcher = Matcher.new({})
@@ -8,19 +8,19 @@ module ResqueBus
       matcher.matches?(nil).should  == false
       matcher.matches?("name" => "val").should == false
     end
-    
+
     it "should not crash if nil inputs" do
       matcher = Matcher.new("name" => "val")
       matcher.matches?(nil).should == false
     end
-    
+
     it "string filter to/from redis" do
       matcher = Matcher.new("name" => "val")
       matcher.matches?("name" => "val").should   == true
       matcher.matches?("name" => " val").should  == false
       matcher.matches?("name" => "zval").should  == false
     end
-    
+
     it "regex filter" do
       matcher = Matcher.new("name" => /^[cb]a+t/)
       matcher.matches?("name" => "cat").should == true
@@ -29,7 +29,7 @@ module ResqueBus
       matcher.matches?("name" => "ct").should == false
       matcher.matches?("name" => "bcat").should == false
     end
-    
+
     it "present filter" do
       matcher = Matcher.new("name" => :present)
       matcher.matches?("name" => "").should == false
@@ -37,7 +37,7 @@ module ResqueBus
       matcher.matches?("name" => "bear").should == true
       matcher.matches?("other" => "bear").should == false
     end
-    
+
     it "blank filter" do
       matcher = Matcher.new("name" => :blank)
       matcher.matches?("name" => nil).should == true
@@ -47,7 +47,7 @@ module ResqueBus
       matcher.matches?("name" => "bear").should == false
       matcher.matches?("name" => "   s ").should == false
     end
-    
+
     it "nil filter" do
       matcher = Matcher.new("name" => :nil)
       matcher.matches?("name" => nil).should == true
@@ -56,7 +56,7 @@ module ResqueBus
       matcher.matches?("name" => "  ").should == false
       matcher.matches?("name" => "bear").should == false
     end
-    
+
     it "key filter" do
       matcher = Matcher.new("name" => :key)
       matcher.matches?("name" => nil).should == true
@@ -65,7 +65,7 @@ module ResqueBus
       matcher.matches?("name" => "  ").should == true
       matcher.matches?("name" => "bear").should == true
     end
-    
+
     it "empty filter" do
       matcher = Matcher.new("name" => :empty)
       matcher.matches?("name" => nil).should == false
@@ -75,7 +75,7 @@ module ResqueBus
       matcher.matches?("name" => "bear").should == false
       matcher.matches?("name" => "   s ").should == false
     end
-    
+
     it "value filter" do
       matcher = Matcher.new("name" => :value)
       matcher.matches?("name" => nil).should == false
@@ -85,7 +85,7 @@ module ResqueBus
       matcher.matches?("name" => "bear").should == true
       matcher.matches?("name" => "   s ").should == true
     end
-    
+
     it "multiple filters" do
       matcher = Matcher.new("name" => /^[cb]a+t/, "state" => "sleeping")
       matcher.matches?("state" => "sleeping", "name" => "cat").should  == true
@@ -94,7 +94,7 @@ module ResqueBus
       matcher.matches?("state" => "sleeping", "name" => "bear").should == false
       matcher.matches?("state" => "awake", "name" => "bear").should    == false
     end
-    
+
     it "regex should go back and forth into redis" do
       matcher = Matcher.new("name" => /^[cb]a+t/)
       matcher.matches?("name" => "cat").should == true
@@ -102,40 +102,40 @@ module ResqueBus
       matcher.matches?("name" => "caaaaat").should == true
       matcher.matches?("name" => "ct").should == false
       matcher.matches?("name" => "bcat").should == false
-      
-      ResqueBus.redis.set("temp1", Resque.encode(matcher.to_redis))
-      redis = ResqueBus.redis.get("temp1")
-      matcher = Matcher.new(Resque.decode(redis))
+
+      QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
+      redis = QueueBus.redis { |redis| redis.get("temp1") }
+      matcher = Matcher.new(QueueBus::Util.decode(redis))
       matcher.matches?("name" => "cat").should == true
       matcher.matches?("name" => "bat").should == true
       matcher.matches?("name" => "caaaaat").should == true
       matcher.matches?("name" => "ct").should == false
       matcher.matches?("name" => "bcat").should == false
-      
-      ResqueBus.redis.set("temp2", Resque.encode(matcher.to_redis))
-      redis = ResqueBus.redis.get("temp2")
-      matcher = Matcher.new(Resque.decode(redis))
+
+      QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
+      redis = QueueBus.redis { |redis| redis.get("temp2") }
+      matcher = Matcher.new(QueueBus::Util.decode(redis))
       matcher.matches?("name" => "cat").should == true
       matcher.matches?("name" => "bat").should == true
       matcher.matches?("name" => "caaaaat").should == true
       matcher.matches?("name" => "ct").should == false
       matcher.matches?("name" => "bcat").should == false
     end
-    
+
     it "special value should go back and forth into redis" do
       matcher = Matcher.new("name" => :blank)
       matcher.matches?("name" => "cat").should == false
       matcher.matches?("name" => "").should    == true
-      
-      ResqueBus.redis.set("temp1", Resque.encode(matcher.to_redis))
-      redis = ResqueBus.redis.get("temp1")
-      matcher = Matcher.new(Resque.decode(redis))
+
+      QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
+      redis= QueueBus.redis { |redis| redis.get("temp1") }
+      matcher = Matcher.new(QueueBus::Util.decode(redis))
       matcher.matches?("name" => "cat").should == false
       matcher.matches?("name" => "").should    == true
-      
-      ResqueBus.redis.set("temp2", Resque.encode(matcher.to_redis))
-      redis = ResqueBus.redis.get("temp2")
-      matcher = Matcher.new(Resque.decode(redis))
+
+      QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
+      redis= QueueBus.redis { |redis| redis.get("temp2") }
+      matcher = Matcher.new(QueueBus::Util.decode(redis))
       matcher.matches?("name" => "cat").should == false
       matcher.matches?("name" => "").should    == true
     end