multi_worker 0.1.0 → 0.2.0

data/spec/adapters/queue_classic_spec.rb

@@ -1,41 +1,41 @@
-exit if jruby?
-
-ENV["DATABASE_URL"] ||= "postgres:///queue_classic_test"
-require 'queue_classic'
-
-module QC
-  class Queue
-    def enqueue(method, *args)
-      klass = eval(method.split(".").first)
-      message = method.split(".").last
-      klass.send(message, *args)
-    end
-  end
-end
-
-require 'test_workers'
-
-describe TestWorker do
-  it_behaves_like "a worker"
-end
-
-describe MultiWorker do
-  context "when Queue Classic is loaded" do
-    it "defaults to the :queue_classic adapter" do
-      MultiWorker.default_adapter.should == :queue_classic
-    end
-  end
-
-  context "when using the :queue_classic adapter" do
-    it "performs the work using Queue Classic" do
-      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
-      TestWorker.perform_async("foo")
-      MultiWorker.enqueue(TestWorker, "foo")
-      TestWorker.perform("foo")
-    end
-
-    it "exposes the Queue Classic rake task" do
-      MultiWorker.adapter.rake_task.name.should == "qc:work"
-    end
-  end
+exit if jruby?
+
+ENV["DATABASE_URL"] ||= "postgres:///queue_classic_test"
+require 'queue_classic'
+
+module QC
+  class Queue
+    def enqueue(method, *args)
+      klass = eval(method.split(".").first)
+      message = method.split(".").last
+      klass.send(message, *args)
+    end
+  end
+end
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+end
+
+describe MultiWorker do
+  context "when Queue Classic is loaded" do
+    it "defaults to the :queue_classic adapter" do
+      expect(MultiWorker.default_adapter).to eq(:queue_classic)
+    end
+  end
+
+  context "when using the :queue_classic adapter" do
+    it "performs the work using Queue Classic" do
+      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.perform("foo")
+    end
+
+    it "exposes the Queue Classic rake task" do
+      expect(MultiWorker.adapter.rake_task.name).to eq("qc:work")
+    end
+  end
 end

data/spec/adapters/resque_spec.rb

@@ -1,74 +1,74 @@
-require 'resque'
-Resque.inline = true
-
-require 'test_workers'
-
-describe TestWorker do
-  it_behaves_like "a worker"
-end
-
-describe MultiWorker do
-  context "when Resque is loaded" do
-    it "defaults to the :resque adapter" do
-      MultiWorker.default_adapter.should == :resque
-    end
-  end
-
-  context "when using the :resque adapter" do
-    it "performs the work using Resque" do
-      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
-      TestWorker.perform_async("foo")
-      MultiWorker.enqueue(TestWorker, "foo")
-      TestWorker.perform("foo")
-    end
-
-    context "with advanced options" do
-      it "configures :retry option" do
-        retry_worker = Class.new do
-          worker :retry => {:limit => 10, :delay => 5 }
-        end
-
-        retry_worker.should be_a ::Resque::Plugins::Retry
-        retry_worker.instance_variable_get(:@retry_limit).should == 10
-        retry_worker.instance_variable_get(:@retry_delay).should == 5
-      end
-
-      it "configures :lock option" do
-        locking_worker = Class.new do
-          worker :lock => {:timeout => 5}
-        end
-
-        locking_worker.should be_a ::Resque::Plugins::LockTimeout
-        locking_worker.instance_variable_get(:@lock_timeout).should == 5
-      end
-
-      it "configures :unique option with :lock" do
-        unique_worker = Class.new do
-          worker :lock => true, :unique => true
-        end
-
-        unique_worker.instance_variable_get(:@loner).should be_true
-      end
-
-      it "configures :unique option without :lock" do
-        unique_worker = Class.new do
-          worker :unique => true
-        end
-
-        unique_worker.should include ::Resque::Plugins::UniqueJob
-      end
-
-      it "configures :status option" do
-        status_worker = Class.new do
-          worker :status => true
-        end
-
-        status_worker.should include ::Resque::Plugins::Status
-      end
-    end
-
-    it "exposes the Resque rake task" do
-      MultiWorker.adapter.rake_task.name.should == "resque:work"
-    end
-  end
+require 'resque'
+Resque.inline = true
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+end
+
+describe MultiWorker do
+  context "when Resque is loaded" do
+    it "defaults to the :resque adapter" do
+      expect(MultiWorker.default_adapter).to eq(:resque)
+    end
+  end
+
+  context "when using the :resque adapter" do
+    it "performs the work using Resque" do
+      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.perform("foo")
+    end
+
+    context "with advanced options" do
+      it "configures :retry option" do
+        retry_worker = Class.new do
+          worker retry: {limit: 10, delay: 5 }
+        end
+
+        expect(retry_worker).to be_a ::Resque::Plugins::Retry
+        expect(retry_worker.instance_variable_get(:@retry_limit)).to eq(10)
+        expect(retry_worker.instance_variable_get(:@retry_delay)).to eq(5)
+      end
+
+      it "configures :lock option" do
+        locking_worker = Class.new do
+          worker lock: {timeout: 5}
+        end
+
+        expect(locking_worker).to be_a ::Resque::Plugins::LockTimeout
+        expect(locking_worker.instance_variable_get(:@lock_timeout)).to eq(5)
+      end
+
+      it "configures :unique option with :lock" do
+        unique_worker = Class.new do
+          worker lock: true, unique: true
+        end
+
+        expect(unique_worker.instance_variable_get(:@loner)).to be_true
+      end
+
+      it "configures :unique option without :lock" do
+        unique_worker = Class.new do
+          worker unique: true
+        end
+
+        expect(unique_worker).to include ::Resque::Plugins::UniqueJob
+      end
+
+      it "configures :status option" do
+        status_worker = Class.new do
+          worker status: true
+        end
+
+        expect(status_worker).to include ::Resque::Plugins::Status
+      end
+    end
+
+    it "exposes the Resque rake task" do
+      expect(MultiWorker.adapter.rake_task.name).to eq("resque:work")
+    end
+  end
 end

data/spec/adapters/sidekiq_spec.rb

@@ -1,91 +1,91 @@
-require 'sidekiq'
-require 'sidekiq/testing'
-::Sidekiq::Testing.fake!
-
-require 'test_workers'
-
-describe TestWorker do
-  it_behaves_like "a worker"
-
-  it { should be_a ::Sidekiq::Worker }
-end
-
-describe MultiWorker do
-  context "when Sidekiq is loaded" do
-    it "defaults to the :sidekiq adapter" do
-      MultiWorker.default_adapter.should == :sidekiq
-    end
-  end
-
-  context "when using the :sidekiq adapter" do
-    it "performs the work using Sidekiq" do
-      TestWorker.perform_async("foo")
-      MultiWorker.enqueue(TestWorker, "foo")
-      TestWorker.jobs.size.should == 2
-    end
-
-    it "forwards ::perform to #perform" do
-      expect(TestWorker).to receive(:perform).once.with("foo")
-      TestWorker.perform("foo")
-    end
-
-    context "with advanced options" do
-      context "when configuring the :retry option" do
-        context "with a hash" do
-          it "configures limit and delay" do
-            retry_worker = Class.new do
-              worker :retry => {:limit => 10, :delay => lambda {|count| count*5} }
-            end
-
-            retry_worker.get_sidekiq_options['retry'].should == 10
-            retry_worker.sidekiq_retry_in_block.call(3).should == 15
-          end
-        end
-
-        context "with a number" do
-          it "configures limit" do
-            retry_worker = Class.new do
-              worker :retry => 15
-            end
-
-            retry_worker.get_sidekiq_options['retry'].should == 15
-          end
-        end
-
-        context "with a boolean" do
-          it "configures retry" do
-            retry_worker = Class.new do
-              worker :retry => true
-            end
-
-            retry_worker.get_sidekiq_options['retry'].should == true
-          end
-        end
-      end
-
-      it "configures :lock option" do
-        locking_worker = Class.new do
-          worker :lock => true
-        end
-
-        locking_worker.get_sidekiq_options['lock'].should == true
-      end
-
-      it "configures :unique option" do
-        unique_worker = Class.new do
-          worker :unique => true
-        end
-
-        unique_worker.get_sidekiq_options['unique'].should == true
-      end
-
-      it "configures :status option" do
-        status_worker = Class.new do
-          worker :status => true
-        end
-
-        status_worker.new.should be_a ::SidekiqStatus::Worker
-      end
-    end
-  end
+require 'sidekiq'
+require 'sidekiq/testing'
+::Sidekiq::Testing.fake!
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+
+  it { should be_a ::Sidekiq::Worker }
+end
+
+describe MultiWorker do
+  context "when Sidekiq is loaded" do
+    it "defaults to the :sidekiq adapter" do
+      expect(MultiWorker.default_adapter).to eq(:sidekiq)
+    end
+  end
+
+  context "when using the :sidekiq adapter" do
+    it "performs the work using Sidekiq" do
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      expect(TestWorker.jobs.size).to eq(2)
+    end
+
+    it "forwards ::perform to #perform" do
+      expect(TestWorker).to receive(:perform).once.with("foo")
+      TestWorker.perform("foo")
+    end
+
+    context "with advanced options" do
+      context "when configuring the :retry option" do
+        context "with a hash" do
+          it "configures limit and delay" do
+            retry_worker = Class.new do
+              worker retry: {limit: 10, delay: lambda {|count| count*5} }
+            end
+
+            expect(retry_worker.get_sidekiq_options['retry']).to eq(10)
+            expect(retry_worker.sidekiq_retry_in_block.call(3)).to eq(15)
+          end
+        end
+
+        context "with a number" do
+          it "configures limit" do
+            retry_worker = Class.new do
+              worker retry: 15
+            end
+
+            expect(retry_worker.get_sidekiq_options['retry']).to eq(15)
+          end
+        end
+
+        context "with a boolean" do
+          it "configures retry" do
+            retry_worker = Class.new do
+              worker retry: true
+            end
+
+            expect(retry_worker.get_sidekiq_options['retry']).to eq(true)
+          end
+        end
+      end
+
+      it "configures :lock option" do
+        locking_worker = Class.new do
+          worker lock: true
+        end
+
+        expect(locking_worker.get_sidekiq_options['lock']).to eq(true)
+      end
+
+      it "configures :unique option" do
+        unique_worker = Class.new do
+          worker unique: true
+        end
+
+        expect(unique_worker.get_sidekiq_options['unique']).to eq(true)
+      end
+
+      it "configures :status option" do
+        status_worker = Class.new do
+          worker status: true
+        end
+
+        expect(status_worker.new).to be_a ::SidekiqStatus::Worker
+      end
+    end
+  end
 end

data/spec/adapters/sneakers_spec.rb

@@ -1,36 +1,36 @@
-require 'sneakers'
-Sneakers.configure(:env => 'test')
-
-require 'test_workers'
-
-describe TestWorker do
-  it_behaves_like "a worker"
-
-  it { should be_a ::Sneakers::Worker }
-end
-
-describe MultiWorker do
-  context "when Sneakers is loaded" do
-    it "defaults to the :qu adapter" do
-      MultiWorker.default_adapter.should == :sneakers
-    end
-  end
-
-  context "when using the :sneakers adapter" do
-    let(:worker) { TestWorker.new }
-
-    context "when calling #perform_async" do
-      it "publishes a message to the queue" do
-        expect(::Sneakers).to receive(:publish).once
-        worker.perform_async("foo")
-      end
-    end
-
-    context "when Sneakers calls #work" do
-      it "calls #perform" do
-        expect(worker).to receive(:perform).once.with("foo")
-        worker.work(["foo"].to_json)
-      end
-    end
-  end
+require 'sneakers'
+Sneakers.configure(env: 'test')
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+
+  it { should be_a ::Sneakers::Worker }
+end
+
+describe MultiWorker do
+  context "when Sneakers is loaded" do
+    it "defaults to the :qu adapter" do
+      expect(MultiWorker.default_adapter).to eq(:sneakers)
+    end
+  end
+
+  context "when using the :sneakers adapter" do
+    let(:worker) { TestWorker.new }
+
+    context "when calling #perform_async" do
+      it "publishes a message to the queue" do
+        expect(::Sneakers).to receive(:publish).once
+        worker.perform_async("foo")
+      end
+    end
+
+    context "when Sneakers calls #work" do
+      it "calls #perform" do
+        expect(worker).to receive(:perform).once.with("foo")
+        worker.work(["foo"].to_json)
+      end
+    end
+  end
 end