queue-bus 0.6.0 → 0.9.1

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

data/spec/matcher_spec.rb

@@ -1,143 +1,145 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Matcher do
-    it "should already return false on empty filters" do
+    it 'should already return false on empty filters' do
       matcher = Matcher.new({})
-      expect(matcher.matches?({})).to  eq(false)
+      expect(matcher.matches?({})).to eq(false)
       expect(matcher.matches?(nil)).to  eq(false)
-      expect(matcher.matches?("name" => "val")).to eq(false)
+      expect(matcher.matches?('name' => 'val')).to eq(false)
     end
 
-    it "should not crash if nil inputs" do
-      matcher = Matcher.new("name" => "val")
+    it 'should not crash if nil inputs' do
+      matcher = Matcher.new('name' => 'val')
       expect(matcher.matches?(nil)).to eq(false)
     end
 
-    it "string filter to/from redis" do
-      matcher = Matcher.new("name" => "val")
-      expect(matcher.matches?("name" => "val")).to   eq(true)
-      expect(matcher.matches?("name" => " val")).to  eq(false)
-      expect(matcher.matches?("name" => "zval")).to  eq(false)
+    it 'string filter to/from redis' do
+      matcher = Matcher.new('name' => 'val')
+      expect(matcher.matches?('name' => 'val')).to   eq(true)
+      expect(matcher.matches?('name' => ' val')).to  eq(false)
+      expect(matcher.matches?('name' => 'zval')).to  eq(false)
     end
 
-    it "regex filter" do
-      matcher = Matcher.new("name" => /^[cb]a+t/)
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
+    it 'regex filter' do
+      matcher = Matcher.new('name' => /^[cb]a+t/)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
     end
 
-    it "present filter" do
-      matcher = Matcher.new("name" => :present)
-      expect(matcher.matches?("name" => "")).to eq(false)
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
+    it 'present filter' do
+      matcher = Matcher.new('name' => :present)
+      expect(matcher.matches?('name' => '')).to eq(false)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
     end
 
-    it "blank filter" do
-      matcher = Matcher.new("name" => :blank)
-      expect(matcher.matches?("name" => nil)).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(true)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "   s ")).to eq(false)
+    it 'blank filter' do
+      matcher = Matcher.new('name' => :blank)
+      expect(matcher.matches?('name' => nil)).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(true)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '   s ')).to eq(false)
     end
 
-    it "nil filter" do
-      matcher = Matcher.new("name" => :nil)
-      expect(matcher.matches?("name" => nil)).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(true)
-      expect(matcher.matches?("name" => "")).to eq(false)
-      expect(matcher.matches?("name" => "  ")).to eq(false)
-      expect(matcher.matches?("name" => "bear")).to eq(false)
+    it 'nil filter' do
+      matcher = Matcher.new('name' => :nil)
+      expect(matcher.matches?('name' => nil)).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(true)
+      expect(matcher.matches?('name' => '')).to eq(false)
+      expect(matcher.matches?('name' => '  ')).to eq(false)
+      expect(matcher.matches?('name' => 'bear')).to eq(false)
     end
 
-    it "key filter" do
-      matcher = Matcher.new("name" => :key)
-      expect(matcher.matches?("name" => nil)).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(true)
+    it 'key filter' do
+      matcher = Matcher.new('name' => :key)
+      expect(matcher.matches?('name' => nil)).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(true)
     end
 
-    it "empty filter" do
-      matcher = Matcher.new("name" => :empty)
-      expect(matcher.matches?("name" => nil)).to eq(false)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(false)
-      expect(matcher.matches?("name" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "   s ")).to eq(false)
+    it 'empty filter' do
+      matcher = Matcher.new('name' => :empty)
+      expect(matcher.matches?('name' => nil)).to eq(false)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(false)
+      expect(matcher.matches?('name' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '   s ')).to eq(false)
     end
 
-    it "value filter" do
-      matcher = Matcher.new("name" => :value)
-      expect(matcher.matches?("name" => nil)).to eq(false)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(true)
-      expect(matcher.matches?("name" => "   s ")).to eq(true)
+    it 'value filter' do
+      matcher = Matcher.new('name' => :value)
+      expect(matcher.matches?('name' => nil)).to eq(false)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(true)
+      expect(matcher.matches?('name' => '   s ')).to eq(true)
     end
 
-    it "multiple filters" do
-      matcher = Matcher.new("name" => /^[cb]a+t/, "state" => "sleeping")
-      expect(matcher.matches?("state" => "sleeping", "name" => "cat")).to  eq(true)
-      expect(matcher.matches?("state" => "awake", "name" => "cat")).to     eq(false)
-      expect(matcher.matches?("state" => "sleeping", "name" => "bat")).to  eq(true)
-      expect(matcher.matches?("state" => "sleeping", "name" => "bear")).to eq(false)
-      expect(matcher.matches?("state" => "awake", "name" => "bear")).to    eq(false)
+    it 'multiple filters' do
+      matcher = Matcher.new('name' => /^[cb]a+t/, 'state' => 'sleeping')
+      expect(matcher.matches?('state' => 'sleeping', 'name' => 'cat')).to  eq(true)
+      expect(matcher.matches?('state' => 'awake', 'name' => 'cat')).to     eq(false)
+      expect(matcher.matches?('state' => 'sleeping', 'name' => 'bat')).to  eq(true)
+      expect(matcher.matches?('state' => 'sleeping', 'name' => 'bear')).to eq(false)
+      expect(matcher.matches?('state' => 'awake', 'name' => 'bear')).to    eq(false)
     end
 
-    it "regex should go back and forth into redis" do
-      matcher = Matcher.new("name" => /^[cb]a+t/)
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
+    it 'regex should go back and forth into redis' do
+      matcher = Matcher.new('name' => /^[cb]a+t/)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
 
-      QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis = QueueBus.redis { |redis| redis.get("temp1") }
+      QueueBus.redis { |redis| redis.set('temp1', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp1') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
-
-      QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis = QueueBus.redis { |redis| redis.get("temp2") }
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
+
+      QueueBus.redis { |redis| redis.set('temp2', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp2') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
     end
 
-    it "special value should go back and forth into redis" do
-      matcher = Matcher.new("name" => :blank)
-      expect(matcher.matches?("name" => "cat")).to eq(false)
-      expect(matcher.matches?("name" => "")).to    eq(true)
+    it 'special value should go back and forth into redis' do
+      matcher = Matcher.new('name' => :blank)
+      expect(matcher.matches?('name' => 'cat')).to eq(false)
+      expect(matcher.matches?('name' => '')).to    eq(true)
 
-      QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis= QueueBus.redis { |redis| redis.get("temp1") }
+      QueueBus.redis { |redis| redis.set('temp1', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp1') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(false)
-      expect(matcher.matches?("name" => "")).to    eq(true)
+      expect(matcher.matches?('name' => 'cat')).to eq(false)
+      expect(matcher.matches?('name' => '')).to    eq(true)
 
-      QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis= QueueBus.redis { |redis| redis.get("temp2") }
+      QueueBus.redis { |redis| redis.set('temp2', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp2') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(false)
-      expect(matcher.matches?("name" => "")).to    eq(true)
+      expect(matcher.matches?('name' => 'cat')).to eq(false)
+      expect(matcher.matches?('name' => '')).to    eq(true)
     end
   end
 end

data/spec/publish_spec.rb

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