sidekiq-bus 0.5.10 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7489c0d0c8039c603f60784f1da9229dc7b738ef
-  data.tar.gz: 411beaacbb95dbff057c75b489938858f92cd3c1
+  metadata.gz: 63c03ac9abef7e30948f4e1cc83d499251853846
+  data.tar.gz: ac25e298ce8dab9160026a2bdd8c5eaba099198b
 SHA512:
-  metadata.gz: aa5c04a124802c488ee1427727353fbf3257d534e45dcd027afd6964fd07d42fe88f558dc5d9ff46b4e0ed308f09d15bab8444bb45f78befc3e4c89b10775124
-  data.tar.gz: 01516f2ffb2e18cf7a9f704000debb019f6f20fc16796df6c3ac0b368c44ee774094ea91bbcba6f7085b4ff5e2bed9773eb6c7b45075766b2f412398245a0abe
+  metadata.gz: 8fa90c9f87a6e27c8a9a29c0d5823460874fb37c99812addaca062788aed32b9cb769f9997006d9c671f4adfbc9e4400e8b0a9d80810b22c79d797eca4f58c85
+  data.tar.gz: 39cd967a17827ec6c8c7f0b0a8a767db802b33e32fe6bbfe2508e67f52a1a1e3471e97c17ceb0d0d46b25e398f2d56c2c54a1dadb4e7cf83ce17e4c1792f42cb

data/README.mdown

@@ -11,7 +11,6 @@ To install, include the 'sidekiq-bus' gem and add the following to your Rakefile
 require "sidekiq_bus/tasks"
 ```
 
-
 ### Example
 
 Application A can publish an event
@@ -108,6 +107,29 @@ end
 
 Note: This subscribes when this class is loaded, so it needs to be in your load or otherwise referenced/required during app initialization to work properly.
 
+### sidekiq.rb
+
+To make sure that your sidekiq server is consuming on the proper queues, add code like
+this to your `config/sidekiq.rb` file:
+
+```ruby
+# config/sidekiq.rb
+
+# Load the environment here
+require './boot.rb'
+
+if Sidekiq.server?
+  # Load the queues into sidekiq:
+  weights = {
+    'app_events'    => 10,
+    'app_heartbeat' => 3,
+    'app_refresh'   => 1
+  }
+  Sidekiq.options[:queues] =
+    SidekiqBus.generate_weighted_queues(overrides: weights, default: 2)
+end
+```
+
 ### Commands
 
 Each app needs to tell Redis about its subscriptions:

data/lib/sidekiq-bus.rb

@@ -1,6 +1,46 @@
-require "queue-bus"
-require "sidekiq_bus/adapter"
-require "sidekiq_bus/version"
+# frozen_string_literal: true
+
+require 'queue-bus'
+require 'sidekiq_bus/adapter'
+require 'sidekiq_bus/version'
 require 'sidekiq_bus/middleware/retry'
 
 QueueBus.adapter = QueueBus::Adapters::Sidekiq.new
+
+module SidekiqBus
+  # This method will analyze the current queues and generate an array that
+  # can operate as the sidekiq queues configuration. It should be based on how
+  # The sidekiq CLI builds weighted queues.
+  #
+  # @param overrides [Hash<String, Integer>] A mapping of queue names and
+  #     weights that must be included
+  # @param default [Integer] The default weight to apply to any given queue
+  # @returns [Array<String>] The set of queue names weighted to sidekiq
+  def self.generate_weighted_queues(overrides: {}, default: 1)
+    # Gathers all queues and overrides as strictly strings
+    queues = Set.new(QueueBus::TaskManager.new(false).queue_names.map(&:to_s))
+    overrides = overrides.each_with_object({}) { |(q, w), h| h[q.to_s] = w }
+    overrides.default = default
+
+    # Also pitches-in for driving the bus.
+    queues << 'bus_incoming'
+
+    # Make sure every queue from the overrides is included
+    queues += overrides.keys
+
+    entry = Struct.new(:queue, :weight)
+
+    # Map all queue names to their weights and returns them as entries
+    entries = queues.map { |q| entry.new(q, [1, overrides[q]].max) }
+
+    # Sorts by weight to provide a visual indication of queue order in sidekiq
+    # UI. Otherwise they can appear in various orders. They will be sorted
+    # from greatest to least weight. The negative sign on the weight is key to
+    # making this work.
+    entries = entries.sort_by { |e| [-e.weight, e.queue] }
+
+    # Creates an array of N length with the same queue name (N=weight) then
+    # flattened into a single array
+    entries.flat_map { |e| Array.new(e.weight, e.queue) }
+  end
+end

data/lib/sidekiq_bus/version.rb

@@ -1,3 +1,3 @@
 module SidekiqBus
-  VERSION = "0.5.10"
+  VERSION = "0.6.0"
 end

data/spec/adapter/integration_spec.rb

@@ -19,26 +19,26 @@ describe "Sidekiq Integration" do
 
     it "should publish and receive" do
       Sidekiq::Testing.fake!
-      QueueBus::Runner1.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(0)
 
       QueueBus.publish("event_name", "ok" => true)
-      QueueBus::Runner1.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(0)
 
       QueueBus::Worker.perform_one
 
-      QueueBus::Runner1.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(0)
 
       QueueBus::Worker.perform_one
 
-      QueueBus::Runner1.value.should == 1
+      expect(QueueBus::Runner1.value).to eq(1)
     end
 
     it "should publish and receive" do
       Sidekiq::Testing.inline!
-      QueueBus::Runner1.value.should == 0
+      expect(QueueBus::Runner1.value).to eq(0)
 
       QueueBus.publish("event_name", "ok" => true)
-      QueueBus::Runner1.value.should == 1
+      expect(QueueBus::Runner1.value).to eq(1)
     end
 
   end
@@ -46,7 +46,7 @@ describe "Sidekiq Integration" do
   describe "Delayed Publishing" 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
@@ -69,10 +69,10 @@ describe "Sidekiq Integration" do
 
       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")
     end
 
     it "should move it to the real queue when processing" do
@@ -80,12 +80,12 @@ describe "Sidekiq Integration" do
       event_name = "event_name"
 
       val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
-      val.should == nil
+      expect(val).to eq(nil)
 
       QueueBus.publish_at(future, event_name, hash)
 
       val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
-      val.should == nil # nothing really added
+      expect(val).to eq(nil) # nothing really added
 
       if Sidekiq::VERSION < '4'
         Sidekiq::Scheduled::Poller.new.poll
@@ -94,7 +94,7 @@ describe "Sidekiq Integration" do
       end
 
       val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
-      val.should == nil # nothing added yet
+      expect(val).to eq(nil) # nothing added yet
 
       # process scheduler in future
       Timecop.freeze(worktime) do
@@ -106,17 +106,17 @@ describe "Sidekiq Integration" do
 
         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::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_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::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs))
 
        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("Invalid application name")
+        }.to raise_error("Invalid application name")
 
-        lambda {
+        expect {
           Application.new(nil)
-        }.should raise_error("Invalid application name")
+        }.to raise_error("Invalid application name")
 
-        lambda {
+        expect {
           Application.new("/")
-        }.should raise_error("Invalid application name")
+        }.to raise_error("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("Adapter already set to QueueBus::Adapters::Sidekiq")
+    }.to raise_error("Adapter already set to QueueBus::Adapters::Sidekiq")
   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("Adapter already set to QueueBus::Adapters::Sidekiq")
+      }.to raise_error("Adapter already set to QueueBus::Adapters::Sidekiq")
     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