resque-bus 0.2.3

data/spec/redis_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe "Redis Connection" do
+  it "should use the one specified if given" do
+    ResqueBus.redis = "localhost:9379"
+    ResqueBus.redis.instance_variable_get("@redis").client.port.should == 9379
+    Resque.redis.instance_variable_get("@redis").client.port.should == 6379
+  end
+  it "should use the default Resque connection if none specified" do
+    ResqueBus.redis.instance_variable_get("@redis").client.port.should == 6379
+    Resque.redis.instance_variable_get("@redis").client.port.should == 6379
+  end
+end

data/spec/rider_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+module ResqueBus
+  describe Rider do
+    it "should call execute" do
+      ResqueBus.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
+        subscribe "event_name" do |attributes|
+          Runner1.run(attributes)
+        end
+      end
+      Runner1.value.should == 0
+      Rider.perform("bus_rider_app_key" => "r1", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
+      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
+    
+    
+    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

data/spec/spec_helper.rb

@@ -0,0 +1,75 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'timecop'
+
+require 'resque-bus'
+
+module ResqueBus
+  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)
+end
+
+def test_list(*args)
+  out = ResqueBus::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.before(:each) do
+    ResqueBus.send(:reset)
+  end
+  config.after(:each) do
+    begin
+      ResqueBus.redis.flushall
+    rescue
+    end
+    ResqueBus.send(:reset)
+    ResqueBus::Runner1.reset
+    ResqueBus::Runner2.reset
+  end
+end
+
+ResqueBus.redis.namespace = "resquebus_test"

data/spec/subscriber_spec.rb

@@ -0,0 +1,233 @@
+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
+    let(:attributes) { {"x" => "y"} }
+    let(:bus_attrs) { {"bus_driven_at" => Time.now.to_i} }
+    
+    before(:each) do
+      ResqueBus::TaskManager.new(false).subscribe!
+    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")
+      all = dispatcher.subscriptions.all
+      all.size.should == 1
+
+      sub = all.first
+      sub.queue_name.should == "test2_default"
+      sub.class_name.should == "SubscriberTest2"
+      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}
+    end
+      
+    
+    it "should put in a different queue" do
+      dispatcher = ResqueBus.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
+    end
+    
+    it "should subscribe to default and attributes" do
+      dispatcher = ResqueBus.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
+    end
+  end
+end

data/spec/subscription_list_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module ResqueBus
+  describe SubscriptionList do
+    describe ".from_redis" do
+      it "should return from attributes" do
+        mult = {"event_one" => {"class" => "MyClass", "queue_name" => "default", "key" => "event_one", "matcher" => {"bus_event_type" => "event_one"}}, 
+                "event_two" => {"class" => "MyClass", "queue_name" => "else",    "key" => "event_two", "matcher" => {"bus_event_type" => "event_two"}}}
+
+        list = SubscriptionList.from_redis(mult)
+        list.size.should == 2
+        one = list.key("event_one")
+        two = list.key("event_two")
+        
+        one.key.should == "event_one"
+        one.key.should == "event_one"
+        one.queue_name.should == "default"
+        one.class_name.should == "MyClass"
+        one.matcher.filters.should == {"bus_event_type" => "event_one"}
+        
+        two.key.should == "event_two"
+        two.key.should == "event_two"
+        two.queue_name.should == "else"
+        two.class_name.should == "MyClass"
+        two.matcher.filters.should == {"bus_event_type" => "event_two"}
+      end
+    end
+    
+    describe "#to_redis" do
+      it "should generate what to store" do
+        list = SubscriptionList.new
+        list.add(Subscription.new("default", "key1", "MyClass", {"bus_event_type" => "event_one"}))
+        list.add(Subscription.new("else_ok", "key2", "MyClass", {"bus_event_type" => "event_two"}))
+        
+        hash = list.to_redis
+        hash.should == {  "key1" => {"queue_name" => "default", "key" => "key1", "class" => "MyClass", "matcher" => {"bus_event_type" => "event_one"}}, 
+                          "key2" => {"queue_name" => "else_ok", "key" => "key2", "class" => "MyClass", "matcher" => {"bus_event_type" => "event_two"}}
+                       }
+        
+      end
+    end
+  end
+end

data/spec/subscription_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module ResqueBus
+  describe Subscription do
+    it "should normalize the queue name" do
+      Subscription.new("test",  "my_event", "MyClass", {}, nil).queue_name.should == "test"
+      Subscription.new("tes t", "my_event", "MyClass", {}, nil).queue_name.should == "tes_t"
+      Subscription.new("t%s",   "my_event", "MyClass", {}, nil).queue_name.should == "t_s"
+    end
+    
+    describe ".register" do
+      it "should take in args from dispatcher" do
+        executor = Proc.new { |attributes| }
+        sub = Subscription.register("queue_name", "mykey", "MyClass", {"bus_event_type" => "my_event"}, executor)
+        sub.send(:executor).should == executor
+        sub.matcher.filters.should == {"bus_event_type" => "my_event"}
+        sub.queue_name.should == "queue_name"
+        sub.key.should == "mykey"
+        sub.class_name.should == "MyClass"
+      end
+    end
+    
+    describe "#execute!" do
+      it "should call the executor with the attributes" do
+        exec = Object.new
+        exec.should_receive(:call)
+        
+        sub = Subscription.new("x", "y", "ClassName", {}, exec)
+        sub.execute!({"ok" => true})
+      end
+    end
+    
+    describe "#to_redis" do
+      it "should return what to store for this subscription" do
+        sub = Subscription.new("queue_one", "xyz", "ClassName", {"bus_event_type" => "my_event"}, nil)
+        sub.to_redis.should == {"queue_name" => "queue_one", "key" => "xyz", "class" => "ClassName", "matcher" => {"bus_event_type" => "my_event"}}
+      end
+    end
+    
+    describe "#matches?" do
+      it "should do pattern stuff" do
+        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one"}).matches?("bus_event_type" => "one").should == true
+        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one"}).matches?("bus_event_type" => "onex").should == false
+        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "^one.*$"}).matches?("bus_event_type" => "onex").should == true
+        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one.*"}).matches?("bus_event_type" => "onex").should == true
+        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one.?"}).matches?("bus_event_type" => "onex").should == true
+        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one.?"}).matches?("bus_event_type" => "one").should == true
+        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "\\"}).matches?("bus_event_type" => "one").should == false
+      end
+    end
+    
+  end
+end