sidekiq-bus 0.5.2

data/spec/subscriber_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+  describe QueueBus::Subscriber do
+    let(:attributes) { {"x" => "y"} }
+    let(:bus_attrs) { {"bus_driven_at" => Time.now.to_i} }
+
+    before(:each) do
+      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 = QueueBus.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"}
+
+      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 = 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"}
+
+      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 = 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"}
+
+      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
+        SubscriberTest1.any_instance.should_receive(:event_sub)
+        SubscriberTest1.perform(attributes)
+      end
+      it "should set the timezone and locale if present" do
+        defined?(I18n).should be_nil
+        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

data/spec/subscription_list_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module QueueBus
+  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 QueueBus
+  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

data/spec/worker_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module QueueBus
+  describe Worker do
+    it "should proxy to given class" do
+      hash = {"bus_class_proxy" => "QueueBus::Driver", "ok" => true}
+      QueueBus::Driver.should_receive(:perform).with(hash)
+      QueueBus::Worker.perform(JSON.generate(hash))
+    end
+
+    it "should use instance" do
+      hash = {"bus_class_proxy" => "QueueBus::Rider", "ok" => true}
+      QueueBus::Rider.should_receive(:perform).with(hash)
+      QueueBus::Worker.new.perform(JSON.generate(hash))
+    end
+
+    it "should not freak out if class not there anymore" do
+      hash = {"bus_class_proxy" => "QueueBus::BadClass", "ok" => true}
+      lambda {
+        QueueBus::Worker.perform(JSON.generate(hash))
+      }.should_not raise_error
+    end
+
+    it "should raise error if proxy raises error" do
+      hash = {"bus_class_proxy" => "QueueBus::Rider", "ok" => true}
+      QueueBus::Rider.should_receive(:perform).with(hash).and_raise("rider crash")
+      lambda {
+        QueueBus::Worker.perform(JSON.generate(hash))
+      }.should raise_error
+    end
+  end
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-bus
+version: !ruby/object:Gem::Version
+  version: 0.5.2
+platform: ruby
+authors:
+- Brian Leonard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: queue-bus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json_pure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple event bus on top of Resque. Publish and subscribe to events
+  as they occur through a queue.
+email:
+- brian@bleonard.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rbenv-version"
+- ".rspec"
+- Gemfile
+- MIT-LICENSE
+- README.mdown
+- Rakefile
+- lib/sidekiq-bus.rb
+- lib/sidekiq_bus/adapter.rb
+- lib/sidekiq_bus/tasks.rb
+- lib/sidekiq_bus/version.rb
+- sidekiq-bus.gemspec
+- spec/adapter/support.rb
+- spec/adapter_spec.rb
+- spec/application_spec.rb
+- spec/config_spec.rb
+- spec/dispatch_spec.rb
+- spec/driver_spec.rb
+- spec/heartbeat_spec.rb
+- spec/integration_spec.rb
+- spec/matcher_spec.rb
+- spec/publish_spec.rb
+- spec/publisher_spec.rb
+- spec/rider_spec.rb
+- spec/spec_helper.rb
+- spec/subscriber_spec.rb
+- spec/subscription_list_spec.rb
+- spec/subscription_spec.rb
+- spec/worker_spec.rb
+homepage: https://github.com/queue-bus/sidekiq-bus
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: sidekiq-bus
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A simple event bus on top of Resque
+test_files:
+- spec/adapter/support.rb
+- spec/adapter_spec.rb
+- spec/application_spec.rb
+- spec/config_spec.rb
+- spec/dispatch_spec.rb
+- spec/driver_spec.rb
+- spec/heartbeat_spec.rb
+- spec/integration_spec.rb
+- spec/matcher_spec.rb
+- spec/publish_spec.rb
+- spec/publisher_spec.rb
+- spec/rider_spec.rb
+- spec/spec_helper.rb
+- spec/subscriber_spec.rb
+- spec/subscription_list_spec.rb
+- spec/subscription_spec.rb
+- spec/worker_spec.rb
+has_rdoc: