queue-bus 0.9.0 → 0.9.1

data/spec/publish_spec.rb

@@ -1,98 +1,98 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe "Publishing an event" do
+require 'spec_helper'
 
+describe 'Publishing an event' do
   before(:each) do
     Timecop.freeze
-    allow(QueueBus).to receive(:generate_uuid).and_return("idfhlkj")
+    allow(QueueBus).to receive(:generate_uuid).and_return('idfhlkj')
   end
   after(:each) do
     Timecop.return
   end
-  let(:bus_attrs) { {"bus_class_proxy"=>"QueueBus::Driver",
-                     "bus_published_at" => Time.now.to_i,
-                     "bus_id"=>"#{Time.now.to_i}-idfhlkj",
-                     "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
+  let(:bus_attrs) do
+    { 'bus_class_proxy' => 'QueueBus::Driver',
+      'bus_published_at' => Time.now.to_i,
+      'bus_id' => "#{Time.now.to_i}-idfhlkj",
+      'bus_app_hostname' => `hostname 2>&1`.strip.sub(/.local/, '') }
+  end
 
-  it "should add it to Redis" do
-    hash = {:one => 1, "two" => "here", "id" => 12 }
-    event_name = "event_name"
+  it 'should add it to Redis' do
+    hash = { :one => 1, 'two' => 'here', 'id' => 12 }
+    event_name = 'event_name'
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     hash = JSON.parse(val)
-    expect(hash["class"]).to eq("QueueBus::Worker")
-    expect(hash["args"].size).to eq(1)
-    expect(JSON.parse(hash["args"].first)).to eq({"bus_event_type" => event_name, "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs))
-
+    expect(hash['class']).to eq('QueueBus::Worker')
+    expect(hash['args'].size).to eq(1)
+    expect(JSON.parse(hash['args'].first)).to eq({ 'bus_event_type' => event_name, 'two' => 'here', 'one' => 1, 'id' => 12 }.merge(bus_attrs))
   end
 
-  it "should use the id if given" do
-    hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
-    event_name = "event_name"
+  it 'should use the id if given' do
+    hash = { :one => 1, 'two' => 'here', 'bus_id' => 'app-given' }
+    event_name = 'event_name'
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     hash = JSON.parse(val)
-    expect(hash["class"]).to eq("QueueBus::Worker")
-    expect(hash["args"].size).to eq(1)
-    expect(JSON.parse(hash["args"].first)).to eq({"bus_event_type" => event_name, "two"=>"here", "one"=>1}.merge(bus_attrs).merge("bus_id" => 'app-given'))
+    expect(hash['class']).to eq('QueueBus::Worker')
+    expect(hash['args'].size).to eq(1)
+    expect(JSON.parse(hash['args'].first)).to eq({ 'bus_event_type' => event_name, 'two' => 'here', 'one' => 1 }.merge(bus_attrs).merge('bus_id' => 'app-given'))
   end
 
-  it "should add metadata via callback" do
+  it 'should add metadata via callback' do
     myval = 0
     QueueBus.before_publish = lambda { |att|
-      att["mine"] = 4
+      att['mine'] = 4
       myval += 1
     }
 
-    hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
-    event_name = "event_name"
+    hash = { :one => 1, 'two' => 'here', 'bus_id' => 'app-given' }
+    event_name = 'event_name'
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
-
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     hash = JSON.parse(val)
-    att = JSON.parse(hash["args"].first)
-    expect(att["mine"]).to eq(4)
+    att = JSON.parse(hash['args'].first)
+    expect(att['mine']).to eq(4)
     expect(myval).to eq(1)
   end
 
-  it "should set the timezone and locale if available" do
+  it 'should set the timezone and locale if available' do
     expect(defined?(I18n)).to be_nil
     expect(Time.respond_to?(:zone)).to eq(false)
 
-    stub_const("I18n", Class.new)
-    allow(I18n).to receive(:locale).and_return("jp")
+    stub_const('I18n', Class.new)
+    allow(I18n).to receive(:locale).and_return('jp')
 
-    allow(Time).to receive(:zone).and_return(double('zone', :name => "EST"))
+    allow(Time).to receive(:zone).and_return(double('zone', name: 'EST'))
 
-    hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
-    event_name = "event_name"
+    hash = { :one => 1, 'two' => 'here', 'bus_id' => 'app-given' }
+    event_name = 'event_name'
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     hash = JSON.parse(val)
-    expect(hash["class"]).to eq("QueueBus::Worker")
-    att = JSON.parse(hash["args"].first)
-    expect(att["bus_locale"]).to eq("jp")
-    expect(att["bus_timezone"]).to eq("EST")
+    expect(hash['class']).to eq('QueueBus::Worker')
+    att = JSON.parse(hash['args'].first)
+    expect(att['bus_locale']).to eq('jp')
+    expect(att['bus_timezone']).to eq('EST')
   end
-
 end

data/spec/publisher_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Publisher do
-    it "should call publish as expected"
+    it 'should call publish as expected'
   end
 end

data/spec/rider_spec.rb

@@ -1,27 +1,29 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Rider do
-    it "should call execute" do
+    it 'should call execute' do
       expect(QueueBus).to receive(:dispatcher_execute)
-      Rider.perform("bus_rider_app_key" => "app", "bus_rider_sub_key" => "sub", "ok" => true, "bus_event_type" => "event_name")
+      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
-      QueueBus.dispatch("r1") do
-        subscribe "event_name" do |attributes|
+    it 'should change the value' do
+      QueueBus.dispatch('r1') do
+        subscribe 'event_name' do |attributes|
           Runner1.run(attributes)
         end
       end
       expect(Runner1.value).to eq(0)
-      Rider.perform("bus_locale" => "en", "bus_timezone" => "PST", "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")
+      Rider.perform('bus_locale' => 'en', 'bus_timezone' => 'PST', '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')
       expect(Runner1.value).to eq(1)
     end
 
-    it "should set the timezone and locale if present" do
-      QueueBus.dispatch("r1") do
-        subscribe "event_name" do |attributes|
+    it 'should set the timezone and locale if present' do
+      QueueBus.dispatch('r1') do
+        subscribe 'event_name' do |attributes|
           Runner1.run(attributes)
         end
       end
@@ -29,11 +31,11 @@ module QueueBus
       expect(defined?(I18n)).to be_nil
       expect(Time.respond_to?(:zone)).to eq(false)
 
-      stub_const("I18n", Class.new)
-      expect(I18n).to receive(:locale=).with("en")
-      expect(Time).to receive(:zone=).with("PST")
+      stub_const('I18n', Class.new)
+      expect(I18n).to receive(:locale=).with('en')
+      expect(Time).to receive(:zone=).with('PST')
 
-      Rider.perform("bus_locale" => "en", "bus_timezone" => "PST", "bus_rider_app_key" => "r1", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
+      Rider.perform('bus_locale' => 'en', 'bus_timezone' => 'PST', 'bus_rider_app_key' => 'r1', 'bus_rider_sub_key' => 'event_name', 'ok' => true, 'bus_event_type' => 'event_name')
     end
   end
 end

data/spec/spec_helper.rb

@@ -12,8 +12,8 @@ module QueueBus
       @value ||= 0
     end
 
-    def self.attributes
-      @attributes
+    class << self
+      attr_reader :attributes
     end
 
     def self.run(attrs)

data/spec/subscriber_spec.rb

@@ -1,270 +1,270 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-  describe QueueBus::Subscriber do
-    let(:attributes) { {"x" => "y"} }
-    let(:bus_attrs) { {"bus_driven_at" => Time.now.to_i} }
+require 'spec_helper'
 
-    before(:each) do
-      class SubscriberTest1
-        include QueueBus::Subscriber
-        @queue = "myqueue"
+describe QueueBus::Subscriber do
+  let(:attributes) { { 'x' => 'y' } }
+  let(:bus_attrs) { { 'bus_driven_at' => Time.now.to_i } }
 
-        application :my_thing
-        subscribe :thing_filter, :x => "y"
-        subscribe :event_sub
+  before(:each) do
+    class SubscriberTest1
+      include QueueBus::Subscriber
+      @queue = 'myqueue'
 
-        def event_sub(attributes)
-          QueueBus::Runner1.run(attributes)
-        end
+      application :my_thing
+      subscribe :thing_filter, x: 'y'
+      subscribe :event_sub
 
-        def thing_filter(attributes)
-          QueueBus::Runner2.run(attributes)
-        end
+      def event_sub(attributes)
+        QueueBus::Runner1.run(attributes)
       end
 
-      class SubscriberTest2
-        include QueueBus::Subscriber
-        application :test2
-        subscribe :test2,  "value" => :present
-        transform :make_an_int
+      def thing_filter(attributes)
+        QueueBus::Runner2.run(attributes)
+      end
+    end
 
-        def self.make_an_int(attributes)
-          attributes["value"].to_s.length
-        end
+    class SubscriberTest2
+      include QueueBus::Subscriber
+      application :test2
+      subscribe :test2, 'value' => :present
+      transform :make_an_int
 
-        def test2(int)
-          QueueBus::Runner1.run("transformed"=>int)
-        end
+      def self.make_an_int(attributes)
+        attributes['value'].to_s.length
       end
 
-      module SubModule
-        class SubscriberTest3
-          include QueueBus::Subscriber
+      def test2(int)
+        QueueBus::Runner1.run('transformed' => int)
+      end
+    end
 
-          subscribe_queue :sub_queue1, :test3, :bus_event_type => "the_event"
-          subscribe_queue :sub_queue2, :the_event
-          subscribe :other, :bus_event_type => "other_event"
+    module SubModule
+      class SubscriberTest3
+        include QueueBus::Subscriber
 
-          def test3(attributes)
-            QueueBus::Runner1.run(attributes)
-          end
+        subscribe_queue :sub_queue1, :test3, bus_event_type: 'the_event'
+        subscribe_queue :sub_queue2, :the_event
+        subscribe :other, bus_event_type: 'other_event'
 
-          def the_event(attributes)
-            QueueBus::Runner2.run(attributes)
-          end
+        def test3(attributes)
+          QueueBus::Runner1.run(attributes)
         end
 
-        class SubscriberTest4
-          include QueueBus::Subscriber
-
-          subscribe_queue :sub_queue1, :test4
+        def the_event(attributes)
+          QueueBus::Runner2.run(attributes)
         end
       end
 
-      Timecop.freeze
-      QueueBus::TaskManager.new(false).subscribe!
-    end
+      class SubscriberTest4
+        include QueueBus::Subscriber
 
-    after(:each) do
-      Timecop.return
+        subscribe_queue :sub_queue1, :test4
+      end
     end
 
-    it "should have the application" do
-      expect(SubscriberTest1.app_key).to eq("my_thing")
-      expect(SubModule::SubscriberTest3.app_key).to eq("sub_module")
-      expect(SubModule::SubscriberTest4.app_key).to eq("sub_module")
-    end
+    Timecop.freeze
+    QueueBus::TaskManager.new(false).subscribe!
+  end
 
-    it "should be able to transform the attributes" do
-      dispatcher = QueueBus.dispatcher_by_key("test2")
-      all = dispatcher.subscriptions.all
-      expect(all.size).to eq(1)
+  after(:each) do
+    Timecop.return
+  end
 
-      sub = all.first
-      expect(sub.queue_name).to eq("test2_default")
-      expect(sub.class_name).to eq("SubscriberTest2")
-      expect(sub.key).to eq("SubscriberTest2.test2")
-      expect(sub.matcher.filters).to eq({"value"=>"bus_special_value_present"})
+  it 'should have the application' do
+    expect(SubscriberTest1.app_key).to eq('my_thing')
+    expect(SubModule::SubscriberTest3.app_key).to eq('sub_module')
+    expect(SubModule::SubscriberTest4.app_key).to eq('sub_module')
+  end
 
-      QueueBus::Driver.perform(attributes.merge("bus_event_type" => "something2", "value"=>"nice"))
+  it 'should be able to transform the attributes' do
+    dispatcher = QueueBus.dispatcher_by_key('test2')
+    all = dispatcher.subscriptions.all
+    expect(all.size).to eq(1)
 
-      hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:test2_default") })
-      expect(hash["class"]).to eq("QueueBus::Worker")
-      expect(hash["args"].size).to eq(1)
-      expect(JSON.parse(hash["args"].first)).to 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))
+    sub = all.first
+    expect(sub.queue_name).to eq('test2_default')
+    expect(sub.class_name).to eq('SubscriberTest2')
+    expect(sub.key).to eq('SubscriberTest2.test2')
+    expect(sub.matcher.filters).to eq('value' => 'bus_special_value_present')
 
-      expect(QueueBus::Runner1.value).to eq(0)
-      expect(QueueBus::Runner2.value).to eq(0)
-      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
-      expect(QueueBus::Runner1.value).to eq(1)
-      expect(QueueBus::Runner2.value).to eq(0)
+    QueueBus::Driver.perform(attributes.merge('bus_event_type' => 'something2', 'value' => 'nice'))
 
-      expect(QueueBus::Runner1.attributes).to eq({"transformed" => 4})
+    hash = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:test2_default') })
+    expect(hash['class']).to eq('QueueBus::Worker')
+    expect(hash['args'].size).to eq(1)
+    expect(JSON.parse(hash['args'].first)).to 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))
 
+    expect(QueueBus::Runner1.value).to eq(0)
+    expect(QueueBus::Runner2.value).to eq(0)
+    QueueBus::Util.constantize(hash['class']).perform(*hash['args'])
+    expect(QueueBus::Runner1.value).to eq(1)
+    expect(QueueBus::Runner2.value).to eq(0)
 
-      QueueBus::Driver.perform(attributes.merge("bus_event_type" => "something2", "value"=>"12"))
+    expect(QueueBus::Runner1.attributes).to eq('transformed' => 4)
 
-      hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:test2_default") })
-      expect(hash["class"]).to eq("QueueBus::Worker")
-      expect(hash["args"].size).to eq(1)
-      expect(JSON.parse(hash["args"].first)).to 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"=>"12", "x"=>"y"}.merge(bus_attrs))
+    QueueBus::Driver.perform(attributes.merge('bus_event_type' => 'something2', 'value' => '12'))
 
-      expect(QueueBus::Runner1.value).to eq(1)
-      expect(QueueBus::Runner2.value).to eq(0)
-      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
-      expect(QueueBus::Runner1.value).to eq(2)
-      expect(QueueBus::Runner2.value).to eq(0)
+    hash = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:test2_default') })
+    expect(hash['class']).to eq('QueueBus::Worker')
+    expect(hash['args'].size).to eq(1)
+    expect(JSON.parse(hash['args'].first)).to 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' => '12', 'x' => 'y' }.merge(bus_attrs))
 
-      expect(QueueBus::Runner1.attributes).to eq({"transformed" => 2})
-    end
+    expect(QueueBus::Runner1.value).to eq(1)
+    expect(QueueBus::Runner2.value).to eq(0)
+    QueueBus::Util.constantize(hash['class']).perform(*hash['args'])
+    expect(QueueBus::Runner1.value).to eq(2)
+    expect(QueueBus::Runner2.value).to eq(0)
 
+    expect(QueueBus::Runner1.attributes).to eq('transformed' => 2)
+  end
+
+  it 'should put in a different queue' do
+    dispatcher = QueueBus.dispatcher_by_key('sub_module')
+    all = dispatcher.subscriptions.all
+    expect(all.size).to eq(4)
+
+    sub = all.select { |s| s.key == 'SubModule::SubscriberTest3.test3' }.first
+    expect(sub.queue_name).to eq('sub_queue1')
+    expect(sub.class_name).to eq('SubModule::SubscriberTest3')
+    expect(sub.key).to eq('SubModule::SubscriberTest3.test3')
+    expect(sub.matcher.filters).to eq('bus_event_type' => 'the_event')
+
+    sub = all.select { |s| s.key == 'SubModule::SubscriberTest3.the_event' }.first
+    expect(sub.queue_name).to eq('sub_queue2')
+    expect(sub.class_name).to eq('SubModule::SubscriberTest3')
+    expect(sub.key).to eq('SubModule::SubscriberTest3.the_event')
+    expect(sub.matcher.filters).to eq('bus_event_type' => 'the_event')
+
+    sub = all.select { |s| s.key == 'SubModule::SubscriberTest3.other' }.first
+    expect(sub.queue_name).to eq('sub_module_default')
+    expect(sub.class_name).to eq('SubModule::SubscriberTest3')
+    expect(sub.key).to eq('SubModule::SubscriberTest3.other')
+    expect(sub.matcher.filters).to eq('bus_event_type' => 'other_event')
+
+    sub = all.select { |s| s.key == 'SubModule::SubscriberTest4.test4' }.first
+    expect(sub.queue_name).to eq('sub_queue1')
+    expect(sub.class_name).to eq('SubModule::SubscriberTest4')
+    expect(sub.key).to eq('SubModule::SubscriberTest4.test4')
+    expect(sub.matcher.filters).to eq('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') })
+    expect(hash['class']).to eq('QueueBus::Worker')
+    expect(hash['args'].size).to eq(1)
+    expect(JSON.parse(hash['args'].first)).to eq({ '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))
+
+    expect(QueueBus::Runner1.value).to eq(0)
+    expect(QueueBus::Runner2.value).to eq(0)
+    QueueBus::Util.constantize(hash['class']).perform(*hash['args'])
+    expect(QueueBus::Runner1.value).to eq(1)
+    expect(QueueBus::Runner2.value).to eq(0)
+
+    hash = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:sub_queue2') })
+    expect(hash['class']).to eq('QueueBus::Worker')
+    expect(hash['args'].size).to eq(1)
+    expect(JSON.parse(hash['args'].first)).to eq({ '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))
+
+    expect(QueueBus::Runner1.value).to eq(1)
+    expect(QueueBus::Runner2.value).to eq(0)
+    QueueBus::Util.constantize(hash['class']).perform(*hash['args'])
+    expect(QueueBus::Runner1.value).to eq(1)
+    expect(QueueBus::Runner2.value).to eq(1)
+  end
 
-    it "should put in a different queue" do
-      dispatcher = QueueBus.dispatcher_by_key("sub_module")
-      all = dispatcher.subscriptions.all
-      expect(all.size).to eq(4)
-
-      sub = all.select{ |s| s.key == "SubModule::SubscriberTest3.test3"}.first
-      expect(sub.queue_name).to eq("sub_queue1")
-      expect(sub.class_name).to eq("SubModule::SubscriberTest3")
-      expect(sub.key).to eq("SubModule::SubscriberTest3.test3")
-      expect(sub.matcher.filters).to eq({"bus_event_type"=>"the_event"})
-
-      sub = all.select{ |s| s.key == "SubModule::SubscriberTest3.the_event"}.first
-      expect(sub.queue_name).to eq("sub_queue2")
-      expect(sub.class_name).to eq("SubModule::SubscriberTest3")
-      expect(sub.key).to eq("SubModule::SubscriberTest3.the_event")
-      expect(sub.matcher.filters).to eq({"bus_event_type"=>"the_event"})
-
-      sub = all.select{ |s| s.key == "SubModule::SubscriberTest3.other"}.first
-      expect(sub.queue_name).to eq("sub_module_default")
-      expect(sub.class_name).to eq("SubModule::SubscriberTest3")
-      expect(sub.key).to eq("SubModule::SubscriberTest3.other")
-      expect(sub.matcher.filters).to eq({"bus_event_type"=>"other_event"})
-
-      sub = all.select{ |s| s.key == "SubModule::SubscriberTest4.test4"}.first
-      expect(sub.queue_name).to eq("sub_queue1")
-      expect(sub.class_name).to eq("SubModule::SubscriberTest4")
-      expect(sub.key).to eq("SubModule::SubscriberTest4.test4")
-      expect(sub.matcher.filters).to eq({"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") })
-      expect(hash["class"]).to eq("QueueBus::Worker")
-      expect(hash["args"].size).to eq(1)
-      expect(JSON.parse(hash["args"].first)).to eq({"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))
-
-      expect(QueueBus::Runner1.value).to eq(0)
-      expect(QueueBus::Runner2.value).to eq(0)
-      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
-      expect(QueueBus::Runner1.value).to eq(1)
-      expect(QueueBus::Runner2.value).to eq(0)
-
-      hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:sub_queue2") })
-      expect(hash["class"]).to eq("QueueBus::Worker")
-      expect(hash["args"].size).to eq(1)
-      expect(JSON.parse(hash["args"].first)).to eq({"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))
-
-      expect(QueueBus::Runner1.value).to eq(1)
-      expect(QueueBus::Runner2.value).to eq(0)
-      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
-      expect(QueueBus::Runner1.value).to eq(1)
-      expect(QueueBus::Runner2.value).to eq(1)
+  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
+    expect(sub.queue_name).to eq('myqueue')
+    expect(sub.class_name).to eq('SubscriberTest1')
+    expect(sub.key).to eq('SubscriberTest1.event_sub')
+    expect(sub.matcher.filters).to eq('bus_event_type' => 'event_sub')
+
+    sub = all.select { |s| s.key == 'SubscriberTest1.thing_filter' }.first
+    expect(sub.queue_name).to eq('myqueue')
+    expect(sub.class_name).to eq('SubscriberTest1')
+    expect(sub.key).to eq('SubscriberTest1.thing_filter')
+    expect(sub.matcher.filters).to eq('x' => 'y')
+
+    QueueBus::Driver.perform(attributes.merge('bus_event_type' => 'event_sub'))
+    expect(QueueBus.redis { |redis| redis.smembers('queues') }).to match_array(['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
 
-    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
-      expect(sub.queue_name).to eq("myqueue")
-      expect(sub.class_name).to eq("SubscriberTest1")
-      expect(sub.key).to eq("SubscriberTest1.event_sub")
-      expect(sub.matcher.filters).to eq({"bus_event_type"=>"event_sub"})
-
-      sub = all.select{ |s| s.key == "SubscriberTest1.thing_filter"}.first
-      expect(sub.queue_name).to eq("myqueue")
-      expect(sub.class_name).to eq("SubscriberTest1")
-      expect(sub.key).to eq("SubscriberTest1.thing_filter")
-      expect(sub.matcher.filters).to eq({"x"=>"y"})
-
-      QueueBus::Driver.perform(attributes.merge("bus_event_type" => "event_sub"))
-      expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["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
+    expect(hash1['class']).to eq('QueueBus::Worker')
+    expect(JSON.parse(hash1['args'].first)).to 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))
+
+    expect(QueueBus::Runner1.value).to eq(0)
+    expect(QueueBus::Runner2.value).to eq(0)
+    QueueBus::Util.constantize(hash1['class']).perform(*hash1['args'])
+    expect(QueueBus::Runner1.value).to eq(0)
+    expect(QueueBus::Runner2.value).to eq(1)
+
+    expect(hash2['class']).to eq('QueueBus::Worker')
+    expect(hash2['args'].size).to eq(1)
+    expect(JSON.parse(hash2['args'].first)).to eq({ '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))
+
+    expect(QueueBus::Runner1.value).to eq(0)
+    expect(QueueBus::Runner2.value).to eq(1)
+    QueueBus::Util.constantize(hash2['class']).perform(*hash2['args'])
+    expect(QueueBus::Runner1.value).to eq(1)
+    expect(QueueBus::Runner2.value).to eq(1)
+
+    QueueBus::Driver.perform(attributes.merge('bus_event_type' => 'event_sub_other'))
+    expect(QueueBus.redis { |redis| redis.smembers('queues') }).to match_array(['myqueue'])
+
+    hash = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:myqueue') })
+    expect(hash['class']).to eq('QueueBus::Worker')
+    expect(hash['args'].size).to eq(1)
+    expect(JSON.parse(hash['args'].first)).to 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_other', 'x' => 'y' }.merge(bus_attrs))
+
+    expect(QueueBus::Runner1.value).to eq(1)
+    expect(QueueBus::Runner2.value).to eq(1)
+    QueueBus::Util.constantize(hash['class']).perform(*hash['args'])
+    expect(QueueBus::Runner1.value).to eq(1)
+    expect(QueueBus::Runner2.value).to eq(2)
+
+    QueueBus::Driver.perform({ 'x' => 'z' }.merge('bus_event_type' => 'event_sub_other'))
+    expect(QueueBus.redis { |redis| redis.smembers('queues') }).to match_array(['myqueue'])
+
+    expect(QueueBus.redis { |redis| redis.lpop('queue:myqueue') }).to be_nil
+  end
 
-      expect(hash1["class"]).to eq("QueueBus::Worker")
-      expect(JSON.parse(hash1["args"].first)).to 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))
-
-      expect(QueueBus::Runner1.value).to eq(0)
-      expect(QueueBus::Runner2.value).to eq(0)
-      QueueBus::Util.constantize(hash1["class"]).perform(*hash1["args"])
-      expect(QueueBus::Runner1.value).to eq(0)
-      expect(QueueBus::Runner2.value).to eq(1)
-
-      expect(hash2["class"]).to eq("QueueBus::Worker")
-      expect(hash2["args"].size).to eq(1)
-      expect(JSON.parse(hash2["args"].first)).to eq({"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))
-
-      expect(QueueBus::Runner1.value).to eq(0)
-      expect(QueueBus::Runner2.value).to eq(1)
-      QueueBus::Util.constantize(hash2["class"]).perform(*hash2["args"])
-      expect(QueueBus::Runner1.value).to eq(1)
-      expect(QueueBus::Runner2.value).to eq(1)
-
-      QueueBus::Driver.perform(attributes.merge("bus_event_type" => "event_sub_other"))
-      expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["myqueue"])
-
-      hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:myqueue") })
-      expect(hash["class"]).to eq("QueueBus::Worker")
-      expect(hash["args"].size).to eq(1)
-      expect(JSON.parse(hash["args"].first)).to 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_other", "x" => "y"}.merge(bus_attrs))
-
-      expect(QueueBus::Runner1.value).to eq(1)
-      expect(QueueBus::Runner2.value).to eq(1)
-      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
-      expect(QueueBus::Runner1.value).to eq(1)
-      expect(QueueBus::Runner2.value).to eq(2)
-
-      QueueBus::Driver.perform({"x"=>"z"}.merge("bus_event_type" => "event_sub_other"))
-      expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["myqueue"])
-
-      expect(QueueBus.redis { |redis| redis.lpop("queue:myqueue") }).to be_nil
+  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
+      expect_any_instance_of(SubscriberTest1).to receive(:event_sub)
+      SubscriberTest1.perform(attributes)
     end
+    it 'should set the timezone and locale if present' do
+      expect(defined?(I18n)).to be_nil
+      expect(Time.respond_to?(:zone)).to eq(false)
 
-    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
-        expect_any_instance_of(SubscriberTest1).to receive(:event_sub)
-        SubscriberTest1.perform(attributes)
-      end
-      it "should set the timezone and locale if present" do
-        expect(defined?(I18n)).to be_nil
-        expect(Time.respond_to?(:zone)).to eq(false)
-
-        stub_const("I18n", Class.new)
-        expect(I18n).to receive(:locale=).with("en")
-        expect(Time).to receive(:zone=).with("PST")
+      stub_const('I18n', Class.new)
+      expect(I18n).to receive(:locale=).with('en')
+      expect(Time).to receive(:zone=).with('PST')
 
-        expect_any_instance_of(SubscriberTest1).to receive(:event_sub)
-        SubscriberTest1.perform(attributes)
-      end
+      expect_any_instance_of(SubscriberTest1).to receive(:event_sub)
+      SubscriberTest1.perform(attributes)
     end
   end
+end