sidekiq-bus 0.8.1 → 0.8.2

data/spec/subscription_list_spec.rb

@@ -1,43 +1,43 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe SubscriptionList do
-    describe ".from_redis" do
-      it "should return from attributes" do
-        mult = {"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"}}}
+    describe '.from_redis' do
+      it 'should return from attributes' do
+        mult = { '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' } } }
 
         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
     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
   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,31 +1,33 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Worker do
-    it "should proxy to given class" do
-      hash = {"bus_class_proxy" => "QueueBus::Driver", "ok" => true}
+    it 'should proxy 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 "should use instance" do
-      hash = {"bus_class_proxy" => "QueueBus::Rider", "ok" => true}
+    it 'should use 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 not freak out if class not there anymore" do
-      hash = {"bus_class_proxy" => "QueueBus::BadClass", "ok" => true}
+    it 'should not freak out if class not there anymore' do
+      hash = { 'bus_class_proxy' => 'QueueBus::BadClass', 'ok' => true }
 
       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}
-      expect(QueueBus::Rider).to receive(:perform).with(hash).and_raise("rider crash")
-      expect {
+    it 'should raise 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("rider crash")
+      end.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.8.1
+  version: 0.8.2
 platform: ruby
 authors:
 - Brian Leonard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-05 00:00:00.000000000 Z
+date: 2019-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: queue-bus