sidekiq-bus 0.5.10 → 0.6.0

data/spec/subscription_list_spec.rb

@@ -8,21 +8,21 @@ module QueueBus
                 "event_two" => {"class" => "MyClass", "queue_name" => "else",    "key" => "event_two", "matcher" => {"bus_event_type" => "event_two"}}}
 
         list = SubscriptionList.from_redis(mult)
-        list.size.should == 2
+        expect(list.size).to eq(2)
         one = list.key("event_one")
         two = list.key("event_two")
         
-        one.key.should == "event_one"
-        one.key.should == "event_one"
-        one.queue_name.should == "default"
-        one.class_name.should == "MyClass"
-        one.matcher.filters.should == {"bus_event_type" => "event_one"}
+        expect(one.key).to eq("event_one")
+        expect(one.key).to eq("event_one")
+        expect(one.queue_name).to eq("default")
+        expect(one.class_name).to eq("MyClass")
+        expect(one.matcher.filters).to eq({"bus_event_type" => "event_one"})
         
-        two.key.should == "event_two"
-        two.key.should == "event_two"
-        two.queue_name.should == "else"
-        two.class_name.should == "MyClass"
-        two.matcher.filters.should == {"bus_event_type" => "event_two"}
+        expect(two.key).to eq("event_two")
+        expect(two.key).to eq("event_two")
+        expect(two.queue_name).to eq("else")
+        expect(two.class_name).to eq("MyClass")
+        expect(two.matcher.filters).to eq({"bus_event_type" => "event_two"})
       end
     end
     
@@ -33,9 +33,9 @@ module QueueBus
         list.add(Subscription.new("else_ok", "key2", "MyClass", {"bus_event_type" => "event_two"}))
         
         hash = list.to_redis
-        hash.should == {  "key1" => {"queue_name" => "default", "key" => "key1", "class" => "MyClass", "matcher" => {"bus_event_type" => "event_one"}}, 
+        expect(hash).to eq({  "key1" => {"queue_name" => "default", "key" => "key1", "class" => "MyClass", "matcher" => {"bus_event_type" => "event_one"}}, 
                           "key2" => {"queue_name" => "else_ok", "key" => "key2", "class" => "MyClass", "matcher" => {"bus_event_type" => "event_two"}}
-                       }
+                       })
         
       end
     end

data/spec/subscription_spec.rb

@@ -3,27 +3,27 @@ require 'spec_helper'
 module QueueBus
   describe Subscription do
     it "should normalize the queue name" do
-      Subscription.new("test",  "my_event", "MyClass", {}, nil).queue_name.should == "test"
-      Subscription.new("tes t", "my_event", "MyClass", {}, nil).queue_name.should == "tes_t"
-      Subscription.new("t%s",   "my_event", "MyClass", {}, nil).queue_name.should == "t_s"
+      expect(Subscription.new("test",  "my_event", "MyClass", {}, nil).queue_name).to eq("test")
+      expect(Subscription.new("tes t", "my_event", "MyClass", {}, nil).queue_name).to eq("tes_t")
+      expect(Subscription.new("t%s",   "my_event", "MyClass", {}, nil).queue_name).to eq("t_s")
     end
     
     describe ".register" do
       it "should take in args from dispatcher" do
         executor = Proc.new { |attributes| }
         sub = Subscription.register("queue_name", "mykey", "MyClass", {"bus_event_type" => "my_event"}, executor)
-        sub.send(:executor).should == executor
-        sub.matcher.filters.should == {"bus_event_type" => "my_event"}
-        sub.queue_name.should == "queue_name"
-        sub.key.should == "mykey"
-        sub.class_name.should == "MyClass"
+        expect(sub.send(:executor)).to eq(executor)
+        expect(sub.matcher.filters).to eq({"bus_event_type" => "my_event"})
+        expect(sub.queue_name).to eq("queue_name")
+        expect(sub.key).to eq("mykey")
+        expect(sub.class_name).to eq("MyClass")
       end
     end
     
     describe "#execute!" do
       it "should call the executor with the attributes" do
         exec = Object.new
-        exec.should_receive(:call)
+        expect(exec).to receive(:call)
         
         sub = Subscription.new("x", "y", "ClassName", {}, exec)
         sub.execute!({"ok" => true})
@@ -33,19 +33,19 @@ module QueueBus
     describe "#to_redis" do
       it "should return what to store for this subscription" do
         sub = Subscription.new("queue_one", "xyz", "ClassName", {"bus_event_type" => "my_event"}, nil)
-        sub.to_redis.should == {"queue_name" => "queue_one", "key" => "xyz", "class" => "ClassName", "matcher" => {"bus_event_type" => "my_event"}}
+        expect(sub.to_redis).to eq({"queue_name" => "queue_one", "key" => "xyz", "class" => "ClassName", "matcher" => {"bus_event_type" => "my_event"}})
       end
     end
     
     describe "#matches?" do
       it "should do pattern stuff" do
-        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one"}).matches?("bus_event_type" => "one").should == true
-        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one"}).matches?("bus_event_type" => "onex").should == false
-        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "^one.*$"}).matches?("bus_event_type" => "onex").should == true
-        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one.*"}).matches?("bus_event_type" => "onex").should == true
-        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one.?"}).matches?("bus_event_type" => "onex").should == true
-        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one.?"}).matches?("bus_event_type" => "one").should == true
-        Subscription.new("x", "id", "ClassName", {"bus_event_type" => "\\"}).matches?("bus_event_type" => "one").should == false
+        expect(Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one"}).matches?("bus_event_type" => "one")).to eq(true)
+        expect(Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one"}).matches?("bus_event_type" => "onex")).to eq(false)
+        expect(Subscription.new("x", "id", "ClassName", {"bus_event_type" => "^one.*$"}).matches?("bus_event_type" => "onex")).to eq(true)
+        expect(Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one.*"}).matches?("bus_event_type" => "onex")).to eq(true)
+        expect(Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one.?"}).matches?("bus_event_type" => "onex")).to eq(true)
+        expect(Subscription.new("x", "id", "ClassName", {"bus_event_type" => "one.?"}).matches?("bus_event_type" => "one")).to eq(true)
+        expect(Subscription.new("x", "id", "ClassName", {"bus_event_type" => "\\"}).matches?("bus_event_type" => "one")).to eq(false)
       end
     end
     

data/spec/worker_spec.rb

@@ -4,28 +4,28 @@ module QueueBus
   describe Worker do
     it "should proxy to given class" do
       hash = {"bus_class_proxy" => "QueueBus::Driver", "ok" => true}
-      QueueBus::Driver.should_receive(:perform).with(hash)
+      expect(QueueBus::Driver).to receive(:perform).with(hash)
       QueueBus::Worker.perform(JSON.generate(hash))
     end
 
     it "should use instance" do
       hash = {"bus_class_proxy" => "QueueBus::Rider", "ok" => true}
-      QueueBus::Rider.should_receive(:perform).with(hash)
+      expect(QueueBus::Rider).to receive(:perform).with(hash)
       QueueBus::Worker.new.perform(JSON.generate(hash))
     end
 
     it "should not freak out if class not there anymore" do
       hash = {"bus_class_proxy" => "QueueBus::BadClass", "ok" => true}
 
-      QueueBus::Worker.perform(JSON.generate(hash)).should == nil
+      expect(QueueBus::Worker.perform(JSON.generate(hash))).to eq(nil)
     end
 
     it "should raise error if proxy raises error" do
       hash = {"bus_class_proxy" => "QueueBus::Rider", "ok" => true}
-      QueueBus::Rider.should_receive(:perform).with(hash).and_raise("rider crash")
-      lambda {
+      expect(QueueBus::Rider).to receive(:perform).with(hash).and_raise("rider crash")
+      expect {
         QueueBus::Worker.perform(JSON.generate(hash))
-      }.should raise_error("rider crash")
+      }.to raise_error("rider crash")
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-bus
 version: !ruby/object:Gem::Version
-  version: 0.5.10
+  version: 0.6.0
 platform: ruby
 authors:
 - Brian Leonard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-17 00:00:00.000000000 Z
+date: 2019-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: queue-bus
@@ -164,6 +164,7 @@ files:
 - spec/publish_spec.rb
 - spec/publisher_spec.rb
 - spec/rider_spec.rb
+- spec/sidekiq_bus_spec.rb
 - spec/spec_helper.rb
 - spec/subscriber_spec.rb
 - spec/subscription_list_spec.rb
@@ -206,6 +207,7 @@ test_files:
 - spec/publish_spec.rb
 - spec/publisher_spec.rb
 - spec/rider_spec.rb
+- spec/sidekiq_bus_spec.rb
 - spec/spec_helper.rb
 - spec/subscriber_spec.rb
 - spec/subscription_list_spec.rb