queue-bus 0.6.0 → 0.9.1

data/spec/config_spec.rb

@@ -1,83 +1,159 @@
-require 'spec_helper'
-
-module QueueBus
-  module Adapters
-    class TestOne
+# frozen_string_literal: true
 
-    end
-  end
-end
+require 'spec_helper'
 
-describe "QueueBus config" do
-  it "should set the default app key" do
+describe 'QueueBus config' do
+  it 'sets 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 'sets 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 'sets 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
+  describe '#with_local_mode' do
+    it 'sets the local mode on the thread' do
+      QueueBus.with_local_mode(:suppress) do
+        expect(QueueBus.local_mode).to eq :suppress
+        Thread.new { expect(QueueBus.local_mode).to eq nil }.join
+      end
+    end
+
+    it 'supports nesting' do
+      QueueBus.with_local_mode(:suppress) do
+        expect(QueueBus.local_mode).to eq :suppress
+        QueueBus.with_local_mode(:inline) do
+          expect(QueueBus.local_mode).to eq :inline
+        end
+        expect(QueueBus.local_mode).to eq :suppress
+      end
+    end
+
+    it 'respects an override of nil' do
+      QueueBus.local_mode = :suppress
+      QueueBus.with_local_mode(nil) do
+        expect(QueueBus.local_mode).to eq nil
+      end
+      QueueBus.local_mode = :suppress
+    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
+      expect(QueueBus.local_mode).to eq nil
+    end
+  end
+
+  it 'sets 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 'sets before_publish callback' do
+    QueueBus.before_publish = ->(_attr) { 42 }
     expect(QueueBus.before_publish_callback({})).to eq(42)
   end
 
-
-  it "should use the default Redis connection" do
+  it 'uses the default Redis connection' do
     expect(QueueBus.redis { |redis| redis }).not_to eq(nil)
   end
 
-  it "should default to given adapter" do
+  it 'defaults to given adapter' do
     expect(QueueBus.adapter.is_a?(adapter_under_test_class)).to eq(true)
 
     # and should raise if already set
-    expect {
-      QueueBus.adapter = :data
-    }.to raise_error(RuntimeError, "Adapter already set to QueueBus::Adapters::Data")
+    expect { QueueBus.adapter = :data }
+      .to raise_error(RuntimeError, 'Adapter already set to QueueBus::Adapters::Data')
   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
-      QueueBus.adapter = adapter_under_test_symbol
-      expect(QueueBus.adapter.is_a?(adapter_under_test_class)).to eq(true)
+    context 'when set to adapter under test' do
+      before do
+        QueueBus.adapter = adapter_under_test_symbol
+      end
 
-      # and should raise if already set
-      expect {
+      it 'sets to that adapter' do
+        expect(QueueBus.adapter).to be_a adapter_under_test_class
+      end
+    end
+
+    context 'when already set' do
+      before do
         QueueBus.adapter = :data
-      }.to raise_error(RuntimeError, "Adapter already set to QueueBus::Adapters::Data")
+      end
+
+      it 'raises' do
+        expect { QueueBus.adapter = :data }
+          .to raise_error(RuntimeError, 'Adapter already set to QueueBus::Adapters::Data')
+      end
+
+      it 'knows the adapter is set' do
+        expect(QueueBus).to have_adapter
+      end
     end
 
-    it "should be able to be set to something else" do
+    context 'with a symbol' do
+      before do
+        QueueBus.adapter = :data
+      end
 
-      QueueBus.adapter = :test_one
-      expect(QueueBus.adapter.is_a?(QueueBus::Adapters::TestOne)).to eq(true)
+      it 'looks up the known class' do
+        expect(QueueBus.adapter).to be_a QueueBus::Adapters::Data
+      end
+    end
+
+    context 'with a custom adapter' do
+      let(:klass) do
+        Class.new(QueueBus::Adapters::Base) do
+          def enabled!
+            # no op
+          end
+
+          def redis
+            # no op
+          end
+        end
+      end
+
+      before do
+        QueueBus.adapter = klass.new
+      end
+
+      it 'sets it to something else' do
+        expect(QueueBus.adapter).to be_a klass
+      end
     end
-  end
 
+    context 'with a class' do
+      before do
+        QueueBus.adapter = QueueBus::Adapters::Data
+      end
 
+      it 'creates a new one' do
+        expect(QueueBus.adapter).to be_a QueueBus::Adapters::Data
+      end
+    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
-

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