sucker_punch 0.3.1 → 0.4

data/CHANGES.md

@@ -1,3 +1,29 @@
+0.4
+-----------
+- Prefer `workers` stat method over `size`
+- Update config to use `workers` instead of `size`
+
+old config:
+
+```Ruby
+# config/initializers/sucker_punch.rb
+
+SuckerPunch.config do
+  queue name: :log_queue, worker: LogWorker, size: 10
+end
+```
+
+new config:
+
+```Ruby
+# config/initializers/sucker_punch.rb
+
+SuckerPunch.config do
+  queue name: :log_queue, worker: LogWorker, workers: 10
+end
+```
+- Add testing library to stub out workers (see testing section in README)
+
 0.3.1
 -----------
 

data/README.md

@@ -23,20 +23,21 @@ Or install it yourself as:
 
 ## Configuration
 
-`config/initializers/sucker_punch.rb`
 
 ```Ruby
-  SuckerPunch.config do
-    queue name: :log_queue, worker: LogWorker, size: 10
-    queue name: :awesome_queue, worker: AwesomeWorker, size: 2
-  end
+# config/initializers/sucker_punch.rb
+
+SuckerPunch.config do
+  queue name: :log_queue, worker: LogWorker, workers: 10
+  queue name: :awesome_queue, worker: AwesomeWorker, workers: 2
+end
 ```
 
 ## Usage
 
-`app/workers/log_worker.rb`
-
 ```Ruby
+# app/workers/log_worker.rb
+
 class LogWorker
   include SuckerPunch::Worker
 
@@ -50,9 +51,10 @@ All workers should define an instance method `perform`, of which the job being q
 
 Workers interacting with `ActiveRecord` should take special precaution not to exhaust connections in the pool. This can be done with `ActiveRecord::Base.connection_pool.with_connection`, which ensures the connection is returned back to the pool when completed.
 
-`app/workers/awesome_worker.rb`
 
 ```Ruby
+# app/workers/awesome_worker.rb
+
 class AwesomeWorker
   include SuckerPunch::Worker
 
@@ -103,15 +105,70 @@ SuckerPunch::Queue[:log_queue].async.perform("login") # => nil
 ## Stats
 
 ```Ruby
-SuckerPunch::Queue[:log_queue].size # => 7
+SuckerPunch::Queue[:log_queue].workers # => 7
 SuckerPunch::Queue[:log_queue].busy_size # => 4
 SuckerPunch::Queue[:log_queue].idle_size # => 3
 ```
 
 ## Testing
 
-`spec/spec_helper.rb`
 ```Ruby
+# spec/spec_helper.rb
+require 'sucker_punch/testing'
+```
+
+Requiring this library completely stubs out the internals of Sucker Puncker, but will provide the necessary tools to confirm your jobs are being enqueucompletely stubs out the internals of Sucker Puncker, but will provide the necessary tools to confirm your jobs are being enqueued.
+
+```Ruby
+# spec/spec_helper.rb
+require 'sucker_punch/testing'
+
+RSpec.configure do |config|
+  config.after(:before) do
+    SuckerPunch.reset! # => Resets the queues and jobs in the queues before each test
+  end
+end
+
+# config/initializer/sucker_punch.rb
+SuckerPunch.config do
+  queue name: :email, worker: EmailWorker, workers: 2
+end
+
+# config/workers/email_worker.rb
+class EmailWorker
+  include SuckerPunch::Worker
+
+  def perform(email, user_id)
+    user = User.find(user_id)
+    UserMailer.send(email.to_sym, user)
+  end
+end
+
+# spec/models/user.rb
+class User < ActiveRecord::Base
+  def send_welcome_email
+    SuckerPunch::Queue.new(:email).async.perform(:welcome, self.id)
+  end
+end
+
+# spec/spec_helper.rb
+require 'sucker_punch/testing'
+
+# spec/models/user_spec.rb
+require 'spec_helper'
+
+describe User do
+  describe "#send_welcome_email" do
+    user = FactoryGirl.create(:user)
+    expect{
+      user.send_welcome_email
+     }.to change{ SuckerPunch::Queue.new(:email).jobs.size }.by(1)
+  end
+end
+```
+
+```Ruby
+# spec/spec_helper.rb
 require 'sucker_punch/testing/inline'
 ```
 
@@ -121,6 +178,34 @@ Requiring this library causes your workers to run everything inline. So a call t
 SuckerPunch::Queue[:log_queue].async.perform("login")
 ```
 
+## Troubleshooting
+
+When using Passenger or Unicorn, you should configure the queues within a block that runs after the child process is forked.
+
+```Ruby
+# config/unicorn.rb
+#
+# The following is only need if in your unicorn config
+# you set:
+# preload_app true
+after_fork do |server, worker|
+  SuckerPunch.config do
+    queue name: :log_queue, worker: LogWorker, workers: 10
+  end
+end
+```
+```Ruby
+# config/initializers/sucker_punch.rb
+#
+if defined?(PhusionPassenger)
+  PhusionPassenger.on_event(:starting_worker_process) do |forked|
+    SuckerPunch.config do
+      queue name: :log_queue, worker: LogWorker, workers: 10
+    end
+  end
+end
+```
+
 ## Gem Name
 
 ...is awesome. But I can't take credit for it. Thanks to [@jmazzi](https://twitter.com/jmazzi) for his superior naming skills. If you're looking for a name for something, he is the one to go to.

data/lib/sucker_punch.rb

@@ -15,11 +15,12 @@ module SuckerPunch
     raise MissingQueueName unless options[:name]
     raise MissingWorkerName unless options[:worker]
 
-    klass         = options.fetch(:worker)
+    klass = options.fetch(:worker)
     registry_name = options.fetch(:name)
-    size          = options.fetch(:size, nil)
+    workers = options.fetch(:workers, nil)
+    workers ||= options.fetch(:size, nil)
 
     q = Queue.new(registry_name)
-    q.register(klass, size)
+    q.register(klass, workers)
   end
-end
+end

data/lib/sucker_punch/queue.rb

@@ -18,8 +18,12 @@ module SuckerPunch
                                 end
     end
 
+    def workers
+      size
+    end
+
     def method_missing(method_name, *args, &block)
       Celluloid::Actor[name].send(method_name, *args, &block)
     end
   end
-end
+end

data/lib/sucker_punch/testing.rb

@@ -0,0 +1,44 @@
+module SuckerPunch
+  class << self
+    attr_accessor :queues
+
+    def reset!
+      self.queues = {}
+    end
+  end
+
+  SuckerPunch.reset!
+
+  class Queue
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      SuckerPunch.queues[name] ||= []
+    end
+
+    def self.[](name)
+      new(name)
+    end
+
+    def register(klass, size)
+      nil
+    end
+
+    def workers
+      raise "Not implemented"
+    end
+
+    def jobs
+      SuckerPunch.queues[@name]
+    end
+
+    def async
+      self
+    end
+
+    def method_missing(name, *args, &block)
+      SuckerPunch.queues[@name] << { method: name, args: Array(args) }
+    end
+  end
+end

data/lib/sucker_punch/version.rb

@@ -1,3 +1,3 @@
 module SuckerPunch
-  VERSION = "0.3.1"
+  VERSION = "0.4"
 end

data/spec/{queue_spec.rb → sucker_punch/queue_spec.rb}

@@ -15,7 +15,7 @@ describe SuckerPunch::Queue do
 
   describe "#register" do
     before(:each) do
-      SuckerPunch::Queue.new(:crazy_queue).register(FakeWorker, 7)
+      SuckerPunch::Queue.new(:crazy_queue).register(FakeWorker, 2)
     end
 
     it "turns the class into an actor" do
@@ -25,7 +25,14 @@ describe SuckerPunch::Queue do
     end
 
     it "sets worker size" do
-      Celluloid::Actor[:crazy_queue].size.should == 7
+      Celluloid::Actor[:crazy_queue].size.should == 2
+    end
+  end
+
+  describe "#workers" do
+    it "returns number of workers" do
+      SuckerPunch::Queue.new(:crazy_queue).register(FakeWorker, 2)
+      SuckerPunch::Queue.new(:crazy_queue).workers.should == 2
     end
   end
 
@@ -33,13 +40,13 @@ describe SuckerPunch::Queue do
     let(:queue) { SuckerPunch::Queue.new(:crazy_queue) }
 
     before(:each) do
-      SuckerPunch::Queue.new(:crazy_queue).register(FakeWorker, 7)
+      SuckerPunch::Queue.new(:crazy_queue).register(FakeWorker, 2)
     end
 
     it "sends messages to Actor" do
-      queue.size.should == 7
-      queue.idle_size.should == 7
+      queue.size.should == 2
+      queue.idle_size.should == 2
       queue.busy_size.should == 0
     end
   end
-end
+end

data/spec/{testing → sucker_punch/testing}/inline_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require_relative '../../lib/sucker_punch/testing/inline'
+require_relative '../../../lib/sucker_punch/testing/inline'
 
 class PatchedWorker
   include SuckerPunch::Worker
@@ -10,7 +10,7 @@ class PatchedWorker
 end
 SuckerPunch::Queue.new(:patched_queue).register(PatchedWorker, 2)
 
-describe "Testing" do
+describe "SuckerPunch Inline Testing" do
   let(:queue) { SuckerPunch::Queue.new(:patched_queue) }
 
   it "processes jobs inline" do

data/spec/sucker_punch/testing_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+class TestingWorker
+  include Celluloid
+
+  def perform(input)
+    input = "after"
+  end
+end
+
+SuckerPunch.config do
+  queue name: :queue, worker: TestingWorker
+end
+
+describe "SuckerPunch Testing" do
+  before :each do
+    require_relative '../../lib/sucker_punch/testing'
+    SuckerPunch.reset!
+  end
+
+  describe ".reset!" do
+    it "resets the queues to be empty" do
+      4.times { SuckerPunch::Queue.new(:queue).async.perform("before") }
+      SuckerPunch.reset!
+      queue = SuckerPunch::Queue.new(:queue)
+      expect(queue.jobs.count).to eq 0
+    end
+  end
+
+  describe Queue do
+    it "returns previous instance when queried again" do
+      queue = SuckerPunch::Queue.new(:queue)
+      queue.async.perform("before")
+      expect(SuckerPunch::Queue.new(:queue).jobs.count).to eq 1
+    end
+
+    describe ".[]" do
+      it "returns the queue instance" do
+        queue = SuckerPunch::Queue.new(:queue)
+        queue.async.perform("before")
+        expect(SuckerPunch::Queue[:queue].jobs.count).to eq 1
+      end
+    end
+
+    describe "#register" do
+      it "returns nil" do
+        queue = SuckerPunch::Queue.new(:queue)
+        expect(queue.register(TestingWorker, 3)).to eq nil
+      end
+    end
+
+    describe "#workers" do
+      it "raises an exception if called" do
+        queue = SuckerPunch::Queue.new(:queue)
+        expect{ queue.workers }.to raise_error "Not implemented"
+      end
+    end
+
+    describe "#jobs" do
+      it "returns an array of the jobs in the queue" do
+        queue = SuckerPunch::Queue.new(:queue)
+        queue.async.perform("before")
+        expect(queue.jobs).to eq [{ method: :perform, args: ["before"] }]
+      end
+
+      it "returns the number of jobs in the queue" do
+        queue = SuckerPunch::Queue.new(:queue)
+        4.times { queue.async.perform("before") }
+        expect(queue.jobs.count).to eq 4
+      end
+    end
+
+    describe "#async" do
+      it "returns self" do
+        queue = SuckerPunch::Queue.new(:queue)
+        expect(queue.async).to eq queue
+      end
+    end
+
+    describe "enqueueing a job" do
+      it "adds the job to the queue" do
+        queue = SuckerPunch::Queue.new(:queue)
+        queue.async.perform("before")
+        expect(queue.jobs).to eq [{ method: :perform, args: ["before"] }]
+      end
+    end
+  end
+end

data/spec/sucker_punch_spec.rb

@@ -9,10 +9,18 @@ describe SuckerPunch do
 
     context "properly configured" do
       it "registers the queue" do
-        SuckerPunch::Queue.any_instance.should_receive(:register).with(FakeWorker, 7)
+        SuckerPunch::Queue.any_instance.should_receive(:register).with(FakeWorker, 3)
 
         SuckerPunch.config do
-          queue name: :crazy_queue, worker: FakeWorker, size: 7
+          queue name: :crazy_queue, worker: FakeWorker, workers: 3
+        end
+      end
+
+      it "supports size for workers count" do
+        SuckerPunch::Queue.any_instance.should_receive(:register).with(FakeWorker, 3)
+
+        SuckerPunch.config do
+          queue name: :crazy_queue, worker: FakeWorker, size: 3
         end
       end
     end
@@ -38,4 +46,4 @@ describe SuckerPunch do
     end
 
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sucker_punch
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: '0.4'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-20 00:00:00.000000000 Z
+date: 2013-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -76,14 +76,16 @@ files:
 - lib/sucker_punch.rb
 - lib/sucker_punch/exceptions.rb
 - lib/sucker_punch/queue.rb
+- lib/sucker_punch/testing.rb
 - lib/sucker_punch/testing/inline.rb
 - lib/sucker_punch/version.rb
 - lib/sucker_punch/worker.rb
-- spec/queue_spec.rb
 - spec/spec_helper.rb
+- spec/sucker_punch/queue_spec.rb
+- spec/sucker_punch/testing/inline_spec.rb
+- spec/sucker_punch/testing_spec.rb
+- spec/sucker_punch/worker_spec.rb
 - spec/sucker_punch_spec.rb
-- spec/testing/inline_spec.rb
-- spec/worker_spec.rb
 - sucker_punch.gemspec
 homepage: https://github.com/brandonhilkert/sucker_punch
 licenses: []
@@ -111,8 +113,9 @@ specification_version: 3
 summary: Sucker Punch is a Ruby asynchronous processing using Celluloid, heavily influenced
   by Sidekiq and girl_friday.
 test_files:
-- spec/queue_spec.rb
 - spec/spec_helper.rb
+- spec/sucker_punch/queue_spec.rb
+- spec/sucker_punch/testing/inline_spec.rb
+- spec/sucker_punch/testing_spec.rb
+- spec/sucker_punch/worker_spec.rb
 - spec/sucker_punch_spec.rb
-- spec/testing/inline_spec.rb
-- spec/worker_spec.rb