queue-bus 0.8.0 → 0.11.0

data/spec/config_spec.rb

@@ -53,6 +53,7 @@ describe 'QueueBus config' do
     end
 
     it 'resets to the original local mode after the block' do
+      expect(QueueBus.local_mode).to eq nil
       QueueBus.with_local_mode(:suppress) do
         expect(QueueBus.local_mode).to eq :suppress
       end
@@ -60,6 +61,41 @@ describe 'QueueBus config' do
     end
   end
 
+  describe '#in_context' do
+    it 'sets the context on the thread' do
+      QueueBus.in_context(:batch_processing) do
+        expect(QueueBus.context).to eq(:batch_processing)
+        Thread.new { expect(QueueBus.context).to eq nil }.join
+      end
+    end
+
+    it 'supports nesting' do
+      QueueBus.in_context(:batch_processing) do
+        expect(QueueBus.context).to eq :batch_processing
+        QueueBus.in_context(:processing) do
+          expect(QueueBus.context).to eq :processing
+        end
+        expect(QueueBus.context).to eq :batch_processing
+      end
+    end
+
+    it 'respects an override of nil' do
+      QueueBus.context = :batch_processing
+      QueueBus.in_context(nil) do
+        expect(QueueBus.context).to eq nil
+      end
+      QueueBus.context = :batch_processing
+    end
+
+    it 'resets to the original context after the block' do
+      expect(QueueBus.context).to eq nil
+      QueueBus.in_context(:batch_processing) do
+        expect(QueueBus.context).to eq :batch_processing
+      end
+      expect(QueueBus.context).to eq nil
+    end
+  end
+
   it 'sets the hostname' do
     expect(QueueBus.hostname).not_to eq(nil)
     QueueBus.hostname = 'whatever'

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
-

data/spec/driver_spec.rb

@@ -1,92 +1,94 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Driver do
     before(:each) do
-      Application.new("app1").subscribe(test_list(test_sub("event1"), test_sub("event2"), test_sub("event3")))
-      Application.new("app2").subscribe(test_list(test_sub("event2","other"), test_sub("event4", "more")))
-      Application.new("app3").subscribe(test_list(test_sub("event[45]"), test_sub("event5"), test_sub("event6")))
+      Application.new('app1').subscribe(test_list(test_sub('event1'), test_sub('event2'), test_sub('event3')))
+      Application.new('app2').subscribe(test_list(test_sub('event2', 'other'), test_sub('event4', 'more')))
+      Application.new('app3').subscribe(test_list(test_sub('event[45]'), test_sub('event5'), test_sub('event6')))
       Timecop.freeze
     end
     after(:each) do
       Timecop.return
     end
 
-    let(:bus_attrs) { {"bus_driven_at" => Time.now.to_i, "bus_rider_class_name"=>"::QueueBus::Rider", "bus_class_proxy" => "::QueueBus::Rider"} }
+    let(:bus_attrs) { { 'bus_driven_at' => Time.now.to_i, 'bus_rider_class_name' => '::QueueBus::Rider', 'bus_class_proxy' => '::QueueBus::Rider' } }
 
-    describe ".subscription_matches" do
-      it "return empty array when none" do
-        expect(Driver.subscription_matches("bus_event_type" => "else").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
-        expect(Driver.subscription_matches("bus_event_type" => "event").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
+    describe '.subscription_matches' do
+      it 'return empty array when none' do
+        expect(Driver.subscription_matches('bus_event_type' => 'else').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
+        expect(Driver.subscription_matches('bus_event_type' => 'event').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
       end
-      it "should return a match" do
-        expect(Driver.subscription_matches("bus_event_type" => "event1").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["app1", "event1", "default", "::QueueBus::Rider"]])
-        expect(Driver.subscription_matches("bus_event_type" => "event6").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["app3", "event6", "default", "::QueueBus::Rider"]])
+      it 'should return a match' do
+        expect(Driver.subscription_matches('bus_event_type' => 'event1').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['app1', 'event1', 'default', '::QueueBus::Rider']])
+        expect(Driver.subscription_matches('bus_event_type' => 'event6').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['app3', 'event6', 'default', '::QueueBus::Rider']])
       end
-      it "should match multiple apps" do
-        expect(Driver.subscription_matches("bus_event_type" => "event2").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["app1", "event2", "default", "::QueueBus::Rider"], ["app2", "event2", "other", "::QueueBus::Rider"]])
+      it 'should match multiple apps' do
+        expect(Driver.subscription_matches('bus_event_type' => 'event2').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['app1', 'event2', 'default', '::QueueBus::Rider'], ['app2', 'event2', 'other', '::QueueBus::Rider']])
       end
-      it "should match multiple apps with patterns" do
-        expect(Driver.subscription_matches("bus_event_type" => "event4").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["app3", "event[45]", "default", "::QueueBus::Rider"], ["app2", "event4", "more", "::QueueBus::Rider"]])
+      it 'should match multiple apps with patterns' do
+        expect(Driver.subscription_matches('bus_event_type' => 'event4').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['app3', 'event[45]', 'default', '::QueueBus::Rider'], ['app2', 'event4', 'more', '::QueueBus::Rider']])
       end
-      it "should match multiple events in same app" do
-        expect(Driver.subscription_matches("bus_event_type" => "event5").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["app3", "event[45]", "default", "::QueueBus::Rider"], ["app3", "event5", "default", "::QueueBus::Rider"]])
+      it 'should match multiple events in same app' do
+        expect(Driver.subscription_matches('bus_event_type' => 'event5').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['app3', 'event[45]', 'default', '::QueueBus::Rider'], ['app3', 'event5', 'default', '::QueueBus::Rider']])
       end
     end
 
-    describe ".perform" do
-      let(:attributes) { {"x" => "y", "bus_class_proxy" => "ResqueBus::Driver"} }
+    describe '.perform' do
+      let(:attributes) { { 'x' => 'y', 'bus_class_proxy' => 'ResqueBus::Driver' } }
 
       before(:each) do
-        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to eq([])
-        expect(QueueBus.redis { |redis| redis.lpop("queue:app1_default") }).to be_nil
-        expect(QueueBus.redis { |redis| redis.lpop("queue:app2_default") }).to be_nil
-        expect(QueueBus.redis { |redis| redis.lpop("queue:app3_default") }).to be_nil
+        expect(QueueBus.redis { |redis| redis.smembers('queues') }).to eq([])
+        expect(QueueBus.redis { |redis| redis.lpop('queue:app1_default') }).to be_nil
+        expect(QueueBus.redis { |redis| redis.lpop('queue:app2_default') }).to be_nil
+        expect(QueueBus.redis { |redis| redis.lpop('queue:app3_default') }).to be_nil
       end
 
-      it "should do nothing when empty" do
-        Driver.perform(attributes.merge("bus_event_type" => "else"))
-        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to eq([])
+      it 'should do nothing when empty' do
+        Driver.perform(attributes.merge('bus_event_type' => 'else'))
+        expect(QueueBus.redis { |redis| redis.smembers('queues') }).to eq([])
       end
 
-      it "should queue up the riders in redis" do
-        expect(QueueBus.redis { |redis| redis.lpop("queue:app1_default") }).to be_nil
-        Driver.perform(attributes.merge("bus_event_type" => "event1"))
-        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["default"])
+      it 'should queue up the riders in redis' do
+        expect(QueueBus.redis { |redis| redis.lpop('queue:app1_default') }).to be_nil
+        Driver.perform(attributes.merge('bus_event_type' => 'event1'))
+        expect(QueueBus.redis { |redis| redis.smembers('queues') }).to match_array(['default'])
 
-        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
-        expect(hash["class"]).to eq("QueueBus::Worker")
-        expect(hash["args"].size).to eq(1)
-        expect(JSON.parse(hash["args"].first)).to eq({"bus_rider_app_key"=>"app1", "x" => "y", "bus_event_type" => "event1", "bus_rider_sub_key"=>"event1", "bus_rider_queue" => "default"}.merge(bus_attrs))
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:default') })
+        expect(hash['class']).to eq('QueueBus::Worker')
+        expect(hash['args'].size).to eq(1)
+        expect(JSON.parse(hash['args'].first)).to eq({ 'bus_rider_app_key' => 'app1', 'x' => 'y', 'bus_event_type' => 'event1', 'bus_rider_sub_key' => 'event1', 'bus_rider_queue' => 'default' }.merge(bus_attrs))
       end
 
-      it "should queue up to multiple" do
-        Driver.perform(attributes.merge("bus_event_type" => "event4"))
-        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["default", "more"])
+      it 'should queue up to multiple' do
+        Driver.perform(attributes.merge('bus_event_type' => 'event4'))
+        expect(QueueBus.redis { |redis| redis.smembers('queues') }).to match_array(%w[default more])
 
-        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:more") })
-        expect(hash["class"]).to eq("QueueBus::Worker")
-        expect(hash["args"].size).to eq(1)
-        expect(JSON.parse(hash["args"].first)).to eq({"bus_rider_app_key"=>"app2", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event4", "bus_rider_queue" => "more"}.merge(bus_attrs))
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:more') })
+        expect(hash['class']).to eq('QueueBus::Worker')
+        expect(hash['args'].size).to eq(1)
+        expect(JSON.parse(hash['args'].first)).to eq({ 'bus_rider_app_key' => 'app2', 'x' => 'y', 'bus_event_type' => 'event4', 'bus_rider_sub_key' => 'event4', 'bus_rider_queue' => 'more' }.merge(bus_attrs))
 
-        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
-        expect(hash["class"]).to eq("QueueBus::Worker")
-        expect(hash["args"].size).to eq(1)
-        expect(JSON.parse(hash["args"].first)).to eq({"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs))
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:default') })
+        expect(hash['class']).to eq('QueueBus::Worker')
+        expect(hash['args'].size).to eq(1)
+        expect(JSON.parse(hash['args'].first)).to eq({ 'bus_rider_app_key' => 'app3', 'x' => 'y', 'bus_event_type' => 'event4', 'bus_rider_sub_key' => 'event[45]', 'bus_rider_queue' => 'default' }.merge(bus_attrs))
       end
 
-      it "should queue up to the same" do
-        Driver.perform(attributes.merge("bus_event_type" => "event5"))
-        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["default"])
+      it 'should queue up to the same' do
+        Driver.perform(attributes.merge('bus_event_type' => 'event5'))
+        expect(QueueBus.redis { |redis| redis.smembers('queues') }).to match_array(['default'])
 
-        expect(QueueBus.redis { |redis| redis.llen("queue:default") }).to eq(2)
+        expect(QueueBus.redis { |redis| redis.llen('queue:default') }).to eq(2)
 
-        pop1 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
-        pop2 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
+        pop1 = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:default') })
+        pop2 = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:default') })
 
-        pargs1 = JSON.parse(pop1["args"].first)
-        pargs2 = JSON.parse(pop2["args"].first)
-        if pargs1["bus_rider_sub_key"] == "event5"
+        pargs1 = JSON.parse(pop1['args'].first)
+        pargs2 = JSON.parse(pop2['args'].first)
+        if pargs1['bus_rider_sub_key'] == 'event5'
           hash1 = pop1
           hash2 = pop2
           args1 = pargs1
@@ -98,11 +100,11 @@ module QueueBus
           args2 = pargs1
         end
 
-        expect(hash1["class"]).to eq("QueueBus::Worker")
-        expect(args1).to eq({"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event5", "bus_rider_queue" => "default"}.merge(bus_attrs))
+        expect(hash1['class']).to eq('QueueBus::Worker')
+        expect(args1).to eq({ 'bus_rider_app_key' => 'app3', 'x' => 'y', 'bus_event_type' => 'event5', 'bus_rider_sub_key' => 'event5', 'bus_rider_queue' => 'default' }.merge(bus_attrs))
 
-        expect(hash2["class"]).to eq("QueueBus::Worker")
-        expect(args2).to eq({"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs))
+        expect(hash2['class']).to eq('QueueBus::Worker')
+        expect(args2).to eq({ 'bus_rider_app_key' => 'app3', 'x' => 'y', 'bus_event_type' => 'event5', 'bus_rider_sub_key' => 'event[45]', 'bus_rider_queue' => 'default' }.merge(bus_attrs))
       end
     end
   end

data/spec/heartbeat_spec.rb

@@ -1,42 +1,44 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Heartbeat do
     def now_attributes
       {
-        "epoch_seconds" => (Time.now.to_i / 60) * 60, # rounded
-        "epoch_minutes" => Time.now.to_i / 60,
-        "epoch_hours"   => Time.now.to_i / (60*60),
-        "epoch_days"    => Time.now.to_i / (60*60*24),
-        "minute" => Time.now.min,
-        "hour"   => Time.now.hour,
-        "day"    => Time.now.day,
-        "month"  => Time.now.month,
-        "year"   => Time.now.year,
-        "yday"   => Time.now.yday,
-        "wday"   => Time.now.wday
+        'epoch_seconds' => (Time.now.to_i / 60) * 60, # rounded
+        'epoch_minutes' => Time.now.to_i / 60,
+        'epoch_hours' => Time.now.to_i / (60 * 60),
+        'epoch_days' => Time.now.to_i / (60 * 60 * 24),
+        'minute' => Time.now.min,
+        'hour' => Time.now.hour,
+        'day' => Time.now.day,
+        'month' => Time.now.month,
+        'year' => Time.now.year,
+        'yday' => Time.now.yday,
+        'wday' => Time.now.wday
       }
     end
-    
-    it "should publish the current time once" do
-      Timecop.freeze "12/12/2013 12:01:19" do
-        expect(QueueBus).to receive(:publish).with("heartbeat_minutes", now_attributes)
+
+    it 'should publish the current time once' do
+      Timecop.freeze '12/12/2013 12:01:19' do
+        expect(QueueBus).to receive(:publish).with('heartbeat_minutes', now_attributes)
         Heartbeat.perform
       end
-      
-      Timecop.freeze "12/12/2013 12:01:40" do
+
+      Timecop.freeze '12/12/2013 12:01:40' do
         Heartbeat.perform
       end
     end
-    
-    it "should publish a minute later" do
-      Timecop.freeze "12/12/2013 12:01:19" do
-        expect(QueueBus).to receive(:publish).with("heartbeat_minutes", now_attributes)
+
+    it 'should publish a minute later' do
+      Timecop.freeze '12/12/2013 12:01:19' do
+        expect(QueueBus).to receive(:publish).with('heartbeat_minutes', now_attributes)
         Heartbeat.perform
       end
-      
-      Timecop.freeze "12/12/2013 12:02:01" do
-        expect(QueueBus).to receive(:publish).with("heartbeat_minutes", now_attributes)
+
+      Timecop.freeze '12/12/2013 12:02:01' do
+        expect(QueueBus).to receive(:publish).with('heartbeat_minutes', now_attributes)
         Heartbeat.perform
       end
     end

data/spec/integration_spec.rb

@@ -1,53 +1,54 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
-  describe "Integration" do
-    it "should round trip attributes" do      
-      write1 = Subscription.new("default", "key1", "MyClass1", {"bus_event_type" => "event_one"})
-      write2 = Subscription.new("else_ok", "key2", "MyClass2", {"bus_event_type" => /^[ab]here/})  #regex
-    
-      expect(write1.matches?("bus_event_type" => "event_one")).to  eq(true)
-      expect(write1.matches?("bus_event_type" => "event_one1")).to eq(false)
-      expect(write1.matches?("bus_event_type" => "aevent_one")).to eq(false)
-      
-      expect(write2.matches?("bus_event_type" => "ahere")).to eq(true)
-      expect(write2.matches?("bus_event_type" => "bhere")).to eq(true)
-      expect(write2.matches?("bus_event_type" => "qhere")).to eq(false)
-      expect(write2.matches?("bus_event_type" => "abhere")).to eq(false)
-      expect(write2.matches?("bus_event_type" => "[ab]here")).to eq(false)
-    
+  describe 'Integration' do
+    it 'should round trip attributes' do
+      write1 = Subscription.new('default', 'key1', 'MyClass1', 'bus_event_type' => 'event_one')
+      write2 = Subscription.new('else_ok', 'key2', 'MyClass2', 'bus_event_type' => /^[ab]here/) # regex
+
+      expect(write1.matches?('bus_event_type' => 'event_one')).to  eq(true)
+      expect(write1.matches?('bus_event_type' => 'event_one1')).to eq(false)
+      expect(write1.matches?('bus_event_type' => 'aevent_one')).to eq(false)
+
+      expect(write2.matches?('bus_event_type' => 'ahere')).to eq(true)
+      expect(write2.matches?('bus_event_type' => 'bhere')).to eq(true)
+      expect(write2.matches?('bus_event_type' => 'qhere')).to eq(false)
+      expect(write2.matches?('bus_event_type' => 'abhere')).to eq(false)
+      expect(write2.matches?('bus_event_type' => '[ab]here')).to eq(false)
+
       write = SubscriptionList.new
       write.add(write1)
       write.add(write2)
-    
-      app = Application.new("test")
+
+      app = Application.new('test')
       app.subscribe(write)
-    
-      reset_test_adapter  # reset to make sure we read from redis
-      app = Application.new("test")
+
+      reset_test_adapter # reset to make sure we read from redis
+      app = Application.new('test')
       read = app.send(:subscriptions)
-    
+
       expect(read.size).to eq(2)
-      read1 = read.key("key1")
-      read2 = read.key("key2")
+      read1 = read.key('key1')
+      read2 = read.key('key2')
       expect(read1).not_to be_nil
       expect(read2).not_to be_nil
-      
-      expect(read1.queue_name).to eq("default")
-      expect(read1.class_name).to eq("MyClass1")
-      expect(read2.queue_name).to eq("else_ok")
-      expect(read2.class_name).to eq("MyClass2")
-      
-      expect(read1.matches?("bus_event_type" => "event_one")).to  eq(true)
-      expect(read1.matches?("bus_event_type" => "event_one1")).to eq(false)
-      expect(read1.matches?("bus_event_type" => "aevent_one")).to eq(false)
-      
-      expect(read2.matches?("bus_event_type" => "ahere")).to eq(true)
-      expect(read2.matches?("bus_event_type" => "bhere")).to eq(true)
-      expect(read2.matches?("bus_event_type" => "qhere")).to eq(false)
-      expect(read2.matches?("bus_event_type" => "abhere")).to eq(false)
-      expect(read2.matches?("bus_event_type" => "[ab]here")).to eq(false)
-      
+
+      expect(read1.queue_name).to eq('default')
+      expect(read1.class_name).to eq('MyClass1')
+      expect(read2.queue_name).to eq('else_ok')
+      expect(read2.class_name).to eq('MyClass2')
+
+      expect(read1.matches?('bus_event_type' => 'event_one')).to  eq(true)
+      expect(read1.matches?('bus_event_type' => 'event_one1')).to eq(false)
+      expect(read1.matches?('bus_event_type' => 'aevent_one')).to eq(false)
+
+      expect(read2.matches?('bus_event_type' => 'ahere')).to eq(true)
+      expect(read2.matches?('bus_event_type' => 'bhere')).to eq(true)
+      expect(read2.matches?('bus_event_type' => 'qhere')).to eq(false)
+      expect(read2.matches?('bus_event_type' => 'abhere')).to eq(false)
+      expect(read2.matches?('bus_event_type' => '[ab]here')).to eq(false)
     end
   end
-end
+end