sidekiq-bus 0.8.1 → 0.8.2

data/spec/config_spec.rb

@@ -1,83 +1,80 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   module Adapters
     class TestOne
-
     end
   end
 end
 
-describe "QueueBus config" do
-  it "should set the default app key" do
+describe 'QueueBus config' do
+  it 'should set the default app key' do
     expect(QueueBus.default_app_key).to eq(nil)
 
-    QueueBus.default_app_key = "my_app"
-    expect(QueueBus.default_app_key).to eq("my_app")
+    QueueBus.default_app_key = 'my_app'
+    expect(QueueBus.default_app_key).to eq('my_app')
 
-    QueueBus.default_app_key = "something here"
-    expect(QueueBus.default_app_key).to eq("something_here")
+    QueueBus.default_app_key = 'something here'
+    expect(QueueBus.default_app_key).to eq('something_here')
   end
 
-  it "should set the default queue" do
+  it 'should set the default queue' do
     expect(QueueBus.default_queue).to eq(nil)
 
-    QueueBus.default_queue = "my_queue"
-    expect(QueueBus.default_queue).to eq("my_queue")
+    QueueBus.default_queue = 'my_queue'
+    expect(QueueBus.default_queue).to eq('my_queue')
   end
 
-  it "should set the local mode" do
+  it 'should set the local mode' do
     expect(QueueBus.local_mode).to eq(nil)
     QueueBus.local_mode = :standalone
     expect(QueueBus.local_mode).to eq(:standalone)
   end
 
-  it "should set the hostname" do
+  it 'should set the hostname' do
     expect(QueueBus.hostname).not_to eq(nil)
-    QueueBus.hostname = "whatever"
-    expect(QueueBus.hostname).to eq("whatever")
+    QueueBus.hostname = 'whatever'
+    expect(QueueBus.hostname).to eq('whatever')
   end
 
-  it "should set before_publish callback" do
-    QueueBus.before_publish = lambda {|attributes| 42 }
+  it 'should set before_publish callback' do
+    QueueBus.before_publish = ->(_attributes) { 42 }
     expect(QueueBus.before_publish_callback({})).to eq(42)
   end
 
-
-  it "should use the default Redis connection" do
+  it 'should use the default Redis connection' do
     expect(QueueBus.redis { |redis| redis }).not_to eq(nil)
   end
 
-  it "should default to given adapter" do
+  it 'should default to given adapter' do
     expect(QueueBus.adapter.is_a?(adapter_under_test_class)).to eq(true)
 
     # and should raise if already set
-    expect {
+    expect do
       QueueBus.adapter = :data
-    }.to raise_error("Adapter already set to QueueBus::Adapters::Sidekiq")
+    end.to raise_error('Adapter already set to QueueBus::Adapters::Sidekiq')
   end
 
-  context "with a fresh load" do
+  context 'with a fresh load' do
     before(:each) do
       QueueBus.send(:reset)
     end
 
-    it "should be able to be set to resque" do
+    it 'should be able to be set to resque' do
       QueueBus.adapter = adapter_under_test_symbol
       expect(QueueBus.adapter.is_a?(adapter_under_test_class)).to eq(true)
 
       # and should raise if already set
-      expect {
+      expect do
         QueueBus.adapter = :data
-      }.to raise_error("Adapter already set to QueueBus::Adapters::Sidekiq")
+      end.to raise_error('Adapter already set to QueueBus::Adapters::Sidekiq')
     end
 
-    it "should be able to be set to something else" do
-
+    it 'should be able to be set to something else' do
       QueueBus.adapter = :test_one
       expect(QueueBus.adapter.is_a?(QueueBus::Adapters::TestOne)).to eq(true)
     end
   end
-
-
 end

data/spec/dispatch_spec.rb

@@ -1,72 +1,71 @@
+# 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")).to eq(nil)
+    it 'should not crash if not there' do
+      expect(Dispatch.new('d').execute('fdkjh', 'bus_event_type' => 'fdkjh')).to eq(nil)
     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
+          low /^patt.+ern/ do
+            Runner.run({})
+          end
+        end
+      end
 
-      it "should register and run" do
+      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"} }
+    describe '.perform' do
+      let(:attributes) { { 'x' => 'y' } }
 
       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