sidekiq-bus 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a863bbad91a600acef85ae8edef094d7b62fef2c
-  data.tar.gz: b190d70f8670247b800141aaa3d7f56860e6f2f4
+  metadata.gz: 2c633c91c5b55a5e08ec80f73ee6a174df07d59c
+  data.tar.gz: '00095d6bcdc1407137cab9051990b91f359df304'
 SHA512:
-  metadata.gz: a5394ae7f51b10a9bd13b64d28aec02e9199b2f2773314d91330cee471769f51c3680974ae2c9056deeb68185ebc529156343e31089838ed8ea0e9c59d0f9736
-  data.tar.gz: 8c676a81ff6cf08a321712aa2fab208247fc88e453ba3eb576248932588e4cc528fc9d7c7779c60560bde0e972e17c257f277ad3401dad880a888ac97d12db36
+  metadata.gz: a4dcb3d6a379ceda40fe1da42c6cdb00662b85f37bbfcf9010ed7303883d8e44a9f43f9ab9c587793503ce4ade15a09f1c23cbdd6ec07ae5f4d85af0ce8ced04
+  data.tar.gz: 2631baff2bc6724686516f34cc04955fef78884228566f961b2f51dd069130bf67c65a562200299e833b241d8ed18c6e7a17636768bfd6310d318de1c8997c0f

data/CHANGELOG.md

@@ -6,6 +6,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### [0.8.2] - 2019-08-06
+
+### Fixed
+- Schedule now uses cron format to schedule heartbeat. The "every: 1min" format was causing multiple heartbeats to fire in the same minute if there were multiple sidekiq processes with the dynamic setting turned off (which is default).
+
 ### [0.8.1] - 2019-08-05
 
 ### Fixed

data/lib/sidekiq_bus/adapter.rb

@@ -57,7 +57,7 @@ module QueueBus
       def set_schedule(queue_name)
         ::Sidekiq.set_schedule(
           'sidekiqbus_heartbeat',
-          every: '1min',
+          cron: '0 * * * * *', # Runs every minute
           class: ::QueueBus::Worker.name,
           args: [
             ::QueueBus::Util.encode('bus_class_proxy' => ::QueueBus::Heartbeat.name)

data/lib/sidekiq_bus/middleware/retry.rb

@@ -1,18 +1,18 @@
+# frozen_string_literal: true
+
 module SidekiqBus
   module Middleware
     module Client
-     
       # ensure sidekiq will retry jobs even when they are enqueued via other adapters
       class Retry
-       def call(worker_class, job, queue, redis_pool)
-         if job['class'] == 'QueueBus::Worker'
-          job['retry'] = true unless job.has_key?('retry')
-          job['backtrace'] = true unless job.has_key?('backtrace')
-         end
-         yield
-       end
+        def call(_worker_class, job, _queue, _redis_pool)
+          if job['class'] == 'QueueBus::Worker'
+            job['retry'] = true unless job.key?('retry')
+            job['backtrace'] = true unless job.key?('backtrace')
+          end
+          yield
+        end
      end
-
    end
  end
-end
+end

data/lib/sidekiq_bus/tasks.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 # require 'sidekiq_bus/tasks'
 # will give you these tasks
 
-require "queue_bus/tasks"
+require 'queue_bus/tasks'
 
 namespace :queuebus do
-
   # Preload app files if this is Rails
   task :preload do
-    require "sidekiq"
+    require 'sidekiq'
   end
-
 end

data/lib/sidekiq_bus/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SidekiqBus
-  VERSION = "0.8.1"
+  VERSION = '0.8.2'
 end

data/spec/adapter/integration_spec.rb

@@ -1,15 +1,15 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
-if Sidekiq::VERSION < '4'
-  require 'celluloid'
-end
+require 'celluloid' if Sidekiq::VERSION < '4'
 require 'sidekiq/scheduled'
 
-describe "Sidekiq Integration" do
-  describe "Happy Path" do
+describe 'Sidekiq Integration' do
+  describe 'Happy Path' do
     before(:each) do
       Sidekiq::Testing.fake!
-      QueueBus.dispatch("r1") do
-        subscribe "event_name" do |attributes|
+      QueueBus.dispatch('r1') do
+        subscribe 'event_name' do |attributes|
           QueueBus::Runner1.run(attributes)
         end
       end
@@ -17,11 +17,11 @@ describe "Sidekiq Integration" do
       QueueBus::TaskManager.new(false).subscribe!
     end
 
-    it "should publish and receive" do
+    it 'should publish and receive' do
       Sidekiq::Testing.fake!
       expect(QueueBus::Runner1.value).to eq(0)
 
-      QueueBus.publish("event_name", "ok" => true)
+      QueueBus.publish('event_name', 'ok' => true)
       expect(QueueBus::Runner1.value).to eq(0)
 
       QueueBus::Worker.perform_one
@@ -33,58 +33,59 @@ describe "Sidekiq Integration" do
       expect(QueueBus::Runner1.value).to eq(1)
     end
 
-    it "should publish and receive" do
+    it 'should publish and receive' do
       Sidekiq::Testing.inline!
       expect(QueueBus::Runner1.value).to eq(0)
 
-      QueueBus.publish("event_name", "ok" => true)
+      QueueBus.publish('event_name', 'ok' => true)
       expect(QueueBus::Runner1.value).to eq(1)
     end
-
   end
 
-  describe "Delayed Publishing" do
+  describe 'Delayed Publishing' 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' =>  Socket.gethostname }
+    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" 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'
       QueueBus.publish_at(future, event_name, hash)
 
-      val = QueueBus.redis { |redis| redis.zrange("schedule", 0, 1) }.first
+      val = QueueBus.redis { |redis| redis.zrange('schedule', 0, 1) }.first
 
       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')
     end
 
-    it "should move it to the real queue when processing" do
-      hash = {:one => 1, "two" => "here", "id" => 12 }
-      event_name = "event_name"
+    it 'should move it to the real queue when processing' 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_at(future, event_name, hash)
 
-      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
 
       if Sidekiq::VERSION < '4'
@@ -93,7 +94,7 @@ describe "Sidekiq Integration" do
         Sidekiq::Scheduled::Poller.new.enqueue
       end
 
-      val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+      val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
       expect(val).to eq(nil) # nothing added yet
 
       # process scheduler in future
@@ -104,21 +105,20 @@ describe "Sidekiq Integration" do
           Sidekiq::Scheduled::Poller.new.enqueue
         end
 
-        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::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_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::Publisher', 'bus_event_type' => 'event_name', 'two' => 'here', 'one' => 1, 'id' => 12 }.merge(delayed_attrs))
 
-       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") }
-       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))
+        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))
       end
     end
-
   end
 end

data/spec/adapter/support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sidekiq-bus'
 
 def reset_test_adapter

data/spec/adapter_spec.rb

@@ -40,7 +40,8 @@ describe 'adapter is set' do
 
     shared_examples 'a scheduled heartbeat' do
       it 'has the schedule for every minute' do
-        expect(Sidekiq.get_schedule('sidekiqbus_heartbeat')['every']).to eq '1min'
+        expect(Sidekiq.get_schedule('sidekiqbus_heartbeat')['every']).to be_nil
+        expect(Sidekiq.get_schedule('sidekiqbus_heartbeat')['cron']).to eq '0 * * * * *'
       end
 
       it 'has scheduled the queue bus worker' do

data/spec/application_spec.rb

@@ -1,151 +1,151 @@
+# 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("Invalid application name")
+      it 'should raise an error if not valid' do
+        expect do
+          Application.new('')
+        end.to raise_error('Invalid application name')
 
-        expect {
+        expect do
           Application.new(nil)
-        }.to raise_error("Invalid application name")
+        end.to raise_error('Invalid application name')
 
-        expect {
-          Application.new("/")
-        }.to raise_error("Invalid application name")
+        expect do
+          Application.new('/')
+        end.to raise_error('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
-
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
+      it 'should do nothing if nil or empty' do
+        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") }
+    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
+        Application.new('myapp').unsubscribe
 
-        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(['other'])
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
       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