queue-bus 0.7.0 → 0.10.0

data/spec/subscription_list_spec.rb

@@ -1,52 +1,78 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe SubscriptionList do
-    describe ".from_redis" do
+    describe '.from_redis' do
       let(:mult) do
-        {"event_one" => {"class" => "MyClass", "queue_name" => "default", "key" => "event_one", "matcher" => {"bus_event_type" => "event_one"}},
-         "event_two" => {"class" => "MyClass", "queue_name" => "else",    "key" => "event_two", "matcher" => {"bus_event_type" => "event_two"}}}
+        { 'event_one' => { 'class' => 'MyClass', 'queue_name' => 'default', 'key' => 'event_one', 'matcher' => { 'bus_event_type' => 'event_one' } },
+          'event_two' => { 'class' => 'MyClass', 'queue_name' => 'else', 'key' => 'event_two', 'matcher' => { 'bus_event_type' => 'event_two' } } }
       end
 
-      it "should return from attributes" do
+      it 'should return from attributes' do
         list = SubscriptionList.from_redis(mult)
         expect(list.size).to eq(2)
-        one = list.key("event_one")
-        two = list.key("event_two")
-        
-        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"})
-        
-        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"})
+        one = list.key('event_one')
+        two = list.key('event_two')
+
+        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')
+
+        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"
+      it 'raises an error if a subscription key already exists' do
+        mult['event_two']['key'] = 'event_one'
 
         expect { SubscriptionList.from_redis(mult) }
           .to raise_error(RuntimeError)
       end
     end
-    
-    describe "#to_redis" do
-      it "should generate what to store" do
+
+    describe '#to_redis' do
+      it 'should generate what to store' do
         list = SubscriptionList.new
-        list.add(Subscription.new("default", "key1", "MyClass", {"bus_event_type" => "event_one"}))
-        list.add(Subscription.new("else_ok", "key2", "MyClass", {"bus_event_type" => "event_two"}))
-        
+        list.add(Subscription.new('default', 'key1', 'MyClass', 'bus_event_type' => 'event_one'))
+        list.add(Subscription.new('else_ok', 'key2', 'MyClass', 'bus_event_type' => 'event_two'))
+
         hash = list.to_redis
-        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"}}
-                       })
-        
+        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
+
+    context "when modifying the subscription" do
+      let(:list) { SubscriptionList.new }
+      let(:subscription_1) { Subscription.new("default", "key1", "MyClass", {"bus_event_type" => "event_one"}) }
+      let(:subscription_2) { Subscription.new("else_ok", "key2", "MyClass", {"bus_event_type" => "event_two"}) }
+
+      context "when adding subscriptions" do
+        it "adds the subscription successfully" do
+          list.add(subscription_1)
+          list.add(subscription_2)
+
+          expect(list.to_redis).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
+
+        it "errors if the subscription already exists" do
+          list.add(subscription_1)
+
+          expect { list.add(subscription_1) }.to raise_exception(RuntimeError, /Duplicate key/)
+        end
       end
     end
   end
-end
+end

data/spec/subscription_spec.rb

@@ -1,53 +1,54 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Subscription do
-    it "should normalize the queue name" do
-      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")
+    it 'should normalize the queue name' do
+      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)
+
+    describe '.register' do
+      it 'should take in args from dispatcher' do
+        executor = proc { |attributes| }
+        sub = Subscription.register('queue_name', 'mykey', 'MyClass', { 'bus_event_type' => 'my_event' }, executor)
         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")
+        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
+
+    describe '#execute!' do
+      it 'should call the executor with the attributes' do
         exec = Object.new
         expect(exec).to receive(:call)
-        
-        sub = Subscription.new("x", "y", "ClassName", {}, exec)
-        sub.execute!({"ok" => true})
+
+        sub = Subscription.new('x', 'y', 'ClassName', {}, exec)
+        sub.execute!('ok' => true)
       end
     end
-    
-    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)
-        expect(sub.to_redis).to eq({"queue_name" => "queue_one", "key" => "xyz", "class" => "ClassName", "matcher" => {"bus_event_type" => "my_event"}})
+
+    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)
+        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
-        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)
+
+    describe '#matches?' do
+      it 'should do pattern stuff' do
+        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
-    
   end
-end
+end

data/spec/worker_spec.rb

@@ -1,36 +1,38 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'json'
 
 describe QueueBus::Worker do
-  it "proxies to given class" do
-    hash = {"bus_class_proxy" => "QueueBus::Driver", "ok" => true}
+  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}
+  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 "does not freak out if class not there anymore" do
-    hash = {"bus_class_proxy" => "QueueBus::BadClass", "ok" => true}
-    expect {
+  it 'does not freak out if class not there anymore' do
+    hash = { 'bus_class_proxy' => 'QueueBus::BadClass', 'ok' => true }
+    expect do
       QueueBus::Worker.perform(JSON.generate(hash))
-    }.not_to raise_error
+    end.not_to 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 {
+  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 do
       QueueBus::Worker.perform(JSON.generate(hash))
-    }.to raise_error(RuntimeError, 'rider crash')
+    end.to raise_error(RuntimeError, 'rider crash')
   end
 
-  it "runs the middleware stack" do
-    hash = {"bus_class_proxy" => "QueueBus::Driver", "ok" => true}
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: queue-bus
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Brian Leonard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-24 00:00:00.000000000 Z
+date: 2020-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: json_pure
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: timecop
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: json_pure
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -102,6 +102,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - ".rbenv-version"
 - ".rspec"
@@ -173,8 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: queue-bus
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A simple event bus on top of background queues