queue-bus 0.5.9 → 0.6.0

data/spec/middleware_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe QueueBus::Middleware do
+  subject { described_class::Stack.new }
+
+  let(:args) { { rand: rand } }
+  let(:inner) { proc {} }
+
+  let(:base_class) do
+    # Creates a unique base class that provides tracking of calls.
+    Class.new(QueueBus::Middleware::Abstract) do
+      class << self
+        attr_accessor :called_at
+      end
+
+      def call(_args)
+        self.class.called_at = Time.now
+        @app.call
+      end
+    end
+  end
+
+  context 'with none configured' do
+    it 'falls through' do
+      expect(inner).to receive(:call)
+      subject.run(args, &inner)
+    end
+  end
+
+  context 'with the abstract class configured' do
+    before do
+      subject.use(QueueBus::Middleware::Abstract)
+    end
+
+    it 'runs the inner' do
+      expect(inner).to receive(:call).and_call_original
+      subject.run(args, &inner)
+    end
+  end
+
+  context 'with one middleware' do
+    let(:middleware) do
+      Class.new(base_class) do
+        class << self
+          attr_accessor :args
+        end
+
+        def call(args)
+          self.class.args = args
+          super
+        end
+      end
+    end
+
+    before do
+      subject.use(middleware)
+    end
+
+    it 'calls the middleware with the args' do
+      subject.run(args, &inner)
+
+      expect(middleware.args).to eql args
+    end
+
+    it 'calls the middleware and then inner' do
+      expect(inner).to receive(:call).and_call_original
+      subject.run(args, &inner)
+      expect(middleware.called_at).not_to be_nil
+    end
+
+    context 'and the middleware does not yield' do
+      let(:middleware) do
+        Class.new(base_class) do
+          def call(_args)
+            self.class.called_at = Time.now
+            # no-op
+          end
+        end
+      end
+
+      it 'does not run inner' do
+        expect(inner).not_to receive(:call).and_call_original
+        subject.run(args, &inner)
+        expect(middleware.called_at).not_to be_nil
+      end
+    end
+  end
+
+  context 'with more than one middleware' do
+    let(:middlewares) do
+      Array.new(rand(2..20)).map do
+        Class.new(base_class)
+      end
+    end
+
+    before do
+      middlewares.each do |middleware|
+        subject.use(middleware)
+      end
+    end
+
+    it 'calls all the middlewares in order' do
+      expect(inner).to receive(:call).and_call_original
+      subject.run(args, &inner)
+      # Test by sorting by when it was called. This should be in a strict
+      # order based on call order.
+      expect(middlewares.sort_by(&:called_at)).to eq middlewares
+    end
+  end
+end

data/spec/publish_spec.rb

@@ -4,7 +4,7 @@ describe "Publishing an event" do
 
   before(:each) do
     Timecop.freeze
-    QueueBus.stub(:generate_uuid).and_return("idfhlkj")
+    allow(QueueBus).to receive(:generate_uuid).and_return("idfhlkj")
   end
   after(:each) do
     Timecop.return
@@ -19,15 +19,15 @@ describe "Publishing an event" do
     event_name = "event_name"
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
-    val.should == nil
+    expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
-    hash["class"].should == "QueueBus::Worker"
-    hash["args"].size.should == 1
-    JSON.parse(hash["args"].first).should == {"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
 
@@ -36,15 +36,15 @@ describe "Publishing an event" do
     event_name = "event_name"
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
-    val.should == nil
+    expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
-    hash["class"].should == "QueueBus::Worker"
-    hash["args"].size.should == 1
-    JSON.parse(hash["args"].first).should == {"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
@@ -58,7 +58,7 @@ describe "Publishing an event" do
     event_name = "event_name"
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
-    val.should == nil
+    expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
@@ -66,33 +66,33 @@ describe "Publishing an event" do
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
     att = JSON.parse(hash["args"].first)
-    att["mine"].should == 4
-    myval.should == 1
+    expect(att["mine"]).to eq(4)
+    expect(myval).to eq(1)
   end
 
   it "should set the timezone and locale if available" do
-    defined?(I18n).should be_nil
-    Time.respond_to?(:zone).should eq(false)
+    expect(defined?(I18n)).to be_nil
+    expect(Time.respond_to?(:zone)).to eq(false)
 
     stub_const("I18n", Class.new)
-    I18n.stub(:locale).and_return("jp")
+    allow(I18n).to receive(:locale).and_return("jp")
 
-    Time.stub(: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"
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
-    val.should == nil
+    expect(val).to eq(nil)
 
     QueueBus.publish(event_name, hash)
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
-    hash["class"].should == "QueueBus::Worker"
+    expect(hash["class"]).to eq("QueueBus::Worker")
     att = JSON.parse(hash["args"].first)
-    att["bus_locale"].should == "jp"
-    att["bus_timezone"].should == "EST"
+    expect(att["bus_locale"]).to eq("jp")
+    expect(att["bus_timezone"]).to eq("EST")
   end
 
 end

data/spec/rider_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module QueueBus
   describe Rider do
     it "should call execute" do
-      QueueBus.should_receive(:dispatcher_execute)
+      expect(QueueBus).to receive(:dispatcher_execute)
       Rider.perform("bus_rider_app_key" => "app", "bus_rider_sub_key" => "sub", "ok" => true, "bus_event_type" => "event_name")
     end
 
@@ -13,10 +13,10 @@ module QueueBus
           Runner1.run(attributes)
         end
       end
-      Runner1.value.should == 0
+      expect(Runner1.value).to eq(0)
       Rider.perform("bus_locale" => "en", "bus_timezone" => "PST", "bus_rider_app_key" => "r1", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
       Rider.perform("bus_rider_app_key" => "other", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
-      Runner1.value.should == 1
+      expect(Runner1.value).to eq(1)
     end
 
     it "should set the timezone and locale if present" do
@@ -26,12 +26,12 @@ module QueueBus
         end
       end
 
-      defined?(I18n).should be_nil
-      Time.respond_to?(:zone).should eq(false)
+      expect(defined?(I18n)).to be_nil
+      expect(Time.respond_to?(:zone)).to eq(false)
 
       stub_const("I18n", Class.new)
-      I18n.should_receive(:locale=).with("en")
-      Time.should_receive(:zone=).with("PST")
+      expect(I18n).to receive(:locale=).with("en")
+      expect(Time).to receive(:zone=).with("PST")
 
       Rider.perform("bus_locale" => "en", "bus_timezone" => "PST", "bus_rider_app_key" => "r1", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
     end

data/spec/spec_helper.rb

@@ -48,10 +48,10 @@ end
 
 RSpec.configure do |config|
   config.mock_with :rspec do |c|
-    c.syntax = :should
+    c.syntax = :expect
   end
   config.expect_with :rspec do |c|
-    c.syntax = :should
+    c.syntax = :expect
   end
 
   config.before(:each) do

data/spec/subscriber_spec.rb

@@ -70,111 +70,111 @@ require 'spec_helper'
     end
 
     it "should have the application" do
-      SubscriberTest1.app_key.should == "my_thing"
-      SubModule::SubscriberTest3.app_key.should == "sub_module"
-      SubModule::SubscriberTest4.app_key.should == "sub_module"
+      expect(SubscriberTest1.app_key).to eq("my_thing")
+      expect(SubModule::SubscriberTest3.app_key).to eq("sub_module")
+      expect(SubModule::SubscriberTest4.app_key).to eq("sub_module")
     end
 
     it "should be able to transform the attributes" do
       dispatcher = QueueBus.dispatcher_by_key("test2")
       all = dispatcher.subscriptions.all
-      all.size.should == 1
+      expect(all.size).to eq(1)
 
       sub = all.first
-      sub.queue_name.should == "test2_default"
-      sub.class_name.should == "SubscriberTest2"
-      sub.key.should == "SubscriberTest2.test2"
-      sub.matcher.filters.should == {"value"=>"bus_special_value_present"}
+      expect(sub.queue_name).to eq("test2_default")
+      expect(sub.class_name).to eq("SubscriberTest2")
+      expect(sub.key).to eq("SubscriberTest2.test2")
+      expect(sub.matcher.filters).to eq({"value"=>"bus_special_value_present"})
 
       QueueBus::Driver.perform(attributes.merge("bus_event_type" => "something2", "value"=>"nice"))
 
       hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:test2_default") })
-      hash["class"].should == "QueueBus::Worker"
-      hash["args"].size.should == 1
-      JSON.parse(hash["args"].first).should eq({"bus_class_proxy" => "SubscriberTest2", "bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
+      expect(hash["class"]).to eq("QueueBus::Worker")
+      expect(hash["args"].size).to eq(1)
+      expect(JSON.parse(hash["args"].first)).to eq({"bus_class_proxy" => "SubscriberTest2", "bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
                                "bus_event_type" => "something2", "value"=>"nice", "x"=>"y"}.merge(bus_attrs))
 
-      QueueBus::Runner1.value.should == 0
-      QueueBus::Runner2.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(0)
+      expect(QueueBus::Runner2.value).to eq(0)
       QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
-      QueueBus::Runner1.value.should == 1
-      QueueBus::Runner2.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(1)
+      expect(QueueBus::Runner2.value).to eq(0)
 
-      QueueBus::Runner1.attributes.should == {"transformed" => 4}
+      expect(QueueBus::Runner1.attributes).to eq({"transformed" => 4})
 
 
       QueueBus::Driver.perform(attributes.merge("bus_event_type" => "something2", "value"=>"12"))
 
       hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:test2_default") })
-      hash["class"].should == "QueueBus::Worker"
-      hash["args"].size.should == 1
-      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubscriberTest2", "bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
-                               "bus_event_type" => "something2", "value"=>"12", "x"=>"y"}.merge(bus_attrs)
+      expect(hash["class"]).to eq("QueueBus::Worker")
+      expect(hash["args"].size).to eq(1)
+      expect(JSON.parse(hash["args"].first)).to eq({"bus_class_proxy" => "SubscriberTest2", "bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
+                               "bus_event_type" => "something2", "value"=>"12", "x"=>"y"}.merge(bus_attrs))
 
-      QueueBus::Runner1.value.should == 1
-      QueueBus::Runner2.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(1)
+      expect(QueueBus::Runner2.value).to eq(0)
       QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
-      QueueBus::Runner1.value.should == 2
-      QueueBus::Runner2.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(2)
+      expect(QueueBus::Runner2.value).to eq(0)
 
-      QueueBus::Runner1.attributes.should == {"transformed" => 2}
+      expect(QueueBus::Runner1.attributes).to eq({"transformed" => 2})
     end
 
 
     it "should put in a different queue" do
       dispatcher = QueueBus.dispatcher_by_key("sub_module")
       all = dispatcher.subscriptions.all
-      all.size.should == 4
+      expect(all.size).to eq(4)
 
       sub = all.select{ |s| s.key == "SubModule::SubscriberTest3.test3"}.first
-      sub.queue_name.should == "sub_queue1"
-      sub.class_name.should == "SubModule::SubscriberTest3"
-      sub.key.should == "SubModule::SubscriberTest3.test3"
-      sub.matcher.filters.should == {"bus_event_type"=>"the_event"}
+      expect(sub.queue_name).to eq("sub_queue1")
+      expect(sub.class_name).to eq("SubModule::SubscriberTest3")
+      expect(sub.key).to eq("SubModule::SubscriberTest3.test3")
+      expect(sub.matcher.filters).to eq({"bus_event_type"=>"the_event"})
 
       sub = all.select{ |s| s.key == "SubModule::SubscriberTest3.the_event"}.first
-      sub.queue_name.should == "sub_queue2"
-      sub.class_name.should == "SubModule::SubscriberTest3"
-      sub.key.should == "SubModule::SubscriberTest3.the_event"
-      sub.matcher.filters.should == {"bus_event_type"=>"the_event"}
+      expect(sub.queue_name).to eq("sub_queue2")
+      expect(sub.class_name).to eq("SubModule::SubscriberTest3")
+      expect(sub.key).to eq("SubModule::SubscriberTest3.the_event")
+      expect(sub.matcher.filters).to eq({"bus_event_type"=>"the_event"})
 
       sub = all.select{ |s| s.key == "SubModule::SubscriberTest3.other"}.first
-      sub.queue_name.should == "sub_module_default"
-      sub.class_name.should == "SubModule::SubscriberTest3"
-      sub.key.should == "SubModule::SubscriberTest3.other"
-      sub.matcher.filters.should == {"bus_event_type"=>"other_event"}
+      expect(sub.queue_name).to eq("sub_module_default")
+      expect(sub.class_name).to eq("SubModule::SubscriberTest3")
+      expect(sub.key).to eq("SubModule::SubscriberTest3.other")
+      expect(sub.matcher.filters).to eq({"bus_event_type"=>"other_event"})
 
       sub = all.select{ |s| s.key == "SubModule::SubscriberTest4.test4"}.first
-      sub.queue_name.should == "sub_queue1"
-      sub.class_name.should == "SubModule::SubscriberTest4"
-      sub.key.should == "SubModule::SubscriberTest4.test4"
-      sub.matcher.filters.should == {"bus_event_type"=>"test4"}
+      expect(sub.queue_name).to eq("sub_queue1")
+      expect(sub.class_name).to eq("SubModule::SubscriberTest4")
+      expect(sub.key).to eq("SubModule::SubscriberTest4.test4")
+      expect(sub.matcher.filters).to eq({"bus_event_type"=>"test4"})
 
       QueueBus::Driver.perform(attributes.merge("bus_event_type" => "the_event"))
 
       hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:sub_queue1") })
-      hash["class"].should == "QueueBus::Worker"
-      hash["args"].size.should == 1
-      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubModule::SubscriberTest3", "bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.test3", "bus_rider_queue" => "sub_queue1", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
-                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs)
+      expect(hash["class"]).to eq("QueueBus::Worker")
+      expect(hash["args"].size).to eq(1)
+      expect(JSON.parse(hash["args"].first)).to eq({"bus_class_proxy" => "SubModule::SubscriberTest3", "bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.test3", "bus_rider_queue" => "sub_queue1", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
+                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs))
 
-      QueueBus::Runner1.value.should == 0
-      QueueBus::Runner2.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(0)
+      expect(QueueBus::Runner2.value).to eq(0)
       QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
-      QueueBus::Runner1.value.should == 1
-      QueueBus::Runner2.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(1)
+      expect(QueueBus::Runner2.value).to eq(0)
 
       hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:sub_queue2") })
-      hash["class"].should == "QueueBus::Worker"
-      hash["args"].size.should == 1
-      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubModule::SubscriberTest3", "bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.the_event", "bus_rider_queue" => "sub_queue2", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
-                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs)
+      expect(hash["class"]).to eq("QueueBus::Worker")
+      expect(hash["args"].size).to eq(1)
+      expect(JSON.parse(hash["args"].first)).to eq({"bus_class_proxy" => "SubModule::SubscriberTest3", "bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.the_event", "bus_rider_queue" => "sub_queue2", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
+                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs))
 
-      QueueBus::Runner1.value.should == 1
-      QueueBus::Runner2.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(1)
+      expect(QueueBus::Runner2.value).to eq(0)
       QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
-      QueueBus::Runner1.value.should == 1
-      QueueBus::Runner2.value.should == 1
+      expect(QueueBus::Runner1.value).to eq(1)
+      expect(QueueBus::Runner2.value).to eq(1)
     end
 
     it "should subscribe to default and attributes" do
@@ -182,19 +182,19 @@ require 'spec_helper'
       all = dispatcher.subscriptions.all
 
       sub = all.select{ |s| s.key == "SubscriberTest1.event_sub"}.first
-      sub.queue_name.should == "myqueue"
-      sub.class_name.should == "SubscriberTest1"
-      sub.key.should == "SubscriberTest1.event_sub"
-      sub.matcher.filters.should == {"bus_event_type"=>"event_sub"}
+      expect(sub.queue_name).to eq("myqueue")
+      expect(sub.class_name).to eq("SubscriberTest1")
+      expect(sub.key).to eq("SubscriberTest1.event_sub")
+      expect(sub.matcher.filters).to eq({"bus_event_type"=>"event_sub"})
 
       sub = all.select{ |s| s.key == "SubscriberTest1.thing_filter"}.first
-      sub.queue_name.should == "myqueue"
-      sub.class_name.should == "SubscriberTest1"
-      sub.key.should == "SubscriberTest1.thing_filter"
-      sub.matcher.filters.should == {"x"=>"y"}
+      expect(sub.queue_name).to eq("myqueue")
+      expect(sub.class_name).to eq("SubscriberTest1")
+      expect(sub.key).to eq("SubscriberTest1.thing_filter")
+      expect(sub.matcher.filters).to eq({"x"=>"y"})
 
       QueueBus::Driver.perform(attributes.merge("bus_event_type" => "event_sub"))
-      QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["myqueue"]
+      expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["myqueue"])
 
       pop1 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:myqueue") })
       pop2 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:myqueue") })
@@ -207,63 +207,63 @@ require 'spec_helper'
         hash2 = pop1
       end
 
-      hash1["class"].should == "QueueBus::Worker"
-      JSON.parse(hash1["args"].first).should eq({"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
+      expect(hash1["class"]).to eq("QueueBus::Worker")
+      expect(JSON.parse(hash1["args"].first)).to eq({"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
                                 "bus_event_type" => "event_sub", "x" => "y"}.merge(bus_attrs))
 
-      QueueBus::Runner1.value.should == 0
-      QueueBus::Runner2.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(0)
+      expect(QueueBus::Runner2.value).to eq(0)
       QueueBus::Util.constantize(hash1["class"]).perform(*hash1["args"])
-      QueueBus::Runner1.value.should == 0
-      QueueBus::Runner2.value.should == 1
+      expect(QueueBus::Runner1.value).to eq(0)
+      expect(QueueBus::Runner2.value).to eq(1)
 
-      hash2["class"].should == "QueueBus::Worker"
-      hash2["args"].size.should == 1
-      JSON.parse(hash2["args"].first).should == {"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.event_sub", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
-                                "bus_event_type" => "event_sub", "x" => "y"}.merge(bus_attrs)
+      expect(hash2["class"]).to eq("QueueBus::Worker")
+      expect(hash2["args"].size).to eq(1)
+      expect(JSON.parse(hash2["args"].first)).to eq({"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.event_sub", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
+                                "bus_event_type" => "event_sub", "x" => "y"}.merge(bus_attrs))
 
-      QueueBus::Runner1.value.should == 0
-      QueueBus::Runner2.value.should == 1
+      expect(QueueBus::Runner1.value).to eq(0)
+      expect(QueueBus::Runner2.value).to eq(1)
       QueueBus::Util.constantize(hash2["class"]).perform(*hash2["args"])
-      QueueBus::Runner1.value.should == 1
-      QueueBus::Runner2.value.should == 1
+      expect(QueueBus::Runner1.value).to eq(1)
+      expect(QueueBus::Runner2.value).to eq(1)
 
       QueueBus::Driver.perform(attributes.merge("bus_event_type" => "event_sub_other"))
-      QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["myqueue"]
+      expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["myqueue"])
 
       hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:myqueue") })
-      hash["class"].should == "QueueBus::Worker"
-      hash["args"].size.should == 1
-      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
-                                "bus_event_type" => "event_sub_other", "x" => "y"}.merge(bus_attrs)
+      expect(hash["class"]).to eq("QueueBus::Worker")
+      expect(hash["args"].size).to eq(1)
+      expect(JSON.parse(hash["args"].first)).to eq({"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
+                                "bus_event_type" => "event_sub_other", "x" => "y"}.merge(bus_attrs))
 
-      QueueBus::Runner1.value.should == 1
-      QueueBus::Runner2.value.should == 1
+      expect(QueueBus::Runner1.value).to eq(1)
+      expect(QueueBus::Runner2.value).to eq(1)
       QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
-      QueueBus::Runner1.value.should == 1
-      QueueBus::Runner2.value.should == 2
+      expect(QueueBus::Runner1.value).to eq(1)
+      expect(QueueBus::Runner2.value).to eq(2)
 
       QueueBus::Driver.perform({"x"=>"z"}.merge("bus_event_type" => "event_sub_other"))
-      QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["myqueue"]
+      expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["myqueue"])
 
-      QueueBus.redis { |redis| redis.lpop("queue:myqueue") }.should be_nil
+      expect(QueueBus.redis { |redis| redis.lpop("queue:myqueue") }).to be_nil
     end
 
     describe ".perform" do
       let(:attributes) { {"bus_rider_sub_key"=>"SubscriberTest1.event_sub", "bus_locale" => "en", "bus_timezone" => "PST"} }
       it "should call the method based on key" do
-        SubscriberTest1.any_instance.should_receive(:event_sub)
+        expect_any_instance_of(SubscriberTest1).to receive(:event_sub)
         SubscriberTest1.perform(attributes)
       end
       it "should set the timezone and locale if present" do
-        defined?(I18n).should be_nil
-        Time.respond_to?(:zone).should eq(false)
+        expect(defined?(I18n)).to be_nil
+        expect(Time.respond_to?(:zone)).to eq(false)
 
         stub_const("I18n", Class.new)
-        I18n.should_receive(:locale=).with("en")
-        Time.should_receive(:zone=).with("PST")
+        expect(I18n).to receive(:locale=).with("en")
+        expect(Time).to receive(:zone=).with("PST")
 
-        SubscriberTest1.any_instance.should_receive(:event_sub)
+        expect_any_instance_of(SubscriberTest1).to receive(:event_sub)
         SubscriberTest1.perform(attributes)
       end
     end