queue-bus 0.5.9 → 0.6.0

data/spec/subscription_list_spec.rb

@@ -10,28 +10,28 @@ module QueueBus
 
       it "should return from attributes" do
         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
 
       it "raises an error if a subscription key already exists" do
         mult["event_two"]["key"] = "event_one"
 
-        lambda { SubscriptionList.from_redis(mult) }
-          .should raise_error(RuntimeError)
+        expect { SubscriptionList.from_redis(mult) }
+          .to raise_error(RuntimeError)
       end
     end
     
@@ -42,9 +42,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

@@ -1,32 +1,37 @@
 require 'spec_helper'
+require 'json'
 
-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)
-      QueueBus::Worker.perform(JSON.generate(hash))
-    end
+describe QueueBus::Worker do
+  it "proxies to given class" do
+    hash = {"bus_class_proxy" => "QueueBus::Driver", "ok" => true}
+    expect(QueueBus::Driver).to receive(:perform).with(hash)
+    QueueBus::Worker.perform(JSON.generate(hash))
+  end
+
+  it "uses an instance" do
+    hash = {"bus_class_proxy" => "QueueBus::Rider", "ok" => true}
+    expect(QueueBus::Rider).to receive(:perform).with(hash)
+    QueueBus::Worker.new.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)
-      QueueBus::Worker.new.perform(JSON.generate(hash))
-    end
+  it "does not freak out if class not there anymore" do
+    hash = {"bus_class_proxy" => "QueueBus::BadClass", "ok" => true}
+    expect {
+      QueueBus::Worker.perform(JSON.generate(hash))
+    }.not_to raise_error
+  end
 
-    it "should not freak out if class not there anymore" do
-      hash = {"bus_class_proxy" => "QueueBus::BadClass", "ok" => true}
-      lambda {
-        QueueBus::Worker.perform(JSON.generate(hash))
-      }.should_not raise_error
-    end
+  it "raises error if proxy raises error" do
+    hash = {"bus_class_proxy" => "QueueBus::Rider", "ok" => true}
+    expect(QueueBus::Rider).to receive(:perform).with(hash).and_raise("rider crash")
+    expect {
+      QueueBus::Worker.perform(JSON.generate(hash))
+    }.to raise_error(RuntimeError, 'rider crash')
+  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 {
-        QueueBus::Worker.perform(JSON.generate(hash))
-      }.should raise_error
-    end
+  it "runs the middleware stack" do
+    hash = {"bus_class_proxy" => "QueueBus::Driver", "ok" => true}
+    expect(QueueBus.worker_middleware_stack).to receive(:run).with(hash).and_yield
+    QueueBus::Worker.perform(JSON.generate(hash))
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: queue-bus
 version: !ruby/object:Gem::Version
-  version: 0.5.9
+  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-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -92,6 +92,7 @@ files:
 - ".rbenv-version"
 - ".rspec"
 - ".rvmrc"
+- CHANGELOG.md
 - Gemfile
 - MIT-LICENSE
 - README.mdown
@@ -107,6 +108,7 @@ files:
 - lib/queue_bus/heartbeat.rb
 - lib/queue_bus/local.rb
 - lib/queue_bus/matcher.rb
+- lib/queue_bus/middleware.rb
 - lib/queue_bus/publisher.rb
 - lib/queue_bus/publishing.rb
 - lib/queue_bus/rider.rb
@@ -129,6 +131,7 @@ files:
 - spec/heartbeat_spec.rb
 - spec/integration_spec.rb
 - spec/matcher_spec.rb
+- spec/middleware_spec.rb
 - spec/publish_spec.rb
 - spec/publisher_spec.rb
 - spec/rider_spec.rb
@@ -156,7 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: queue-bus
-rubygems_version: 2.5.2
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A simple event bus on top of background queues
@@ -171,6 +174,7 @@ test_files:
 - spec/heartbeat_spec.rb
 - spec/integration_spec.rb
 - spec/matcher_spec.rb
+- spec/middleware_spec.rb
 - spec/publish_spec.rb
 - spec/publisher_spec.rb
 - spec/rider_spec.rb