sidekiq-bus 0.5.2

data/lib/sidekiq_bus/version.rb

@@ -0,0 +1,3 @@
+module SidekiqBus
+  VERSION = "0.5.2"
+end

data/sidekiq-bus.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sidekiq_bus/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sidekiq-bus"
+  s.version     = SidekiqBus::VERSION
+  s.authors     = ["Brian Leonard"]
+  s.email       = ["brian@bleonard.com"]
+  s.homepage    = "https://github.com/queue-bus/sidekiq-bus"
+  s.summary     = %q{A simple event bus on top of Resque}
+  s.description = %q{A simple event bus on top of Resque. Publish and subscribe to events as they occur through a queue.}
+
+  s.rubyforge_project = "sidekiq-bus"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('queue-bus', '0.5.2')
+  s.add_dependency('sidekiq', ['>= 3.0.0', '< 4.0'])
+
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("timecop")
+  s.add_development_dependency("json_pure")
+end

data/spec/adapter/support.rb

@@ -0,0 +1,14 @@
+require 'sidekiq-bus'
+
+def reset_test_adapter
+  QueueBus.send(:reset)
+  QueueBus.adapter = QueueBus::Adapters::Sidekiq.new
+end
+
+def adapter_under_test_class
+  QueueBus::Adapters::Sidekiq
+end
+
+def adapter_under_test_symbol
+  :sidekiq
+end

data/spec/adapter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "adapter is set" do
+  it "should call it's enabled! method on init" do
+    QueueBus.send(:reset)
+    adapter_under_test_class.any_instance.should_receive(:enabled!)
+    instance = adapter_under_test_class.new
+    QueueBus.send(:reset)
+  end
+
+  it "should be defaulting to Data from spec_helper" do
+    QueueBus.adapter.is_a?(adapter_under_test_class).should == true
+  end
+end

data/spec/application_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+module QueueBus
+  describe Application do
+    describe ".all" do
+      it "should return empty array when none" do
+        Application.all.should == []
+      end
+      it "should return registered applications when there are some" do
+        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
+
+        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
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+        Application.new("myapp").subscribe(test_list(sub1, sub2))
+
+        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
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+        Application.new("myapp").subscribe(test_list(sub1))
+
+        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
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+        Application.new("myapp").subscribe(test_list(sub1, sub2, sub3))
+        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
+
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+
+        Application.new("myapp").subscribe(nil)
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+
+        Application.new("myapp").subscribe([])
+        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
+        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
+
+        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", "::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", "::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", "::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

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

@@ -0,0 +1,76 @@
+require 'spec_helper' 
+
+module QueueBus
+  describe Dispatch do
+    it "should not start with any applications" do
+      Dispatch.new("d").subscriptions.size.should == 0
+    end
+    
+    it "should register code to run and execute it" do
+      dispatch = Dispatch.new("d")
+      dispatch.subscribe("my_event") do |attrs|
+        Runner1.run(attrs)
+      end
+      sub = dispatch.subscriptions.key("my_event")
+      sub.send(:executor).is_a?(Proc).should == true
+
+      Runner.value.should == 0
+      dispatch.execute("my_event", {"bus_event_type" => "my_event", "ok" => true})
+      Runner1.value.should == 1
+      Runner1.attributes.should == {"bus_event_type" => "my_event", "ok" => true}
+      
+    end
+    
+    it "should not crash if not there" do
+      lambda {
+        Dispatch.new("d").execute("fdkjh", "bus_event_type" => "fdkjh")
+      }.should_not raise_error
+    end
+    
+    describe "Top Level" do
+      before(:each) do
+         QueueBus.dispatch("testit") do
+           subscribe "event1" do |attributes|
+             Runner2.run(attributes)
+           end
+
+           subscribe "event2" do
+             Runner2.run({})
+           end
+
+           high "event3" do
+             Runner2.run({})
+           end
+           
+           low /^patt.+ern/ do
+             Runner.run({})
+           end
+         end
+       end
+       
+      it "should register and run" do
+        Runner2.value.should == 0
+        QueueBus.dispatcher_execute("testit", "event2", "bus_event_type" => "event2")
+        Runner2.value.should == 1
+        QueueBus.dispatcher_execute("testit", "event1", "bus_event_type" => "event1")
+        Runner2.value.should == 2
+        QueueBus.dispatcher_execute("testit", "event1", "bus_event_type" => "event1")
+        Runner2.value.should == 3
+      end
+      
+      it "should return the subscriptions" do
+        dispatcher = QueueBus.dispatcher_by_key("testit")
+        subs = dispatcher.subscriptions.all
+        tuples = subs.collect{ |sub| [sub.key, sub.queue_name]}
+        tuples.should =~ [  ["event1", "testit_default"],
+                            ["event2", "testit_default"],
+                            ["event3", "testit_high"],
+                            [ "(?-mix:^patt.+ern)", "testit_low"]
+                         ]
+      end
+    
+    end
+  end
+
+end
+

data/spec/driver_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+module QueueBus
+  describe Driver do
+    before(:each) do
+      Application.new("app1").subscribe(test_list(test_sub("event1"), test_sub("event2"), test_sub("event3")))
+      Application.new("app2").subscribe(test_list(test_sub("event2","other"), test_sub("event4", "more")))
+      Application.new("app3").subscribe(test_list(test_sub("event[45]"), test_sub("event5"), test_sub("event6")))
+      Timecop.freeze
+    end
+    after(:each) do
+      Timecop.return
+    end
+
+    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", "::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", "::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", "::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", "::QueueBus::Rider"], ["app3", "event5", "default", "::QueueBus::Rider"]]
+      end
+    end
+
+    describe ".perform" do
+      let(:attributes) { {"x" => "y", "bus_class_proxy" => "ResqueBus::Driver"} }
+
+      before(:each) do
+        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"))
+        QueueBus.redis { |redis| redis.smembers("queues") }.should == []
+      end
+
+      it "should queue up the riders in redis" do
+        QueueBus.redis { |redis| redis.lpop("queue:app1_default") }.should be_nil
+        Driver.perform(attributes.merge("bus_event_type" => "event1"))
+        QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default"]
+
+        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"))
+        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"))
+        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
+
+        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