sidekiq-bus 0.5.10 → 0.6.0

data/spec/dispatch_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module QueueBus
   describe Dispatch do
     it "should not start with any applications" do
-      Dispatch.new("d").subscriptions.size.should == 0
+      expect(Dispatch.new("d").subscriptions.size).to eq(0)
     end
 
     it "should register code to run and execute it" do
@@ -12,16 +12,16 @@ module QueueBus
         Runner1.run(attrs)
       end
       sub = dispatch.subscriptions.key("my_event")
-      sub.send(:executor).is_a?(Proc).should == true
+      expect(sub.send(:executor).is_a?(Proc)).to eq(true)
 
-      Runner.value.should == 0
+      expect(Runner.value).to eq(0)
       dispatch.execute("my_event", {"bus_event_type" => "my_event", "ok" => true})
-      Runner1.value.should == 1
-      Runner1.attributes.should == {"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})
     end
 
     it "should not crash if not there" do
-      Dispatch.new("d").execute("fdkjh", "bus_event_type" => "fdkjh").should == nil
+      expect(Dispatch.new("d").execute("fdkjh", "bus_event_type" => "fdkjh")).to eq(nil)
     end
 
     describe "Top Level" do
@@ -46,24 +46,24 @@ module QueueBus
        end
 
       it "should register and run" do
-        Runner2.value.should == 0
+        expect(Runner2.value).to eq(0)
         QueueBus.dispatcher_execute("testit", "event2", "bus_event_type" => "event2")
-        Runner2.value.should == 1
+        expect(Runner2.value).to eq(1)
         QueueBus.dispatcher_execute("testit", "event1", "bus_event_type" => "event1")
-        Runner2.value.should == 2
+        expect(Runner2.value).to eq(2)
         QueueBus.dispatcher_execute("testit", "event1", "bus_event_type" => "event1")
-        Runner2.value.should == 3
+        expect(Runner2.value).to eq(3)
       end
 
       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]}
-        tuples.should =~ [  ["event1", "testit_default"],
+        expect(tuples).to match_array([  ["event1", "testit_default"],
                             ["event2", "testit_default"],
                             ["event3", "testit_high"],
                             [ "(?-mix:^patt.+ern)", "testit_low"]
-                         ]
+                         ])
       end
 
     end

data/spec/driver_spec.rb

@@ -16,21 +16,21 @@ module QueueBus
 
     describe ".subscription_matches" do
       it "return empty array when none" do
-        Driver.subscription_matches("bus_event_type" => "else").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
-        Driver.subscription_matches("bus_event_type" => "event").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
+        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
-        Driver.subscription_matches("bus_event_type" => "event1").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app1", "event1", "default", "::QueueBus::Rider"]]
-        Driver.subscription_matches("bus_event_type" => "event6").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event6", "default", "::QueueBus::Rider"]]
+        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
-        Driver.subscription_matches("bus_event_type" => "event2").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app1", "event2", "default", "::QueueBus::Rider"], ["app2", "event2", "other", "::QueueBus::Rider"]]
+        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
-        Driver.subscription_matches("bus_event_type" => "event4").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event[45]", "default", "::QueueBus::Rider"], ["app2", "event4", "more", "::QueueBus::Rider"]]
+        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
-        Driver.subscription_matches("bus_event_type" => "event5").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event[45]", "default", "::QueueBus::Rider"], ["app3", "event5", "default", "::QueueBus::Rider"]]
+        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
 
@@ -38,48 +38,48 @@ module QueueBus
       let(:attributes) { {"x" => "y"} }
 
       before(:each) do
-        QueueBus.redis { |redis| redis.smembers("queues") }.should == []
-        QueueBus.redis { |redis| redis.lpop("queue:app1_default") }.should be_nil
-        QueueBus.redis { |redis| redis.lpop("queue:app2_default") }.should be_nil
-        QueueBus.redis { |redis| redis.lpop("queue:app3_default") }.should 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"))
-        QueueBus.redis { |redis| redis.smembers("queues") }.should == []
+        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to eq([])
       end
 
       it "should queue up the riders in redis" do
-        QueueBus.redis { |redis| redis.lpop("queue:app1_default") }.should be_nil
+        expect(QueueBus.redis { |redis| redis.lpop("queue:app1_default") }).to be_nil
         Driver.perform(attributes.merge("bus_event_type" => "event1"))
-        QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default"]
+        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["default"])
 
         hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
-        hash["class"].should == "QueueBus::Worker"
-        hash["args"].size.should == 1
-        JSON.parse(hash["args"].first).should == {"bus_rider_app_key"=>"app1", "x" => "y", "bus_event_type" => "event1", "bus_rider_sub_key"=>"event1", "bus_rider_queue" => "default"}.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_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"))
-        QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default", "more"]
+        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["default", "more"])
 
         hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:more") })
-        hash["class"].should == "QueueBus::Worker"
-        hash["args"].size.should == 1
-        JSON.parse(hash["args"].first).should == {"bus_rider_app_key"=>"app2", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event4", "bus_rider_queue" => "more"}.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_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") })
-        hash["class"].should == "QueueBus::Worker"
-        hash["args"].size.should == 1
-        JSON.parse(hash["args"].first).should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.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_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"))
-        QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default"]
+        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["default"])
 
-        QueueBus.redis { |redis| redis.llen("queue:default") }.should == 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") })
@@ -98,11 +98,11 @@ module QueueBus
           args2 = pargs1
         end
 
-        hash1["class"].should == "QueueBus::Worker"
-        args1.should == {"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))
 
-        hash2["class"].should == "QueueBus::Worker"
-        args2.should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs)
+        expect(hash2["class"]).to eq("QueueBus::Worker")
+        expect(args2).to eq({"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs))
       end
     end
   end

data/spec/heartbeat_spec.rb

@@ -20,7 +20,7 @@ module QueueBus
     
     it "should publish the current time once" do
       Timecop.freeze "12/12/2013 12:01:19" do
-        QueueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
+        expect(QueueBus).to receive(:publish).with("heartbeat_minutes", now_attributes)
         Heartbeat.perform
       end
       
@@ -31,12 +31,12 @@ module QueueBus
     
     it "should publish a minute later" do
       Timecop.freeze "12/12/2013 12:01:19" do
-        QueueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
+        expect(QueueBus).to receive(:publish).with("heartbeat_minutes", now_attributes)
         Heartbeat.perform
       end
       
       Timecop.freeze "12/12/2013 12:02:01" do
-        QueueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
+        expect(QueueBus).to receive(:publish).with("heartbeat_minutes", now_attributes)
         Heartbeat.perform
       end
     end

data/spec/integration_spec.rb

@@ -6,15 +6,15 @@ module QueueBus
       write1 = Subscription.new("default", "key1", "MyClass1", {"bus_event_type" => "event_one"})
       write2 = Subscription.new("else_ok", "key2", "MyClass2", {"bus_event_type" => /^[ab]here/})  #regex
     
-      write1.matches?("bus_event_type" => "event_one").should  == true
-      write1.matches?("bus_event_type" => "event_one1").should == false
-      write1.matches?("bus_event_type" => "aevent_one").should == false
+      expect(write1.matches?("bus_event_type" => "event_one")).to  eq(true)
+      expect(write1.matches?("bus_event_type" => "event_one1")).to eq(false)
+      expect(write1.matches?("bus_event_type" => "aevent_one")).to eq(false)
       
-      write2.matches?("bus_event_type" => "ahere").should == true
-      write2.matches?("bus_event_type" => "bhere").should == true
-      write2.matches?("bus_event_type" => "qhere").should == false
-      write2.matches?("bus_event_type" => "abhere").should == false
-      write2.matches?("bus_event_type" => "[ab]here").should == false
+      expect(write2.matches?("bus_event_type" => "ahere")).to eq(true)
+      expect(write2.matches?("bus_event_type" => "bhere")).to eq(true)
+      expect(write2.matches?("bus_event_type" => "qhere")).to eq(false)
+      expect(write2.matches?("bus_event_type" => "abhere")).to eq(false)
+      expect(write2.matches?("bus_event_type" => "[ab]here")).to eq(false)
     
       write = SubscriptionList.new
       write.add(write1)
@@ -27,26 +27,26 @@ module QueueBus
       app = Application.new("test")
       read = app.send(:subscriptions)
     
-      read.size.should == 2
+      expect(read.size).to eq(2)
       read1 = read.key("key1")
       read2 = read.key("key2")
-      read1.should_not be_nil
-      read2.should_not be_nil
+      expect(read1).not_to be_nil
+      expect(read2).not_to be_nil
       
-      read1.queue_name.should == "default"
-      read1.class_name.should == "MyClass1"
-      read2.queue_name.should == "else_ok"
-      read2.class_name.should == "MyClass2"
+      expect(read1.queue_name).to eq("default")
+      expect(read1.class_name).to eq("MyClass1")
+      expect(read2.queue_name).to eq("else_ok")
+      expect(read2.class_name).to eq("MyClass2")
       
-      read1.matches?("bus_event_type" => "event_one").should  == true
-      read1.matches?("bus_event_type" => "event_one1").should == false
-      read1.matches?("bus_event_type" => "aevent_one").should == false
+      expect(read1.matches?("bus_event_type" => "event_one")).to  eq(true)
+      expect(read1.matches?("bus_event_type" => "event_one1")).to eq(false)
+      expect(read1.matches?("bus_event_type" => "aevent_one")).to eq(false)
       
-      read2.matches?("bus_event_type" => "ahere").should == true
-      read2.matches?("bus_event_type" => "bhere").should == true
-      read2.matches?("bus_event_type" => "qhere").should == false
-      read2.matches?("bus_event_type" => "abhere").should == false
-      read2.matches?("bus_event_type" => "[ab]here").should == false
+      expect(read2.matches?("bus_event_type" => "ahere")).to eq(true)
+      expect(read2.matches?("bus_event_type" => "bhere")).to eq(true)
+      expect(read2.matches?("bus_event_type" => "qhere")).to eq(false)
+      expect(read2.matches?("bus_event_type" => "abhere")).to eq(false)
+      expect(read2.matches?("bus_event_type" => "[ab]here")).to eq(false)
       
     end
   end

data/spec/matcher_spec.rb

@@ -4,140 +4,140 @@ module QueueBus
   describe Matcher do
     it "should already return false on empty filters" do
       matcher = Matcher.new({})
-      matcher.matches?({}).should  == false
-      matcher.matches?(nil).should  == false
-      matcher.matches?("name" => "val").should == false
+      expect(matcher.matches?({})).to  eq(false)
+      expect(matcher.matches?(nil)).to  eq(false)
+      expect(matcher.matches?("name" => "val")).to eq(false)
     end
 
     it "should not crash if nil inputs" do
       matcher = Matcher.new("name" => "val")
-      matcher.matches?(nil).should == false
+      expect(matcher.matches?(nil)).to eq(false)
     end
 
     it "string filter to/from redis" do
       matcher = Matcher.new("name" => "val")
-      matcher.matches?("name" => "val").should   == true
-      matcher.matches?("name" => " val").should  == false
-      matcher.matches?("name" => "zval").should  == false
+      expect(matcher.matches?("name" => "val")).to   eq(true)
+      expect(matcher.matches?("name" => " val")).to  eq(false)
+      expect(matcher.matches?("name" => "zval")).to  eq(false)
     end
 
     it "regex filter" do
       matcher = Matcher.new("name" => /^[cb]a+t/)
-      matcher.matches?("name" => "cat").should == true
-      matcher.matches?("name" => "bat").should == true
-      matcher.matches?("name" => "caaaaat").should == true
-      matcher.matches?("name" => "ct").should == false
-      matcher.matches?("name" => "bcat").should == false
+      expect(matcher.matches?("name" => "cat")).to eq(true)
+      expect(matcher.matches?("name" => "bat")).to eq(true)
+      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
+      expect(matcher.matches?("name" => "ct")).to eq(false)
+      expect(matcher.matches?("name" => "bcat")).to eq(false)
     end
 
     it "present filter" do
       matcher = Matcher.new("name" => :present)
-      matcher.matches?("name" => "").should == false
-      matcher.matches?("name" => "cat").should == true
-      matcher.matches?("name" => "bear").should == true
-      matcher.matches?("other" => "bear").should == false
+      expect(matcher.matches?("name" => "")).to eq(false)
+      expect(matcher.matches?("name" => "cat")).to eq(true)
+      expect(matcher.matches?("name" => "bear")).to eq(true)
+      expect(matcher.matches?("other" => "bear")).to eq(false)
     end
 
     it "blank filter" do
       matcher = Matcher.new("name" => :blank)
-      matcher.matches?("name" => nil).should == true
-      matcher.matches?("other" => "bear").should == true
-      matcher.matches?("name" => "").should == true
-      matcher.matches?("name" => "  ").should == true
-      matcher.matches?("name" => "bear").should == false
-      matcher.matches?("name" => "   s ").should == false
+      expect(matcher.matches?("name" => nil)).to eq(true)
+      expect(matcher.matches?("other" => "bear")).to eq(true)
+      expect(matcher.matches?("name" => "")).to eq(true)
+      expect(matcher.matches?("name" => "  ")).to eq(true)
+      expect(matcher.matches?("name" => "bear")).to eq(false)
+      expect(matcher.matches?("name" => "   s ")).to eq(false)
     end
 
     it "nil filter" do
       matcher = Matcher.new("name" => :nil)
-      matcher.matches?("name" => nil).should == true
-      matcher.matches?("other" => "bear").should == true
-      matcher.matches?("name" => "").should == false
-      matcher.matches?("name" => "  ").should == false
-      matcher.matches?("name" => "bear").should == false
+      expect(matcher.matches?("name" => nil)).to eq(true)
+      expect(matcher.matches?("other" => "bear")).to eq(true)
+      expect(matcher.matches?("name" => "")).to eq(false)
+      expect(matcher.matches?("name" => "  ")).to eq(false)
+      expect(matcher.matches?("name" => "bear")).to eq(false)
     end
 
     it "key filter" do
       matcher = Matcher.new("name" => :key)
-      matcher.matches?("name" => nil).should == true
-      matcher.matches?("other" => "bear").should == false
-      matcher.matches?("name" => "").should == true
-      matcher.matches?("name" => "  ").should == true
-      matcher.matches?("name" => "bear").should == true
+      expect(matcher.matches?("name" => nil)).to eq(true)
+      expect(matcher.matches?("other" => "bear")).to eq(false)
+      expect(matcher.matches?("name" => "")).to eq(true)
+      expect(matcher.matches?("name" => "  ")).to eq(true)
+      expect(matcher.matches?("name" => "bear")).to eq(true)
     end
 
     it "empty filter" do
       matcher = Matcher.new("name" => :empty)
-      matcher.matches?("name" => nil).should == false
-      matcher.matches?("other" => "bear").should == false
-      matcher.matches?("name" => "").should == true
-      matcher.matches?("name" => "  ").should == false
-      matcher.matches?("name" => "bear").should == false
-      matcher.matches?("name" => "   s ").should == false
+      expect(matcher.matches?("name" => nil)).to eq(false)
+      expect(matcher.matches?("other" => "bear")).to eq(false)
+      expect(matcher.matches?("name" => "")).to eq(true)
+      expect(matcher.matches?("name" => "  ")).to eq(false)
+      expect(matcher.matches?("name" => "bear")).to eq(false)
+      expect(matcher.matches?("name" => "   s ")).to eq(false)
     end
 
     it "value filter" do
       matcher = Matcher.new("name" => :value)
-      matcher.matches?("name" => nil).should == false
-      matcher.matches?("other" => "bear").should == false
-      matcher.matches?("name" => "").should == true
-      matcher.matches?("name" => "  ").should == true
-      matcher.matches?("name" => "bear").should == true
-      matcher.matches?("name" => "   s ").should == true
+      expect(matcher.matches?("name" => nil)).to eq(false)
+      expect(matcher.matches?("other" => "bear")).to eq(false)
+      expect(matcher.matches?("name" => "")).to eq(true)
+      expect(matcher.matches?("name" => "  ")).to eq(true)
+      expect(matcher.matches?("name" => "bear")).to eq(true)
+      expect(matcher.matches?("name" => "   s ")).to eq(true)
     end
 
     it "multiple filters" do
       matcher = Matcher.new("name" => /^[cb]a+t/, "state" => "sleeping")
-      matcher.matches?("state" => "sleeping", "name" => "cat").should  == true
-      matcher.matches?("state" => "awake", "name" => "cat").should     == false
-      matcher.matches?("state" => "sleeping", "name" => "bat").should  == true
-      matcher.matches?("state" => "sleeping", "name" => "bear").should == false
-      matcher.matches?("state" => "awake", "name" => "bear").should    == false
+      expect(matcher.matches?("state" => "sleeping", "name" => "cat")).to  eq(true)
+      expect(matcher.matches?("state" => "awake", "name" => "cat")).to     eq(false)
+      expect(matcher.matches?("state" => "sleeping", "name" => "bat")).to  eq(true)
+      expect(matcher.matches?("state" => "sleeping", "name" => "bear")).to eq(false)
+      expect(matcher.matches?("state" => "awake", "name" => "bear")).to    eq(false)
     end
 
     it "regex should go back and forth into redis" do
       matcher = Matcher.new("name" => /^[cb]a+t/)
-      matcher.matches?("name" => "cat").should == true
-      matcher.matches?("name" => "bat").should == true
-      matcher.matches?("name" => "caaaaat").should == true
-      matcher.matches?("name" => "ct").should == false
-      matcher.matches?("name" => "bcat").should == false
+      expect(matcher.matches?("name" => "cat")).to eq(true)
+      expect(matcher.matches?("name" => "bat")).to eq(true)
+      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
+      expect(matcher.matches?("name" => "ct")).to eq(false)
+      expect(matcher.matches?("name" => "bcat")).to eq(false)
 
       QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
       redis = QueueBus.redis { |redis| redis.get("temp1") }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      matcher.matches?("name" => "cat").should == true
-      matcher.matches?("name" => "bat").should == true
-      matcher.matches?("name" => "caaaaat").should == true
-      matcher.matches?("name" => "ct").should == false
-      matcher.matches?("name" => "bcat").should == false
+      expect(matcher.matches?("name" => "cat")).to eq(true)
+      expect(matcher.matches?("name" => "bat")).to eq(true)
+      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
+      expect(matcher.matches?("name" => "ct")).to eq(false)
+      expect(matcher.matches?("name" => "bcat")).to eq(false)
 
       QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
       redis = QueueBus.redis { |redis| redis.get("temp2") }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      matcher.matches?("name" => "cat").should == true
-      matcher.matches?("name" => "bat").should == true
-      matcher.matches?("name" => "caaaaat").should == true
-      matcher.matches?("name" => "ct").should == false
-      matcher.matches?("name" => "bcat").should == false
+      expect(matcher.matches?("name" => "cat")).to eq(true)
+      expect(matcher.matches?("name" => "bat")).to eq(true)
+      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
+      expect(matcher.matches?("name" => "ct")).to eq(false)
+      expect(matcher.matches?("name" => "bcat")).to eq(false)
     end
 
     it "special value should go back and forth into redis" do
       matcher = Matcher.new("name" => :blank)
-      matcher.matches?("name" => "cat").should == false
-      matcher.matches?("name" => "").should    == true
+      expect(matcher.matches?("name" => "cat")).to eq(false)
+      expect(matcher.matches?("name" => "")).to    eq(true)
 
       QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
       redis= QueueBus.redis { |redis| redis.get("temp1") }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      matcher.matches?("name" => "cat").should == false
-      matcher.matches?("name" => "").should    == true
+      expect(matcher.matches?("name" => "cat")).to eq(false)
+      expect(matcher.matches?("name" => "")).to    eq(true)
 
       QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
       redis= QueueBus.redis { |redis| redis.get("temp2") }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      matcher.matches?("name" => "cat").should == false
-      matcher.matches?("name" => "").should    == true
+      expect(matcher.matches?("name" => "cat")).to eq(false)
+      expect(matcher.matches?("name" => "")).to    eq(true)
     end
   end
 end