queue-bus 0.7.0 → 0.10.0

data/lib/queue_bus/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module QueueBus
-  VERSION = "0.7.0"
+  VERSION = '0.10.0'
 end

data/lib/queue_bus/worker.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module QueueBus
   class Worker
-
     def self.perform(json)
       klass = nil
       attributes = ::QueueBus::Util.decode(json)
       begin
-        class_name = attributes["bus_class_proxy"]
+        class_name = attributes['bus_class_proxy']
         klass = ::QueueBus::Util.constantize(class_name)
       rescue NameError
         # not there anymore

data/queue-bus.gemspec

@@ -1,33 +1,34 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "queue_bus/version"
+# frozen_string_literal: true
+
+$:.push File.expand_path('lib', __dir__)
+require 'queue_bus/version'
 
 Gem::Specification.new do |s|
-  s.name        = "queue-bus"
+  s.name        = 'queue-bus'
   s.version     = QueueBus::VERSION
-  s.authors     = ["Brian Leonard"]
-  s.email       = ["brian@bleonard.com"]
-  s.homepage    = ""
-  s.summary     = %q{A simple event bus on top of background queues}
-  s.description = %q{A simple event bus on top of common background queues. Publish and subscribe to events as they occur using what you already have.}
+  s.authors     = ['Brian Leonard']
+  s.email       = ['brian@bleonard.com']
+  s.homepage    = ''
+  s.summary     = 'A simple event bus on top of background queues'
+  s.description = 'A simple event bus on top of common background queues. Publish and subscribe to events as they occur using what you already have.'
 
-  s.rubyforge_project = "queue-bus"
+  s.rubyforge_project = 'queue-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.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
 
-  s.add_dependency("multi_json")
-  s.add_dependency("redis")
+  s.add_dependency('multi_json')
+  s.add_dependency('redis')
 
   # if using resque
   # s.add_development_dependency('resque', ['>= 1.10.0', '< 2.0'])
   # s.add_development_dependency('resque-scheduler', '>= 2.0.1')
   # s.add_development_dependency('resque-retry')
 
-  s.add_development_dependency("rspec")
-  s.add_development_dependency("timecop")
-  s.add_development_dependency("json_pure")
-  s.add_development_dependency("rubocop")
+  s.add_development_dependency('json_pure')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('rubocop')
+  s.add_development_dependency('timecop')
 end

data/spec/adapter/publish_at_spec.rb

@@ -1,51 +1,54 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe "Publishing an event in the future" do
+require 'spec_helper'
 
+describe 'Publishing an event in the future' do
   before(:each) do
     Timecop.freeze(now)
-    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(:delayed_attrs) { {
-                     "bus_delayed_until" => future.to_i,
-                     "bus_id" => "#{now.to_i}-idfhlkj",
-                     "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
+  let(:delayed_attrs) do
+    {
+      'bus_delayed_until' => future.to_i,
+      'bus_id' => "#{now.to_i}-idfhlkj",
+      'bus_app_hostname' => `hostname 2>&1`.strip.sub(/.local/, '')
+    }
+  end
 
-  let(:bus_attrs) { delayed_attrs.merge({"bus_published_at" => worktime.to_i})}
-  let(:now)    { Time.parse("01/01/2013 5:00")}
+  let(:bus_attrs) { delayed_attrs.merge('bus_published_at' => worktime.to_i) }
+  let(:now)    { Time.parse('01/01/2013 5:00') }
   let(:future) { Time.at(now.to_i + 60) }
-  let(:worktime) {Time.at(future.to_i + 1)}
+  let(:worktime) { Time.at(future.to_i + 1) }
 
-  it "should add it to Redis then to the real queue" do
-    hash = {:one => 1, "two" => "here", "id" => 12 }
-    event_name = "event_name"
+  it 'should add it to Redis then to the real queue' do
+    hash = { :one => 1, 'two' => 'here', 'id' => 12 }
+    event_name = 'event_name'
     QueueBus.publish_at(future, event_name, hash)
 
-    schedule = QueueBus.redis { |redis| redis.zrange("delayed_queue_schedule", 0, 1) }
+    schedule = QueueBus.redis { |redis| redis.zrange('delayed_queue_schedule', 0, 1) }
     expect(schedule).to eq([future.to_i.to_s])
 
     val = QueueBus.redis { |redis| redis.lpop("delayed:#{future.to_i}") }
     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_class_proxy"=>"QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs))
-    expect(hash["queue"]).to eq("bus_incoming")
+    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' => 'QueueBus::Publisher', 'bus_event_type' => 'event_name', 'two' => 'here', 'one' => 1, 'id' => 12 }.merge(delayed_attrs))
+    expect(hash['queue']).to eq('bus_incoming')
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     expect(val).to eq(nil) # nothing really added
 
     Timecop.freeze(worktime)
-    QueueBus::Publisher.perform(JSON.parse(hash["args"].first))
+    QueueBus::Publisher.perform(JSON.parse(hash['args'].first))
 
-    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_class_proxy"=>"QueueBus::Driver", "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_class_proxy' => 'QueueBus::Driver', 'bus_event_type' => 'event_name', 'two' => 'here', 'one' => 1, 'id' => 12 }.merge(bus_attrs))
   end
-
 end

data/spec/adapter/support.rb

@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
 require 'redis'
 
 def reset_test_adapter
   QueueBus.send(:reset)
   QueueBus.adapter = :data
-  QueueBus.adapter.redis = Redis.new
+  QueueBus.adapter.redis = if ENV['REDIS_URL']
+                             Redis.new(url: ENV['REDIS_URL'])
+                           else
+                             Redis.new
+                           end
 end
 
 def adapter_under_test_class

data/spec/adapter_spec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe "adapter is set" do
+describe 'adapter is set' do
   it "should call it's enabled! method on init" do
     QueueBus.send(:reset)
     expect_any_instance_of(adapter_under_test_class).to receive(:enabled!)
@@ -8,7 +10,7 @@ describe "adapter is set" do
     QueueBus.send(:reset)
   end
 
-  it "should be defaulting to Data from spec_helper" do
+  it 'should be defaulting to Data from spec_helper' do
     expect(QueueBus.adapter.is_a?(adapter_under_test_class)).to eq(true)
   end
 end

data/spec/application_spec.rb

@@ -1,151 +1,193 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Application do
-    describe ".all" do
-      it "should return empty array when none" do
+    describe '.all' do
+      it 'should return empty array when none' do
         expect(Application.all).to eq([])
       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")))
+      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')))
 
-        expect(Application.all.collect(&:app_key)).to match_array(["one", "two", "three"])
+        expect(Application.all.collect(&:app_key)).to match_array(%w[one two three])
 
-        Application.new("two").unsubscribe
-        expect(Application.all.collect(&:app_key)).to match_array(["one", "three"])
+        Application.new('two').unsubscribe
+        expect(Application.all.collect(&:app_key)).to match_array(%w[one three])
       end
     end
 
-    describe ".new" do
-      it "should have a key" do
-        expect(Application.new("something").app_key).to eq("something")
+    describe '.new' do
+      it 'should have a key' do
+        expect(Application.new('something').app_key).to eq('something')
 
-        expect(Application.new("some thing").app_key).to eq("some_thing")
-        expect(Application.new("some-thing").app_key).to eq("some_thing")
-        expect(Application.new("some_thing").app_key).to eq("some_thing")
-        expect(Application.new("Some Thing").app_key).to eq("some_thing")
+        expect(Application.new('some thing').app_key).to eq('some_thing')
+        expect(Application.new('some-thing').app_key).to eq('some_thing')
+        expect(Application.new('some_thing').app_key).to eq('some_thing')
+        expect(Application.new('Some Thing').app_key).to eq('some_thing')
       end
 
-      it "should raise an error if not valid" do
-        expect {
-          Application.new("")
-        }.to raise_error(RuntimeError, "Invalid application name")
+      it 'should raise an error if not valid' do
+        expect do
+          Application.new('')
+        end.to raise_error(RuntimeError, 'Invalid application name')
 
-        expect {
+        expect do
           Application.new(nil)
-        }.to raise_error(RuntimeError, "Invalid application name")
+        end.to raise_error(RuntimeError, 'Invalid application name')
 
-        expect {
-          Application.new("/")
-        }.to raise_error(RuntimeError, "Invalid application name")
+        expect do
+          Application.new('/')
+        end.to raise_error(RuntimeError, 'Invalid application name')
       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")
+    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)
-        expect(val).to eq({"new_one" => {"queue_name" => "x", "bus_event_type" => "event_name"}, "old_one" => "oldqueue_name"})
+        expect(val).to eq('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
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
-        Application.new("myapp").subscribe(test_list(sub1, sub2))
-
-        expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({"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\"}}"})
-        expect(QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }).to match_array(["event_one", "event_two"])
-        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to match_array(["myapp"])
+    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
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
+        Application.new('myapp').subscribe(test_list(sub1, sub2))
+
+        expect(QueueBus.redis { |redis| redis.hgetall('bus_app:myapp') }).to eq('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"}}')
+        expect(QueueBus.redis { |redis| redis.hkeys('bus_app:myapp') }).to match_array(%w[event_one event_two])
+        expect(QueueBus.redis { |redis| redis.smembers('bus_apps') }).to match_array(['myapp'])
       end
-      it "should add string to redis" do
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
-        Application.new("myapp").subscribe(test_list(sub1))
+      it 'should add string to redis' do
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
+        Application.new('myapp').subscribe(test_list(sub1))
 
-        expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({"event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"})
-        expect(QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }).to match_array(["event_one"])
-        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to match_array(["myapp"])
+        expect(QueueBus.redis { |redis| redis.hgetall('bus_app:myapp') }).to eq('event_one' => '{"queue_name":"default","key":"event_one","class":"::QueueBus::Rider","matcher":{"bus_event_type":"event_one"}}')
+        expect(QueueBus.redis { |redis| redis.hkeys('bus_app:myapp') }).to match_array(['event_one'])
+        expect(QueueBus.redis { |redis| redis.smembers('bus_apps') }).to match_array(['myapp'])
       end
-      it "should multiple queues to redis" do
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
-        Application.new("myapp").subscribe(test_list(sub1, sub2, sub3))
-        expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({"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\"}}"})
-        expect(QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }).to match_array(["event_three", "event_two", "event_one"])
-        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to match_array(["myapp"])
+      it 'should multiple queues to redis' do
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
+        Application.new('myapp').subscribe(test_list(sub1, sub2, sub3))
+        expect(QueueBus.redis { |redis| redis.hgetall('bus_app:myapp') }).to eq('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"}}')
+        expect(QueueBus.redis { |redis| redis.hkeys('bus_app:myapp') }).to match_array(%w[event_three event_two event_one])
+        expect(QueueBus.redis { |redis| redis.smembers('bus_apps') }).to match_array(['myapp'])
       end
 
-      it "should do nothing if nil or empty" do
+      it 'should do nothing if nil or empty' do
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
 
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
+        Application.new('myapp').subscribe(nil)
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
 
-        Application.new("myapp").subscribe(nil)
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
-
-        Application.new("myapp").subscribe([])
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
+        Application.new('myapp').subscribe([])
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
       end
 
-      it "should call unsubscribe" do
-        app = Application.new("myapp")
+      it 'should call unsubscribe' do
+        app = Application.new('myapp')
         expect(app).to 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") }
+      context "when a queue is not specified" do
+        it "removes all subscriptions" do
+          myapp_list = SubscriptionList.new
+          other_list = SubscriptionList.new
+
+          subscription_1 = Subscription.new("myapp_default", "key1", "MyClass1", {"bus_event_type" => "event_one"})
+          subscription_2 = Subscription.new("myapp_default", "key2", "MyClass2", {"bus_event_type" => "event_two"})
+          subscription_3 = Subscription.new("myapp_other_queue", "key1", "MyClass1", {"bus_event_type" => "event_one"})
+
+          myapp_list.add(subscription_1)
+          myapp_list.add(subscription_2)
+          other_list.add(subscription_3)
+
+          Application.new("myapp").subscribe(myapp_list)
+          Application.new("other").subscribe(other_list)
+
+          expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({
+            "key1" => "{\"queue_name\":\"myapp_default\",\"key\":\"key1\",\"class\":\"MyClass1\",\"matcher\":{\"bus_event_type\":\"event_one\"}}",
+            "key2" => "{\"queue_name\":\"myapp_default\",\"key\":\"key2\",\"class\":\"MyClass2\",\"matcher\":{\"bus_event_type\":\"event_two\"}}"
+          })
+
+          Application.new("myapp").unsubscribe
+
+          expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to eq(["other"])
+          expect(QueueBus.redis { |redis| redis.hlen("bus_app:myapp") }).to eq(0)
+          expect(QueueBus.redis { |redis| redis.hlen("bus_app:other") }).to eq(1)
+        end
+      end
+
+      context "when a queue is specified" do
+        it "removes only that key" do
+          list = SubscriptionList.new
+
+          subscription_1 = Subscription.new("myapp_default", "key1", "MyClass1", {"bus_event_type" => "event_one"})
+          subscription_2 = Subscription.new("myapp_other_queue", "key2", "MyClass2", {"bus_event_type" => "event_two"})
+
+          list.add(subscription_1)
+          list.add(subscription_2)
+
+          Application.new("myapp").subscribe(list)
+
+          expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({
+            "key1" => "{\"queue_name\":\"myapp_default\",\"key\":\"key1\",\"class\":\"MyClass1\",\"matcher\":{\"bus_event_type\":\"event_one\"}}",
+            "key2" => "{\"queue_name\":\"myapp_other_queue\",\"key\":\"key2\",\"class\":\"MyClass2\",\"matcher\":{\"bus_event_type\":\"event_two\"}}"
+          })
 
-        Application.new("myapp").unsubscribe
+          Application.new("myapp").unsubscribe_queue("myapp_default")
 
-        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to eq(["other"])
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
+          expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to eq(["myapp"])
+          expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({"key2" => "{\"queue_name\":\"myapp_other_queue\",\"key\":\"key2\",\"class\":\"MyClass2\",\"matcher\":{\"bus_event_type\":\"event_two\"}}"})
+        end
       end
     end
 
-    describe "#subscription_matches" do
-      it "should return if it is there" do
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
+    describe '#subscription_matches' do
+      it 'should return if it is there' do
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'three').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
 
-        subs = test_list(test_sub("one_x"), test_sub("one_y"), test_sub("one"), test_sub("two"))
-        Application.new("myapp").subscribe(subs)
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
+        subs = test_list(test_sub('one_x'), test_sub('one_y'), test_sub('one'), test_sub('two'))
+        Application.new('myapp').subscribe(subs)
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'three').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
 
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"two").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "two", "default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one", "default", "::QueueBus::Rider"]])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'two').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', 'two', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'one').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['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)
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
+      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)
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'three').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
 
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one.+", "default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one", "default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one.+","default", "::QueueBus::Rider"], ["myapp", "one_.*", "default", "::QueueBus::Rider"]])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'onex').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', 'one.+', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'one').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', 'one', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'one_x').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['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)
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
+      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)
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'three').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
 
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"donex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one" ,"default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"], ["myapp", "(?-mix:one_.*)", "default", "::QueueBus::Rider"]])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'onex').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', '(?-mix:one.+)', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'donex').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', '(?-mix:one.+)', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'one').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', 'one', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'one_x').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', '(?-mix:one.+)', 'default', '::QueueBus::Rider'], ['myapp', '(?-mix:one_.*)', 'default', '::QueueBus::Rider']])
       end
     end
   end