queue-bus 0.9.0 → 0.9.1

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,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(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
-
-        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

data/spec/dispatch_spec.rb

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