em-jack 0.1.3 → 0.1.4

data/.gitignore

@@ -0,0 +1,5 @@
+doc
+pkg
+*.gem
+Gemfile.lock
+.rvmrc

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+require 'bundler/setup'
+require 'bundler/gem_helper'
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.verbose = false
+end

data/bin/shell

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+$:.unshift("lib")
+
+require 'rubygems'
+require 'eventmachine'
+require 'em-jack'
+require 'pp'
+
+$stdout.sync = true
+
+class KeyboardHandler < EM::Connection
+  include EM::Protocols::LineText2
+
+  def post_init
+    @jack = EMJack::Connection.new
+    @jack.on_error { |err| puts "ERROR: #{err}" }
+
+    print "> "
+  end
+
+  def receive_line(line)
+    line.chomp!
+    line.gsub!(/^\s+/, '')
+
+    df = case(line)
+    when /^\s*$/ then
+      # noop
+      nil
+
+    when /^use / then
+      tube = line.gsub(/use /, '')
+      @jack.use(tube) { |tube| puts "Using #{tube}" }
+
+    when /^watch / then
+      tube = line.gsub(/watch /, '')
+      @jack.watch(tube) { |tube| puts "Watching #{tube}" }
+
+    when /^ignore / then
+      tube = line.gsub(/ignore /, '')
+      @jack.ignore(tube) { |tube| puts "Ignoring #{tube}" }
+
+    when /^put / then
+      msg = line.gsub(/put /, '')
+      @jack.put(msg) { |id| puts "Inserted job #{id}" }
+
+    when /^delete / then
+      id = line.gsub(/delete /, '').to_i
+      job = EMJack::Job.new(@jack, id, "asdf")
+      job.delete { puts "Deleted" }
+
+    when 'reserve' then
+      @jack.reserve { |job| puts "Reserved #{job}" }
+
+    when 'list-tubes' then
+      @jack.list { |tubes| pp tubes }
+
+    when 'list-watched' then
+      @jack.list(:watched) { |tubes| pp tubes }
+
+    when 'list-used' then
+      @jack.list(:used) { |tube| puts "Using #{tube}" }
+
+    when /^peek\s+(\d+)\s*$/ then
+      @jack.peek($1) { |job| puts "Peeked: #{job}" }
+
+    when 'peek-ready' then
+      @jack.peek(:ready) { |job| puts "Peeked ready: #{job}"}
+
+    when 'peek-delayed' then
+      @jack.peek(:delayed) { |job| puts "Peeked delayed: #{job}" }
+
+    when 'peek-buried' then
+      @jack.peek(:buried) { |job| puts "Peeked buried: #{job}" }
+
+    when 'stats' then
+      @jack.stats { |stats| pp stats }
+
+    when /^stats-tube\s+(.*)$/ then
+      @jack.stats(:tube, $1) { |stats| pp stats }
+
+    when /^stats-job\s+(\d+)/ then
+      j = EMJack::Job.new(@jack, $1, "blah")
+      j.stats { |stats| pp stats }
+
+    when 'help' then
+      msg = "COMMANDS:\n"
+      msg << "  put <msg>    - put message onto beanstalk\n"
+      msg << "  reserve      - reserve a job on beanstalk\n"
+      msg << "  delete <id>  - delete message with ID <id>\n"
+      msg << "\n"
+      msg << "  use <tube>   - use tube for messages\n"
+      msg << "  watch <tube> - add <tube to watch list for messages\n"
+      msg << "\n"
+      msg << "  stats        - display beanstalk stats\n"
+      msg << "  stats-tube <tube> - display tube stats\n"
+      msg << "  stats-job <id> - display job stats\n"
+      msg << "\n"
+      msg << "  list-tubes   - display beanstalk tubes\n"
+      msg << "  list-used    - display the currently used tube\n"
+      msg << "  list-watched - display the currently watched tubes\n"
+      msg << "\n"
+      msg << "  peek <id>    - peek at job with ID <id>\n"
+      msg << "  peek-ready   - peek at the first job in the ready queue\n"
+      msg << "  peek-delayed - peek at the delayed job with shortest delay\n"
+      msg << "  peek-buried  - peek at the next buried job\n"
+      msg << "\n"
+      msg << "  help         - this help text\n"
+      msg << "  quit         - quit application\n"
+
+      puts msg
+      nil
+
+    when 'quit' then
+      EM.stop_event_loop
+      nil
+    end
+
+    unless df.nil?
+      df.callback { print "> " }
+      df.errback { print "> " }
+    end
+
+    print "> "
+  end
+end
+
+EM.run do
+  EM.open_keyboard(KeyboardHandler)
+end

data/em-jack.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$:.unshift(lib) unless $:.include?(lib)
+
+require 'em-jack/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'em-jack'
+  s.version     = EMJack::VERSION
+  s.authors     = ['Dan Sinclair']
+  s.email       = ['dj2@everburning.com']
+  s.homepage    = 'https://github.com/dj2/em-jack/'
+  s.summary     = 'An evented Beanstalk client'
+  s.description = 'An evented Beanstalk client'
+
+  s.required_rubygems_version = '>= 1.3.6'
+
+  s.add_dependency 'eventmachine', ['>= 0.12.10']
+
+  s.add_development_dependency 'bundler', ['~> 1.0.13']
+  s.add_development_dependency 'rake',    ['>= 0.8.7']
+  s.add_development_dependency 'rspec',   ['~> 2.6']
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- {spec}/*`.split("\n")
+  s.require_path = ['lib']
+end

data/lib/em-jack.rb

@@ -4,13 +4,11 @@ require 'em-jack/job'
 require 'em-jack/errors'
 require 'em-jack/beanstalk_connection'
 require 'em-jack/connection'
+require 'em-jack/version'
 
 Dir["#{File.dirname(__FILE__)}/em-jack/handlers/*.rb"].each do |file|
   require file
 end
 
 module EMJack
-  module VERSION
-    STRING = '0.1.3'
-  end
 end

data/lib/em-jack/connection.rb

@@ -1,5 +1,6 @@
 require 'eventmachine'
 require 'yaml'
+require 'uri'
 
 module EMJack
   class Connection
@@ -21,15 +22,24 @@ module EMJack
     end
 
     def initialize(opts = {})
-      @host = opts[:host] || 'localhost'
-      @port = opts[:port] || 11300
-      @tube = opts[:tube]
+      case opts
+      when Hash
+        @host = opts[:host] || 'localhost'
+        @port = opts[:port] || 11300
+        @tube = opts[:tube]
+      when String
+        uri = URI.parse(opts)
+        @host = uri.host || 'localhost'
+        @port = uri.port || 11300
+        @tube = uri.path.gsub(/^\//, '') # Kill the leading /
+      end
 
       reset_tube_state
 
       @data = ""
       @retries = 0
       @in_reserve = false
+      @fiberized = false
 
       @conn = EM::connect(host, port, EMJack::BeanstalkConnection) do |conn|
         conn.client = self
@@ -42,7 +52,7 @@ module EMJack
     end
 
     def reset_tube_state
-      prev_used = @used_tube 
+      prev_used = @used_tube
       prev_watched = @watched_tubes.dup if @watched_tubes
 
       @used_tube = 'default'
@@ -53,16 +63,15 @@ module EMJack
     end
 
     def fiber!
-      eigen = (class << self
-       self
-      end)
+      @fiberized = true
+
+      eigen = (class << self; self; end)
       eigen.instance_eval do
         %w(use reserve ignore watch peek stats list delete touch bury kick pause release put).each do |meth|
           alias_method :"a#{meth}", meth.to_sym
           define_method(meth.to_sym) do |*args|
             fib = Fiber.current
             ameth = :"a#{meth}"
-            p [ameth, *args]
             proc = lambda { |*result| fib.resume(*result) }
             send(ameth, *args, &proc)
             Fiber.yield
@@ -219,16 +228,26 @@ module EMJack
     end
 
     def each_job(timeout = nil, &blk)
-      work = Proc.new do
-        r = reserve(timeout)
-        r.callback do |job|
-          blk.call(job)
-          EM.next_tick { work.call }
+      if (@fiberized)
+        work = Proc.new do
+          Fiber.new do
+            job = reserve(timeout)
+            blk.call(job)
+          end.resume
+          EM.next_tick { work.call }          
         end
-        r.errback do
-          EM.next_tick { work.call }
+      else
+        work = Proc.new do
+          r = reserve(timeout)
+          r.callback do |job|
+            blk.call(job)
+            EM.next_tick { work.call }
+          end
+          r.errback do
+            EM.next_tick { work.call }
+          end
         end
-      end
+      end      
       work.call
     end
 
@@ -236,9 +255,12 @@ module EMJack
       @reconnect_proc = nil
       @retries = 0
       succeed
+      @connected = true
+      @connected_callback.call if @connected_callback
     end
 
     def disconnected
+      @connected = false
       d = @deferrables.dup
 
       ## if reconnecting, need to fail ourself to remove any callbacks
@@ -256,18 +278,26 @@ module EMJack
       end
 
       prev_used, prev_watched = reset_tube_state
-      @reconnect_proc = Proc.new { reconnect(prev_used, prev_watched) } unless @reconnect_proc
+      unless @reconnect_proc
+        recon = Proc.new { reconnect(prev_used, prev_watched) }
+        if @fiberized
+          @reconnect_proc = Proc.new { Fiber.new { recon.call }.resume }
+        else
+          @reconnect_proc = recon
+        end
+      end
 
       @retries += 1
       EM.add_timer(5) { @reconnect_proc.call }
     end
-   
+
     def reconnect(prev_used, prev_watched)
       @conn.reconnect(@host, @port)
 
       use(prev_used) if prev_used
-      [ prev_watched ].flatten.compact.each do |tube|
-        watch(tube)
+
+      [prev_watched].flatten.compact.each do |tube|
+        @fiberized ? awatch(tube) : watch(tube)
       end
     end
 
@@ -275,7 +305,6 @@ module EMJack
       @retries = 0
 
       prev_used, prev_watched = reset_tube_state
-
       EM.next_tick { reconnect(prev_used, prev_watched) }
     end
 
@@ -294,11 +323,19 @@ module EMJack
     def on_error(&blk)
       @error_callback = blk
     end
-    
+
     def on_disconnect(&blk)
       @disconnected_callback = blk
     end
 
+    def on_connect(&blk)
+      @connected_callback = blk
+    end
+
+    def connected?
+      @connected
+    end
+
     def received(data)
       @data << data
 

data/lib/em-jack/version.rb

@@ -0,0 +1,3 @@
+module EMJack
+  VERSION = '0.1.4'
+end

data/spec/em-jack/connection_spec.rb

@@ -0,0 +1,589 @@
+require 'spec_helper'
+
+describe EMJack::Connection do
+  let(:conn) do
+    conn = EMJack::Connection.new
+    conn.connected
+    conn
+  end
+
+  let(:connection_mock) do
+    connection_mock = mock(:conn)
+    connection_mock
+  end
+
+  before(:each) do
+    EM.stub!(:connect).and_return(connection_mock)
+  end
+
+  describe "uri connection string" do
+    let(:conn) do
+      EMJack::Connection.new('beanstalk://leet:1337/leetube')
+    end
+
+    it "should parse host" do
+      conn.host.should eql('leet')
+    end
+
+    it "should parse tube" do
+      connection_mock.should_receive(:send).once.with(:use, "leetube")
+      connection_mock.should_receive(:send).once.with(:watch, "leetube")
+      conn.connected
+    end
+
+    it "should parse port" do
+      conn.port.should eql(1337)
+    end
+  end
+
+  describe 'defaults' do
+    it 'host of "localhost"' do
+      conn.host.should == 'localhost'
+    end
+
+    it 'port of 11300' do
+      conn.port.should == 11300
+    end
+
+    it 'watch and use to provided tube on connect' do
+      connection_mock.should_receive(:send).once.with(:use, "mytube")
+      connection_mock.should_receive(:send).once.with(:watch, "mytube")
+      conn = EMJack::Connection.new(:tube => "mytube")
+      conn.connected
+    end
+
+  end
+
+  describe 'sending commands' do
+    it "doesn't send the command until we've connected" do
+      conn = EMJack::Connection.new
+      conn.should_not_receive(:send)
+      conn.use("mytube")
+    end
+
+    it "sends commands after we've connected" do
+      connected = false
+
+      connection_mock.should_receive(:send).twice do
+        connected.should be_true
+      end
+
+      conn = EMJack::Connection.new
+      conn.use('mytube')
+      conn.watch('mytube')
+
+      connected = true
+      conn.connected
+    end
+
+    it 'the "use" command' do
+      connection_mock.should_receive(:send).once.with(:use, "mytube")
+      conn.use("mytube")
+    end
+
+    it "doesn't send the use command to the currently used tube" do
+      connection_mock.should_receive(:send).once.with(:use, "mytube")
+      conn.use("mytube")
+      conn.use("mytube")
+    end
+
+    it 'the "watch" command' do
+      connection_mock.should_receive(:send).once.with(:watch, "mytube")
+      conn.watch("mytube")
+    end
+
+    it "doesn't send the watch command for a tube currently watched" do
+      connection_mock.should_not_receive(:send)
+      conn.instance_variable_get("@watched_tubes").push("mytube")
+      conn.watch("mytube")
+    end
+
+    describe "'put' command" do
+      it 'basic' do
+        msg = "my message"
+        connection_mock.should_receive(:send_with_data).once.
+                          with(:put, msg, anything, anything, anything, msg.length)
+        conn.put(msg)
+      end
+
+      it 'defaults the delay, priority and ttr settings' do
+        connection_mock.should_receive(:send_with_data).once.
+                          with(:put, anything, 65536, 0, 300, anything)
+        conn.put("msg")
+      end
+
+      it 'accepts a delay setting' do
+        connection_mock.should_receive(:send_with_data).once.
+                          with(:put, anything, anything, 42, anything, anything)
+        conn.put("msg", :delay => 42)
+      end
+
+      it 'accepts a ttr setting' do
+        connection_mock.should_receive(:send_with_data).once.
+                          with(:put, anything, anything, anything, 999, anything)
+        conn.put("msg", :ttr => 999)
+      end
+
+      it 'accepts a priority setting' do
+        connection_mock.should_receive(:send_with_data).once.
+                          with(:put, anything, 233, anything, anything, anything)
+        conn.put("msg", :priority => 233)
+      end
+
+      it 'accepts a priority, delay and ttr setting' do
+        connection_mock.should_receive(:send_with_data).once.
+                          with(:put, anything, 99, 42, 2000, anything)
+        conn.put("msg", :priority => 99, :delay => 42, :ttr => 2000)
+      end
+
+      it 'forces delay to be >= 0' do
+        connection_mock.should_receive(:send_with_data).once.
+                          with(:put, anything, anything, 0, anything, anything)
+        conn.put("msg", :delay => -42)
+      end
+
+      it 'forces ttr to be >= 0' do
+        connection_mock.should_receive(:send_with_data).once.
+                          with(:put, anything, anything, anything, 300, anything)
+        conn.put("msg", :ttr => -42)
+      end
+
+      it 'forces priority to be >= 0' do
+        connection_mock.should_receive(:send_with_data).once.
+                          with(:put, anything, 65536, anything, anything, anything)
+        conn.put("msg", :priority => -42)
+      end
+
+      it 'forces priority to be < 2**32' do
+        connection_mock.should_receive(:send_with_data).once.
+                          with(:put, anything, (2 ** 32), anything, anything, anything)
+        conn.put("msg", :priority => (2 ** 32 + 1))
+      end
+
+      it 'handles a non-string provided as the put message' do
+        msg = 22
+        connection_mock.should_receive(:send_with_data).once.
+                          with(:put, msg.to_s, anything, anything, anything, msg.to_s.length)
+        conn.put(msg)
+      end
+    end
+
+    it 'the "delete" command' do
+      connection_mock.should_receive(:send).once.with(:delete, 1)
+      job = EMJack::Job.new(nil, 1, "body")
+      conn.delete(job)
+    end
+
+    it 'the "touch" command' do
+      connection_mock.should_receive(:send).once.with(:touch, 1)
+      job = EMJack::Job.new(nil, 1, "body")
+      conn.touch(job)
+    end
+
+    it 'the "kick" command' do
+      connection_mock.should_receive(:send).once.with(:kick, 15)
+      conn.kick(15)
+    end
+
+    it 'the "kick" command defaults to 1' do
+      connection_mock.should_receive(:send).once.with(:kick, 1)
+      conn.kick
+    end
+
+    it 'the "pause-tube" command' do
+      connection_mock.should_receive(:send).once.with(:'pause-tube', 60)
+      conn.pause('mytube', 60)
+    end
+
+    it 'the "bury" command' do
+      connection_mock.should_receive(:send).once.with(:'bury', 1, 1234)
+      job = EMJack::Job.new(nil, 1, "body")
+      conn.bury(job, 1234)
+    end
+
+    it 'handles a nil job sent to the "delete" command' do
+      connection_mock.should_not_receive(:send).with(:delete, nil)
+      conn.delete(nil)
+    end
+
+    it 'the "reserve" command' do
+      connection_mock.should_receive(:send).with(:reserve)
+      conn.reserve
+    end
+
+    describe 'stats' do
+      it 'default' do
+        connection_mock.should_receive(:send).once.with(:stats)
+        conn.stats
+      end
+
+      it 'job' do
+        job = EMJack::Job.new(nil, 42, "blah")
+
+        connection_mock.should_receive(:send).once.with(:'stats-job', 42)
+        conn.stats(:job, job)
+      end
+
+      it 'tube' do
+        connection_mock.should_receive(:send).once.with(:'stats-tube', "mytube")
+        conn.stats(:tube, "mytube")
+      end
+
+      it 'throws exception on invalid param' do
+        connection_mock.should_not_receive(:send)
+        lambda { conn.stats(:blah) }.should raise_error(EMJack::InvalidCommand)
+      end
+    end
+
+    describe 'list' do
+      it 'default' do
+        connection_mock.should_receive(:send).once.with(:'list-tubes')
+        conn.list
+      end
+
+      it 'tube used' do
+        connection_mock.should_receive(:send).once.with(:'list-tube-used')
+        conn.list(:used)
+      end
+
+      it 'tubes watched' do
+        connection_mock.should_receive(:send).once.with(:'list-tubes-watched')
+        conn.list(:watched)
+      end
+
+      it 'throws exception on invalid param' do
+        connection_mock.should_not_receive(:send)
+        lambda { conn.list(:blah) }.should raise_error(EMJack::InvalidCommand)
+      end
+    end
+
+    describe 'peek' do
+      it 'with a job id' do
+        connection_mock.should_receive(:send).once.with(:'peek', 42)
+        conn.peek(42)
+      end
+
+      it 'ready' do
+        connection_mock.should_receive(:send).once.with(:'peek-ready')
+        conn.peek(:ready)
+      end
+
+      it 'delayed' do
+        connection_mock.should_receive(:send).once.with(:'peek-delayed')
+        conn.peek(:delayed)
+      end
+
+      it 'buried' do
+        connection_mock.should_receive(:send).once.with(:'peek-buried')
+        conn.peek(:buried)
+      end
+
+      it 'throws exception on invalid param' do
+        connection_mock.should_not_receive(:send)
+        lambda { conn.peek(:blah) }.should raise_error(EMJack::InvalidCommand)
+      end
+    end
+  end
+
+  describe 'reconnect' do
+    let (:blk) do
+      Proc.new { "my proc" }
+    end
+
+    context 'on disconnect' do
+      before(:each) do
+        EM.should_receive(:add_timer).exactly(1).times.and_yield
+        connection_mock.as_null_object
+      end
+  
+      it 'reuses a used tube' do
+        conn.should_receive(:use).with('used')
+        conn.instance_variable_set(:@used_tube, 'used')
+        conn.disconnected
+      end
+
+      it 'reuses a used tube' do
+        conn.should_receive(:use).with('default')
+        conn.disconnected
+      end
+
+      it 'rewatches a watched tube' do
+        conn.should_receive(:watch).with('watched')
+        conn.instance_variable_set(:@watched_tubes, ['watched'])
+        conn.disconnected
+      end
+
+      it 'rewatches multiple watched tubes' do
+        tubes = ['watched0', 'watched1']
+
+        conn.should_receive(:watch).twice do |tube|
+          tubes.delete(tube).should be_true
+        end
+
+        conn.instance_variable_set(:@watched_tubes, tubes)
+        conn.disconnected
+      end
+
+      it 'rewatches and reuses previous tubes on disconnect' do
+        conn.should_receive(:use).with('used')
+        conn.should_receive(:watch).with('watched')
+
+        conn.instance_variable_set(:@used_tube, 'used')
+        conn.instance_variable_set(:@watched_tubes, ['watched'])
+        conn.disconnected
+      end
+    end
+
+    it 'watches and uses previous tubes on disconnect' do
+      conn.should_receive(:watch).with('other')
+      connection_mock.as_null_object
+
+      EM.should_receive(:add_timer).exactly(1).times.and_yield
+      conn.instance_variable_set(:@watched_tubes, ['other'])
+      conn.disconnected
+    end
+
+    it 'raises exception if it fails more then RETRY_COUNT times' do
+      EM.should_receive(:add_timer).exactly(5).times
+
+      5.times { conn.disconnected }
+      lambda { conn.disconnected }.should raise_error(EMJack::Disconnected)
+    end
+
+    it 'resets the retry count on connection' do
+      EM.should_receive(:add_timer).at_least(1).times
+
+      5.times { conn.disconnected }
+      conn.connected
+      lambda { conn.disconnected }.should_not raise_error(EMJack::Disconnected)
+    end
+
+    it 'handles deferrables added during the fail phase' do
+      EM.stub!(:add_timer)
+
+      count = 0
+      blk = Proc.new do
+        count += 1
+        if count < 2
+          df = conn.add_deferrable
+          df.errback { blk.call }
+        end
+      end
+
+      df = conn.add_deferrable
+      df.errback { blk.call }
+
+      conn.disconnected
+      count.should == 1
+    end
+  end
+
+  describe 'beanstalk responses' do
+    let(:df) do
+      conn.add_deferrable
+    end
+
+    %w(OUT_OF_MEMORY INTERNAL_ERROR DRAINING BAD_FORMAT
+       UNKNOWN_COMMAND EXPECTED_CRLF JOB_TOO_BIG DEADLINE_SOON
+       TIMED_OUT NOT_FOUND).each do |cmd|
+      it "#{cmd} messages" do
+         df.should_receive(:fail).with(cmd.downcase.to_sym)
+         conn.received("#{cmd}\r\n")
+       end
+    end
+
+    ['buried', 'paused', 'touched', 'deleted'].each do |type|
+      it "#{type} messages" do
+        df.should_receive(:succeed)
+        conn.received("#{type.upcase}\r\n")
+      end
+    end
+
+    it 'inserted messages' do
+      df.should_receive(:succeed).with(40)
+      conn.received("INSERTED 40\r\n")
+    end
+
+    it 'buried messages' do
+      df.should_receive(:fail).with(:buried, 40)
+      conn.received("BURIED 40\r\n")
+    end
+
+    it 'kicked messages' do
+      df.should_receive(:succeed).with(15)
+      conn.received("KICKED 15\r\n")
+    end
+
+    it 'using messages' do
+      df.should_receive(:succeed).with("mytube")
+      conn.received("USING mytube\r\n")
+    end
+
+    it 'watching messages' do
+      df.should_receive(:succeed).with(24)
+      conn.received("WATCHING 24\r\n")
+    end
+
+    ['reserved', 'found'].each do |type|
+      it "#{type} messages" do
+        msg = "This is my message"
+
+        df.should_receive(:succeed).with do |job|
+          job.class.should == EMJack::Job
+          job.jobid.should == 42
+          job.body.should == msg
+        end
+
+        conn.received("#{type.upcase} 42 #{msg.length}\r\n#{msg}\r\n")
+      end
+    end
+
+    it 'OK messages' do
+      msg =<<-HERE
+---
+current-jobs-urgent: 42
+current-jobs-ready: 92
+current-jobs-reserved: 18
+current-jobs-delayed: 7
+current-jobs-buried: 0
+pid: 416
+version: dev
+HERE
+
+      df.should_receive(:succeed).with do |stats|
+        stats['current-jobs-urgent'].should == 42
+        stats['current-jobs-ready'].should == 92
+        stats['current-jobs-reserved'].should == 18
+        stats['current-jobs-delayed'].should == 7
+        stats['current-jobs-buried'].should == 0
+        stats['pid'].should == 416
+        stats['version'].should == 'dev'
+      end
+
+      conn.received("OK #{msg.length}\r\n#{msg}\r\n")
+    end
+
+    it 'receiving multiple replies in one packet' do
+      df.should_receive(:succeed).with(24)
+
+      df2 = conn.add_deferrable
+      df2.should_receive(:succeed).with("mytube")
+
+      conn.received("WATCHING 24\r\nUSING mytube\r\n")
+    end
+
+    it 'recieving multiple replies in one packet where first is STATS and second is DEADLINE_SOON (anti regression)' do
+      df.should_receive(:succeed).with do |stats|
+        stats['id'].should == 2
+      end
+
+      df2 = conn.add_deferrable
+      df2.should_receive(:fail).with(:deadline_soon)
+
+      conn.received("OK 142\r\n---\nid: 2\ntube: default\nstate: reserved\npri: 65536\nage: 2\ndelay: 0\nttr: 3\ntime-left: 0\nreserves: 1\ntimeouts: 0\nreleases: 0\nburies: 0\nkicks: 0\n\r\nDEADLINE_SOON\r\n")
+    end
+
+    it 'receiving data in chunks' do
+      msg1 = "First half of the message\r\n"
+      msg2 = "Last half of the message"
+
+      df.should_receive(:succeed).with do |job|
+        job.body.should == "#{msg1}#{msg2}"
+      end
+
+      conn.received("RESERVED 9 #{(msg1 + msg2).length}\r\n#{msg1}")
+      conn.received("#{msg2}\r\n")
+    end
+
+    it 'receiving a response broken over multiple packets' do
+      msg1 = "First half of the message\r\n"
+      msg2 = "Last half of the message"
+
+      df.should_receive(:succeed).with do |job|
+        job.body.should == "#{msg1}#{msg2}"
+      end
+
+      conn.received("RESERVED 9 ")
+      conn.received("#{(msg1 + msg2).length}")
+      conn.received("\r\n#{msg1}#{msg2}\r\n")
+    end
+
+    it 'the \r\n in a separate packet' do
+      msg1 = "First half of the message\r\n"
+      msg2 = "Last half of the message"
+
+      df.should_receive(:succeed).with do |job|
+        job.body.should == "#{msg1}#{msg2}"
+      end
+
+      conn.received("RESERVED 9 #{(msg1 + msg2).length}\r\n#{msg1}#{msg2}")
+      conn.received("\r\n")
+    end
+  end
+
+  context 'passed blocks' do
+    def callbacks(df)
+      df.instance_variable_get("@callbacks")
+    end
+
+    let (:blk) do
+      Proc.new { "my proc" }
+    end
+
+    describe 'uses #send' do
+      before(:each) do
+        connection_mock.should_receive(:send)
+      end
+
+      it 'use should set the callback when provided a block' do
+        df = conn.use('test', &blk)
+        callbacks(df).include?(blk).should be_true
+      end
+
+      it 'watch should set the callback when provided a block' do
+        df = conn.watch('blarg', &blk)
+        callbacks(df).include?(blk).should be_true
+      end
+
+      it 'ignore should set the callback when provided a block' do
+        conn.instance_variable_get("@watched_tubes").push('blarg')
+        df = conn.ignore('blarg', &blk)
+        callbacks(df).include?(blk).should be_true
+      end
+
+      it 'reserve should set the callback when provided a block' do
+        df = conn.reserve(&blk)
+        callbacks(df).include?(blk).should be_true
+      end
+
+      it 'stats should set the callback when provided a block' do
+        df = conn.stats(&blk)
+        callbacks(df).include?(blk).should be_true
+      end
+
+      it 'list should set the callback when provided a block' do
+        df = conn.list(&blk)
+        callbacks(df).include?(blk).should be_true
+      end
+
+      it 'delete should set the callback when provided a block' do
+        job = EMJack::Job.new(nil, 1, "body")
+        df = conn.delete(job, &blk)
+        callbacks(df).include?(blk).should be_true
+      end
+
+      it 'release should set the callback when provided a block' do
+        job = EMJack::Job.new(nil, 1, "body")
+        df = conn.release(job, &blk)
+        callbacks(df).include?(blk).should be_true
+      end
+    end
+
+    it 'put should set the callback when provided a block' do
+      connection_mock.should_receive(:send_with_data)
+
+      df = conn.put("asdf", nil, &blk)
+      callbacks(df).include?(blk).should be_true
+    end
+  end
+end

data/spec/em-jack/fiber_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+if RUBY_VERSION > '1.9'
+  require 'fiber'
+
+  describe EMJack::Connection do
+    it "should process live messages" do
+      EM.run do
+        EM.add_timer(10) { EM.stop }
+
+        Fiber.new do
+          bean = EMJack::Connection.new
+          bean.fiber!
+
+          bean.put("hello!")
+          job = bean.reserve
+          job.body.should == "hello!"
+          job.delete
+
+          EM.stop
+        end.resume
+      end
+    end
+    it "should process each job" do
+      EM.run do
+        EM.add_timer(10) { EM.stop }
+        
+        job_body = ''
+        
+        f = Fiber.new do
+          bean = EMJack::Connection.new
+          bean.fiber!
+        
+          bean.put("hello!")
+          bean.put("bonjour!")   
+          
+          mock = double()
+          mock.should_receive(:foo).with("hello!")
+          mock.should_receive(:foo).with("bonjour!")
+          
+          bean.each_job(0) do |job|
+            mock.foo(job.body)
+            job_body = job.body
+            job.delete
+          end
+          
+        end
+        
+        f.resume
+        
+        EM.add_timer(1) { EM.stop unless f.alive?; job_body.should eq "bonjour!" unless f.alive? }
+        
+      end
+    end
+  end
+end

data/spec/em-jack/job_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe EMJack::Job do
+  let (:conn ) { mock(:conn) }
+
+  it 'converts jobid to an integer' do
+    j = EMJack::Job.new(nil, "1", "body")
+    j.jobid.class.should == Fixnum
+    j.jobid.should == 1
+  end
+
+  it 'sends a delete command to the connection' do
+    j = EMJack::Job.new(conn, 1, "body")
+    conn.should_receive(:delete).with(j)
+
+    j.delete
+  end
+
+  it 'sends a stats command to the connection' do
+    j = EMJack::Job.new(conn, 2, 'body')
+    conn.should_receive(:stats).with(:job, j)
+
+    j.stats
+  end
+
+  it 'sends a release command to the connection' do
+    blk = Proc.new { x = 1 }
+
+    j = EMJack::Job.new(conn, 2, 'body')
+    conn.should_receive(:release).with(j, {:foo => :bar}, &blk)
+
+    j.release({:foo => :bar}, &blk)
+  end
+
+  it 'sends a touch command to the connection' do
+    j = EMJack::Job.new(conn, 2, 'body')
+    conn.should_receive(:touch).with(j)
+
+    j.touch
+  end
+
+  it 'sends a bury command to the connection' do
+    j = EMJack::Job.new(conn, 2, 'body')
+    conn.should_receive(:bury).with(j, 1234)
+
+    j.bury(1234)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'em-jack'
+
+RSpec.configure do |config|
+end

metadata

@@ -1,103 +1,123 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: em-jack
-version: !ruby/object:Gem::Version 
-  hash: 29
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 3
-  version: 0.1.3
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+  prerelease: 
 platform: ruby
-authors: 
-- dan sinclair
+authors:
+- Dan Sinclair
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-12-01 00:00:00 -05:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: eventmachine
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70242395661740 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.12.10
   type: :runtime
-  version_requirements: *id001
-description: An evented Beanstalk client.
-email: dj2@everburning.com
+  prerelease: false
+  version_requirements: *70242395661740
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70242395661260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.13
+  type: :development
+  prerelease: false
+  version_requirements: *70242395661260
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70242395660620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: *70242395660620
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70242395660100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *70242395660100
+description: An evented Beanstalk client
+email:
+- dj2@everburning.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README.rdoc
-files: 
-- README.rdoc
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
 - COPYING
+- Gemfile
+- README.rdoc
+- Rakefile
+- bin/shell
+- em-jack.gemspec
 - lib/em-jack.rb
 - lib/em-jack/beanstalk_connection.rb
 - lib/em-jack/connection.rb
 - lib/em-jack/errors.rb
-- lib/em-jack/job.rb
 - lib/em-jack/handlers/buried.rb
+- lib/em-jack/handlers/deleted.rb
+- lib/em-jack/handlers/errors.rb
 - lib/em-jack/handlers/inserted.rb
+- lib/em-jack/handlers/kicked.rb
 - lib/em-jack/handlers/not_ignored.rb
 - lib/em-jack/handlers/ok.rb
+- lib/em-jack/handlers/paused.rb
 - lib/em-jack/handlers/released.rb
 - lib/em-jack/handlers/reserved.rb
+- lib/em-jack/handlers/touched.rb
 - lib/em-jack/handlers/using.rb
 - lib/em-jack/handlers/watching.rb
-- lib/em-jack/handlers/deleted.rb
-- lib/em-jack/handlers/errors.rb
-- lib/em-jack/handlers/paused.rb
-- lib/em-jack/handlers/touched.rb
-- lib/em-jack/handlers/kicked.rb
-has_rdoc: true
-homepage: http://github.com/dj2/em-jack/
+- lib/em-jack/job.rb
+- lib/em-jack/version.rb
+- spec/em-jack/connection_spec.rb
+- spec/em-jack/fiber_spec.rb
+- spec/em-jack/job_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dj2/em-jack/
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --title
-- EM-Jack Documentation
-- --main
-- README.rdoc
-- --line-numbers
-require_paths: 
-- lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+rdoc_options: []
+require_paths:
+- - lib
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: -3983606337964967417
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: An evented Beanstalk client.
+summary: An evented Beanstalk client
 test_files: []
-