queue-bus 0.5.9 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e1b4c0ca9bf660b79b88769d6ba7e4d2d89e28f5
-  data.tar.gz: 2840967bb05b953171b300d28538d6b362332e6d
+SHA256:
+  metadata.gz: f18ed6e21b956ce928e0c3ede7e1493eb7806413706e92e1f4c991667e9e06b8
+  data.tar.gz: 4043918b7705741e3719d6460b9823367b9e271e6344193c2b616aab063a4d9a
 SHA512:
-  metadata.gz: 90dded1ee751e8d7773fbc183a8c8a0c430ec7dac927090fae6c775c05605c007b11e9a0595b0670f83becd6f5100b012d63ec77b34180d3ce9c802c995ca48e
-  data.tar.gz: 9ddb1c632db8dcd4ca2d298fe50b219485cc408c264eef073d17b0f61fe447c4de04aad9cece3c01f3952f8cd5e931626a0f5aedbd3a8e7380111775095ac938
+  metadata.gz: 6894d383941edf09df6d245eaffc57ecd2ef3185bb3196d89a29c7714cc7b3f849639e285764ee57832158a566538bc2c1b8b6691af2d73ab5a3760d8893ef5e
+  data.tar.gz: 9b08d34ff3309f039640a1c154b5f33cfc186f69f18511a09201e4eeb5553ef8f5b8ad053405fc6f9bf3658d5750543d7fa92d431d88ba72af5c3ab8f0d50e45

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.6.0]
+
+### Added
+- New middleware implementation that allows middleware to wrap the execution of work from the `QueueBus::Worker`
+- Changelog!
+
+### Changed
+- Specs are now using the `expect` syntax instead of `should`. This more closely aligns with the rspec recommendations.

data/lib/queue-bus.rb

@@ -11,6 +11,7 @@ module QueueBus
   autoload :Heartbeat,        'queue_bus/heartbeat'
   autoload :Local,            'queue_bus/local'
   autoload :Matcher,          'queue_bus/matcher'
+  autoload :Middleware,       'queue_bus/middleware'
   autoload :Publishing,       'queue_bus/publishing'
   autoload :Publisher,        'queue_bus/publisher'
   autoload :Rider,            'queue_bus/rider'
@@ -39,7 +40,7 @@ module QueueBus
                             :hostname=, :hostname,
                             :adapter=, :adapter,
                             :incoming_queue=, :incoming_queue,
-                            :redis
+                            :redis, :worker_middleware_stack
 
     def_delegators :_dispatchers, :dispatch, :dispatchers, :dispatcher_by_key, :dispatcher_execute
 

data/lib/queue_bus/config.rb

@@ -55,6 +55,10 @@ module QueueBus
       @incoming_queue ||= "bus_incoming"
     end
 
+    def worker_middleware_stack
+      @worker_middleware_stack ||= QueueBus::Middleware::Stack.new
+    end
+
     def hostname
       @hostname ||= `hostname 2>&1`.strip.sub(/.local/,'')
     end

data/lib/queue_bus/middleware.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module QueueBus
+  module Middleware
+    # A base class for implementing a middleware. Inheriting from this will
+    # provide a constructor and a basic call method. Override the call method
+    # to implement your own logic. Calling the instance variable `@app` will
+    # drive the middleware stack.
+    class Abstract
+      def initialize(app)
+        @app = app
+      end
+
+      def call(_args)
+        @app.call
+      end
+    end
+
+    # A stack of middleware. You can modify the stack using the provided
+    # helper methods.
+    class Stack
+      def initialize
+        @middlewares = []
+      end
+
+      def use(middleware)
+        @middlewares << middleware
+      end
+
+      def run(args, &inner)
+        Runner.new(args: args, stack: @middlewares.dup, inner: inner).call
+      end
+    end
+
+    # Runs the middleware stack by passing it self to each class.
+    class Runner
+      def initialize(args:, stack:, inner:)
+        @stack = stack
+        @inner = inner
+        @args = args
+      end
+
+      def call
+        middleware = @stack.shift
+
+        if middleware
+          middleware.new(self).call(@args)
+        else
+          @inner.call
+        end
+      end
+    end
+  end
+end

data/lib/queue_bus/version.rb

@@ -1,3 +1,3 @@
 module QueueBus
-  VERSION = "0.5.9"
+  VERSION = "0.6.0"
 end

data/lib/queue_bus/worker.rb

@@ -12,7 +12,9 @@ module QueueBus
         return
       end
 
-      klass.perform(attributes)
+      QueueBus.worker_middleware_stack.run(attributes) do
+        klass.perform(attributes)
+      end
     end
 
     # all our workers include this one

data/spec/adapter/publish_at_spec.rb

@@ -4,7 +4,7 @@ describe "Publishing an event in the future" do
 
   before(:each) do
     Timecop.freeze(now)
-    QueueBus.stub(:generate_uuid).and_return("idfhlkj")
+    allow(QueueBus).to receive(:generate_uuid).and_return("idfhlkj")
   end
   after(:each) do
     Timecop.return
@@ -25,27 +25,27 @@ describe "Publishing an event in the future" do
     QueueBus.publish_at(future, event_name, hash)
 
     schedule = QueueBus.redis { |redis| redis.zrange("delayed_queue_schedule", 0, 1) }
-    schedule.should == [future.to_i.to_s]
+    expect(schedule).to eq([future.to_i.to_s])
 
     val = QueueBus.redis { |redis| redis.lpop("delayed:#{future.to_i}") }
     hash = JSON.parse(val)
 
-    hash["class"].should == "QueueBus::Worker"
-    hash["args"].size.should == 1
-    JSON.parse(hash["args"].first).should == {"bus_class_proxy"=>"QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs)
-    hash["queue"].should == "bus_incoming"
+    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"=>"QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs))
+    expect(hash["queue"]).to eq("bus_incoming")
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
-    val.should == nil # nothing really added
+    expect(val).to eq(nil) # nothing really added
 
     Timecop.freeze(worktime)
     QueueBus::Publisher.perform(JSON.parse(hash["args"].first))
 
     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_class_proxy"=>"QueueBus::Driver", "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_class_proxy"=>"QueueBus::Driver", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs))
   end
 
 end

data/spec/adapter_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe "adapter is set" do
   it "should call it's enabled! method on init" do
     QueueBus.send(:reset)
-    adapter_under_test_class.any_instance.should_receive(:enabled!)
+    expect_any_instance_of(adapter_under_test_class).to receive(:enabled!)
     instance = adapter_under_test_class.new
     QueueBus.send(:reset)
   end
 
   it "should be defaulting to Data from spec_helper" do
-    QueueBus.adapter.is_a?(adapter_under_test_class).should == true
+    expect(QueueBus.adapter.is_a?(adapter_under_test_class)).to eq(true)
   end
 end

data/spec/application_spec.rb

@@ -4,42 +4,42 @@ module QueueBus
   describe Application do
     describe ".all" do
       it "should return empty array when none" do
-        Application.all.should == []
+        expect(Application.all).to eq([])
       end
       it "should return registered applications when there are some" do
         Application.new("One").subscribe(test_list(test_sub("fdksjh")))
         Application.new("Two").subscribe(test_list(test_sub("fdklhf")))
         Application.new("Three").subscribe(test_list(test_sub("fkld")))
 
-        Application.all.collect(&:app_key).should =~ ["one", "two", "three"]
+        expect(Application.all.collect(&:app_key)).to match_array(["one", "two", "three"])
 
         Application.new("two").unsubscribe
-        Application.all.collect(&:app_key).should =~ ["one", "three"]
+        expect(Application.all.collect(&:app_key)).to match_array(["one", "three"])
       end
     end
 
     describe ".new" do
       it "should have a key" do
-        Application.new("something").app_key.should == "something"
+        expect(Application.new("something").app_key).to eq("something")
 
-        Application.new("some thing").app_key.should == "some_thing"
-        Application.new("some-thing").app_key.should == "some_thing"
-        Application.new("some_thing").app_key.should == "some_thing"
-        Application.new("Some Thing").app_key.should == "some_thing"
+        expect(Application.new("some thing").app_key).to eq("some_thing")
+        expect(Application.new("some-thing").app_key).to eq("some_thing")
+        expect(Application.new("some_thing").app_key).to eq("some_thing")
+        expect(Application.new("Some Thing").app_key).to eq("some_thing")
       end
 
       it "should raise an error if not valid" do
-        lambda {
+        expect {
           Application.new("")
-        }.should raise_error
+        }.to raise_error(RuntimeError, "Invalid application name")
 
-        lambda {
+        expect {
           Application.new(nil)
-        }.should raise_error
+        }.to raise_error(RuntimeError, "Invalid application name")
 
-        lambda {
+        expect {
           Application.new("/")
-        }.should raise_error
+        }.to raise_error(RuntimeError, "Invalid application name")
       end
     end
 
@@ -50,7 +50,7 @@ module QueueBus
         QueueBus.redis { |redis| redis.hset("bus_app:myapp", "old_one", "oldqueue_name") }
         app = Application.new("myapp")
         val = app.send(:read_redis_hash)
-        val.should == {"new_one" => {"queue_name" => "x", "bus_event_type" => "event_name"}, "old_one" => "oldqueue_name"}
+        expect(val).to eq({"new_one" => {"queue_name" => "x", "bus_event_type" => "event_name"}, "old_one" => "oldqueue_name"})
       end
     end
 
@@ -59,45 +59,45 @@ module QueueBus
       let(:sub2) { test_sub("event_two", "default") }
       let(:sub3) { test_sub("event_three", "other") }
       it "should add array to redis" do
-        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
         Application.new("myapp").subscribe(test_list(sub1, sub2))
 
-        QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }.should == {"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}",
-                                                                  "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"}
-        QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }.should =~ ["event_one", "event_two"]
-        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should =~ ["myapp"]
+        expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}",
+                                                                  "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"})
+        expect(QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }).to match_array(["event_one", "event_two"])
+        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to match_array(["myapp"])
       end
       it "should add string to redis" do
-        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
         Application.new("myapp").subscribe(test_list(sub1))
 
-        QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }.should == {"event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"}
-        QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }.should =~ ["event_one"]
-        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should =~ ["myapp"]
+        expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({"event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"})
+        expect(QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }).to match_array(["event_one"])
+        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to match_array(["myapp"])
       end
       it "should multiple queues to redis" do
-        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
         Application.new("myapp").subscribe(test_list(sub1, sub2, sub3))
-        QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }.should == {"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}", "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}",
-                                                                  "event_three"=>"{\"queue_name\":\"other\",\"key\":\"event_three\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_three\"}}"}
-        QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }.should =~ ["event_three", "event_two", "event_one"]
-        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should =~ ["myapp"]
+        expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}", "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}",
+                                                                  "event_three"=>"{\"queue_name\":\"other\",\"key\":\"event_three\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_three\"}}"})
+        expect(QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }).to match_array(["event_three", "event_two", "event_one"])
+        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to match_array(["myapp"])
       end
 
       it "should do nothing if nil or empty" do
 
-        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
 
         Application.new("myapp").subscribe(nil)
-        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
 
         Application.new("myapp").subscribe([])
-        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
       end
 
       it "should call unsubscribe" do
         app = Application.new("myapp")
-        app.should_receive(:unsubscribe)
+        expect(app).to receive(:unsubscribe)
         app.subscribe([])
       end
     end
@@ -110,42 +110,42 @@ module QueueBus
 
         Application.new("myapp").unsubscribe
 
-        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should == ["other"]
-        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to eq(["other"])
+        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
       end
     end
 
     describe "#subscription_matches" do
       it "should return if it is there" do
-        Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
 
         subs = test_list(test_sub("one_x"), test_sub("one_y"), test_sub("one"), test_sub("two"))
         Application.new("myapp").subscribe(subs)
-        Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
 
-        Application.new("myapp").subscription_matches("bus_event_type"=>"two").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "two", "default", "::QueueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one", "default", "::QueueBus::Rider"]]
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"two").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "two", "default", "::QueueBus::Rider"]])
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one", "default", "::QueueBus::Rider"]])
       end
 
       it "should handle * wildcards" do
         subs = test_list(test_sub("one.+"), test_sub("one"), test_sub("one_.*"), test_sub("two"))
         Application.new("myapp").subscribe(subs)
-        Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
 
-        Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one.+", "default", "::QueueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one", "default", "::QueueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one.+","default", "::QueueBus::Rider"], ["myapp", "one_.*", "default", "::QueueBus::Rider"]]
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one.+", "default", "::QueueBus::Rider"]])
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one", "default", "::QueueBus::Rider"]])
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one.+","default", "::QueueBus::Rider"], ["myapp", "one_.*", "default", "::QueueBus::Rider"]])
       end
 
       it "should handle actual regular expressions" do
         subs = test_list(test_sub(/one.+/), test_sub("one"), test_sub(/one_.*/), test_sub("two"))
         Application.new("myapp").subscribe(subs)
-        Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
 
-        Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"donex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one" ,"default", "::QueueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"], ["myapp", "(?-mix:one_.*)", "default", "::QueueBus::Rider"]]
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]])
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"donex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]])
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one" ,"default", "::QueueBus::Rider"]])
+        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"], ["myapp", "(?-mix:one_.*)", "default", "::QueueBus::Rider"]])
       end
     end
   end

data/spec/config_spec.rb

@@ -10,51 +10,51 @@ end
 
 describe "QueueBus config" do
   it "should set the default app key" do
-    QueueBus.default_app_key.should == nil
+    expect(QueueBus.default_app_key).to eq(nil)
 
     QueueBus.default_app_key = "my_app"
-    QueueBus.default_app_key.should == "my_app"
+    expect(QueueBus.default_app_key).to eq("my_app")
 
     QueueBus.default_app_key = "something here"
-    QueueBus.default_app_key.should == "something_here"
+    expect(QueueBus.default_app_key).to eq("something_here")
   end
 
   it "should set the default queue" do
-    QueueBus.default_queue.should == nil
+    expect(QueueBus.default_queue).to eq(nil)
 
     QueueBus.default_queue = "my_queue"
-    QueueBus.default_queue.should == "my_queue"
+    expect(QueueBus.default_queue).to eq("my_queue")
   end
 
   it "should set the local mode" do
-    QueueBus.local_mode.should == nil
+    expect(QueueBus.local_mode).to eq(nil)
     QueueBus.local_mode = :standalone
-    QueueBus.local_mode.should == :standalone
+    expect(QueueBus.local_mode).to eq(:standalone)
   end
 
   it "should set the hostname" do
-    QueueBus.hostname.should_not == nil
+    expect(QueueBus.hostname).not_to eq(nil)
     QueueBus.hostname = "whatever"
-    QueueBus.hostname.should == "whatever"
+    expect(QueueBus.hostname).to eq("whatever")
   end
 
   it "should set before_publish callback" do
     QueueBus.before_publish = lambda {|attributes| 42 }
-    QueueBus.before_publish_callback({}).should == 42
+    expect(QueueBus.before_publish_callback({})).to eq(42)
   end
 
 
   it "should use the default Redis connection" do
-    QueueBus.redis { |redis| redis }.should_not eq(nil)
+    expect(QueueBus.redis { |redis| redis }).not_to eq(nil)
   end
 
   it "should default to given adapter" do
-    QueueBus.adapter.is_a?(adapter_under_test_class).should == true
+    expect(QueueBus.adapter.is_a?(adapter_under_test_class)).to eq(true)
 
     # and should raise if already set
-    lambda {
+    expect {
       QueueBus.adapter = :data
-    }.should raise_error
+    }.to raise_error(RuntimeError, "Adapter already set to QueueBus::Adapters::Data")
   end
 
   context "with a fresh load" do
@@ -64,18 +64,18 @@ describe "QueueBus config" do
 
     it "should be able to be set to resque" do
       QueueBus.adapter = adapter_under_test_symbol
-      QueueBus.adapter.is_a?(adapter_under_test_class).should == true
+      expect(QueueBus.adapter.is_a?(adapter_under_test_class)).to eq(true)
 
       # and should raise if already set
-      lambda {
+      expect {
         QueueBus.adapter = :data
-      }.should raise_error
+      }.to raise_error(RuntimeError, "Adapter already set to QueueBus::Adapters::Data")
     end
 
     it "should be able to be set to something else" do
 
       QueueBus.adapter = :test_one
-      QueueBus.adapter.is_a?(QueueBus::Adapters::TestOne).should == true
+      expect(QueueBus.adapter.is_a?(QueueBus::Adapters::TestOne)).to eq(true)
     end
   end