beaneater 1.1.4 → 1.2.0

data/test/jobs_test.rb

@@ -106,4 +106,433 @@ describe Beaneater::Jobs do
       assert_equal 1, @beanstalk.tubes.find('tube_buried').stats.current_jobs_buried
     end
   end # for_process!
+
+  describe "for process! with a dashed tube name" do
+    before do
+      $ran = []
+      cleanup_tubes!(['email-jobs', 'tube_stop'])
+      @jobs.register('email-jobs') { |job| $ran << job.body }
+      @jobs.register('tube_stop') { |job| $ran << job.body; @jobs.stop! }
+      @beanstalk.tubes.find('email-jobs').put('email', :pri => 1)
+      @beanstalk.tubes.find('tube_stop').put('stop', :pri => 2)
+      @jobs.process!(:release_delay => 0)
+    end
+
+    it "should run the handler registered for the tube" do
+      assert_equal ['email', 'stop'], $ran
+      assert_nil @beanstalk.tubes.find('email-jobs').peek(:buried)
+    end
+  end # process! with a dashed tube name
+
+  describe "for process! when a failing handler no longer holds its job" do
+    before do
+      $foo = []
+      cleanup_tubes!(['tube_lost'])
+    end
+
+    after do
+      cleanup_tubes!(['tube_lost'])
+    end
+
+    # The handler loses 'first', puts 'second' and raises. 'second' outranks 'first', so it is
+    # reserved next whatever happened to 'first'.
+    def process_until_second_job(ttr = 120, &lose_job)
+      tube = @beanstalk.tubes.find('tube_lost')
+      @jobs.register('tube_lost') do |job|
+        $foo << job.body
+        if job.body == 'second'
+          @jobs.stop!
+        else
+          lose_job.call(job)
+          tube.put('second', :pri => 0)
+          raise RuntimeError
+        end
+      end
+      tube.put('first', :pri => 1, :ttr => ttr)
+      Timeout.timeout(15) { @jobs.process!(:reserve_timeout => 1) }
+    end
+
+    it "keeps processing when the handler deleted the job" do
+      process_until_second_job { |job| job.delete }
+      assert_equal ['first', 'second'], $foo
+    end
+
+    it "keeps processing when the handler released the job" do
+      process_until_second_job { |job| job.release(:delay => 5) }
+      assert_equal ['first', 'second'], $foo
+      assert_equal 1, @beanstalk.tubes.find('tube_lost').stats.current_jobs_delayed
+    end
+
+    it "keeps processing when the handler overran the job's TTR" do
+      process_until_second_job(1) do |job|
+        # the server releases a job some time after its TTR runs out
+        deadline = Time.now + 10
+        sleep 0.1 while job.stats.state == 'reserved' && Time.now < deadline
+        refute_equal 'reserved', job.stats.state
+      end
+      assert_equal ['first', 'second'], $foo
+    end
+  end
+
+  describe "for process! with stop!" do
+    before do
+      cleanup_tubes!(['tube_stop'])
+    end
+
+    after do
+      cleanup_tubes!(['tube_stop'])
+    end
+
+    # Runs process! in a thread and yields. Returns :returned, the exception process! raised, or
+    # :still_running if it hadn't finished within seconds.
+    def process_in_thread(seconds)
+      worker = Thread.new do
+        begin
+          @jobs.process!(:reserve_timeout => 1)
+          :returned
+        rescue StandardError => ex
+          ex
+        end
+      end
+      yield if block_given?
+      return worker.value if worker.join(seconds)
+      worker.kill
+      :still_running
+    end
+
+    it "returns within one reserve_timeout when stop! is called while idle" do
+      @jobs.register('tube_stop') { |job| }
+      result = process_in_thread(3) do
+        sleep 0.5
+        @jobs.stop!
+      end
+      assert_equal :returned, result
+    end
+
+    it "returns when stop! is called by a handler whose job another worker took over" do
+      other = Beaneater.new('localhost')
+      other.tubes.watch!('tube_stop')
+      runs = 0
+      @jobs.register('tube_stop') do |job|
+        runs += 1
+        job.release # as the server does once a job's TTR runs out
+        other.tubes.reserve(1)
+        @jobs.stop!
+      end
+      @beanstalk.tubes.find('tube_stop').put('taken over')
+
+      assert_equal :returned, process_in_thread(5)
+      assert_equal 1, runs
+    ensure
+      other.close if other
+    end
+  end
+
+  describe "for process! when the job_parser rejects a job" do
+    before do
+      cleanup_tubes!(['tube_bad_body'])
+      Beaneater.configure.job_parser = lambda { |body| JSON.parse(body) }
+    end
+
+    after do
+      Beaneater.configure.job_parser = lambda { |body| body }
+      cleanup_tubes!(['tube_bad_body'])
+    end
+
+    it "buries the job and goes on to the next one" do
+      handled = []
+      @jobs.register('tube_bad_body') do |job|
+        handled << job.body
+        @jobs.stop!
+      end
+      tube = @beanstalk.tubes.find('tube_bad_body')
+      tube.put('not json', :pri => 1)
+      tube.put('{"ok":1}', :pri => 2)
+
+      Timeout.timeout(10) { @jobs.process!(:reserve_timeout => 1) }
+      assert_equal [{ 'ok' => 1 }], handled
+      Beaneater.configure.job_parser = lambda { |body| body }
+      buried = tube.peek(:buried)
+      refute_nil buried, "the job the parser rejected was not buried"
+      assert_equal 'not json', buried.body
+    end
+
+    # process! goes on after NotFoundError (and JobNotReserved, TimedOutError); the job it had
+    # must not be taken for the bad job that follows.
+    def put_after_retry_jobs
+      tube = @beanstalk.tubes.find('tube_bad_body')
+      first = tube.put('{"first":1}', :pri => 1)[:id]
+      bad = tube.put('not json', :pri => 2)[:id]
+      tube.put('{"stop":1}', :pri => 3)
+      [tube, first, bad]
+    end
+
+    def stats_of(id)
+      Beaneater.configure.job_parser = lambda { |body| body }
+      @beanstalk.connection.transmit("stats-job #{id}")[:body]
+    end
+
+    it "buries the bad job after a handler deleted its own job" do
+      @jobs.register('tube_bad_body') do |job|
+        job.body == { 'stop' => 1 } ? @jobs.stop! : job.delete # process!'s own delete then gets NOT_FOUND
+      end
+      tube, _first, bad = put_after_retry_jobs
+      Timeout.timeout(10) { @jobs.process!(:reserve_timeout => 1) }
+      assert_equal 'buried', stats_of(bad)['state']
+    end
+
+    it "buries both the failed job and the bad job after a handler raised NotFoundError" do
+      @jobs.register('tube_bad_body') do |job|
+        if job.body == { 'stop' => 1 }
+          @jobs.stop!
+        else
+          @beanstalk.connection.transmit('delete 999999') # NOT_FOUND for some other job
+        end
+      end
+      tube, first, bad = put_after_retry_jobs
+      Timeout.timeout(10) { @jobs.process!(:reserve_timeout => 1) }
+      assert_equal 'buried', stats_of(bad)['state']
+      assert_equal 'buried', stats_of(first)['state'] # its handler failed, with the job still reserved
+    ensure
+      begin
+        @beanstalk.connection.transmit("delete #{first}") if first
+      rescue Beaneater::NotFoundError
+        nil
+      end
+    end
+
+    it "buries the job when the parser raises an error process! handles itself" do
+      Beaneater.configure.job_parser = lambda do |body|
+        raise Beaneater::NotFoundError.new('NOT_FOUND', 'parse') if body == 'not found'
+        raise Beaneater::TimedOutError.new('TIMED_OUT', 'parse') if body == 'timed out'
+        body
+      end
+      handled = []
+      @jobs.register('tube_bad_body') do |job|
+        handled << job.body
+        @jobs.stop!
+      end
+      tube = @beanstalk.tubes.find('tube_bad_body')
+      not_found = tube.put('not found', :pri => 1, :ttr => 2)[:id]
+      timed_out = tube.put('timed out', :pri => 2, :ttr => 2)[:id]
+      tube.put('stop', :pri => 3)
+
+      Timeout.timeout(10) { @jobs.process!(:reserve_timeout => 1) }
+      assert_equal ['stop'], handled
+      [not_found, timed_out].each do |id|
+        stats = stats_of(id)
+        assert_equal 'buried', stats['state'], "job #{id}"
+        assert_equal 0, stats['timeouts'], "job #{id}"
+      end
+    end
+
+    it "buries the job and stops when the parser raises AbortProcessingError" do
+      Beaneater.configure.job_parser = lambda { |body| raise Beaneater::AbortProcessingError if body == 'abort'; body }
+      @jobs.register('tube_bad_body') { |job| }
+      id = @beanstalk.tubes.find('tube_bad_body').put('abort')[:id]
+      Timeout.timeout(10) { @jobs.process!(:reserve_timeout => 1) }
+      assert_equal 'buried', stats_of(id)['state']
+    end
+
+    it "buries the job when the parser raises a frozen exception" do
+      frozen = ArgumentError.new('frozen').freeze
+      Beaneater.configure.job_parser = lambda { |body| body == 'bad' ? raise(frozen) : body }
+      handled = []
+      @jobs.register('tube_bad_body') do |job|
+        handled << job.body
+        @jobs.stop!
+      end
+      tube = @beanstalk.tubes.find('tube_bad_body')
+      tube.put('bad', :pri => 1)
+      tube.put('good', :pri => 2)
+
+      Timeout.timeout(10) { @jobs.process!(:reserve_timeout => 1) }
+      assert_equal ['good'], handled
+      Beaneater.configure.job_parser = lambda { |body| body }
+      assert_equal 'bad', (tube.peek(:buried) || flunk("the bad job was not buried")).body
+    end
+
+    it "buries the handler's job, not the one its own reserve rejected, when a handler raises it" do
+      cleanup_tubes!(['tube_bad_body_other'])
+      other_id = @beanstalk.tubes.find('tube_bad_body_other').put('not json')[:id]
+      @jobs.register('tube_bad_body') do |job|
+        @jobs.stop!
+        @beanstalk.tubes.watch('tube_bad_body_other')
+        @beanstalk.tubes.reserve(0) # raises: the parser rejects the other tube's job
+      end
+      @beanstalk.tubes.find('tube_bad_body').put('{"ok":1}')
+
+      Timeout.timeout(10) { @jobs.process!(:reserve_timeout => 1) }
+      Beaneater.configure.job_parser = lambda { |body| body }
+      assert_equal '{"ok":1}', (@beanstalk.tubes.find('tube_bad_body').peek(:buried) || flunk("the handler's job was not buried")).body
+      assert_equal 'reserved', @beanstalk.connection.transmit("stats-job #{other_id}")[:body]['state']
+    ensure
+      Beaneater.configure.job_parser = lambda { |body| body }
+      begin
+        @beanstalk.connection.transmit("delete #{other_id}") if other_id
+      rescue Beaneater::NotFoundError
+        nil
+      end
+      cleanup_tubes!(['tube_bad_body_other'])
+    end
+  end
+
+  describe "for process! when a handler raises NotFoundError with its job reserved" do
+    before do
+      cleanup_tubes!(['tube_not_found'])
+    end
+
+    after do
+      cleanup_tubes!(['tube_not_found'])
+    end
+
+    it "buries the job once instead of reserving in a loop near its TTR" do
+      runs = 0
+      @jobs.register('tube_not_found') do |job|
+        runs += 1
+        @beanstalk.connection.transmit('delete 999999') # NOT_FOUND for some other job
+      end
+      id = @beanstalk.tubes.find('tube_not_found').put('x', :ttr => 2)[:id]
+      worker = Thread.new { @jobs.process!(:reserve_timeout => 1) }
+      sleep 3 # past the job's TTR
+      @jobs.stop!
+      assert worker.join(5), "process! did not stop"
+      checker = Beaneater.new('localhost')
+      stats = checker.connection.transmit("stats-job #{id}")[:body]
+      checker.close
+      assert_equal 1, runs
+      assert_equal 'buried', stats['state']
+      assert_equal 0, stats['timeouts']
+    end
+
+    it "goes on when the job stops being reserved just before it is buried" do
+      @jobs.register('tube_not_found') do |job|
+        @jobs.stop!
+        raise 'handler failed'
+      end
+      id = @beanstalk.tubes.find('tube_not_found').put('x')[:id]
+      Beaneater::Job.any_instance.stubs(:bury).raises(Beaneater::JobNotReserved) # another client's reservation ended
+      Timeout.timeout(10) { @jobs.process!(:reserve_timeout => 1) } # must not raise JobNotReserved
+      assert_nil @jobs.current_job
+    ensure
+      Beaneater::Job.any_instance.unstub(:bury)
+      begin
+        @beanstalk.connection.transmit("delete #{id}") if id
+      rescue Beaneater::NotFoundError
+        nil
+      end
+    end
+
+    it "releases the job for another try instead when the error is in retry_on" do
+      runs = 0
+      @jobs.register('tube_not_found', :retry_on => [Beaneater::NotFoundError], :max_retries => 1) do |job|
+        runs += 1
+        @jobs.stop! if runs == 2
+        @beanstalk.connection.transmit('delete 999999') # NOT_FOUND for some other job
+      end
+      id = @beanstalk.tubes.find('tube_not_found').put('x')[:id]
+      Timeout.timeout(10) { @jobs.process!(:reserve_timeout => 1, :release_delay => 0) }
+      stats = @beanstalk.connection.transmit("stats-job #{id}")[:body]
+      assert_equal 2, runs
+      assert_equal 1, stats['releases'] # released once, then buried once the retries ran out
+      assert_equal 'buried', stats['state']
+    end
+  end
+
+  describe "for process! when a handler raises NotConnected for another server" do
+    before do
+      cleanup_tubes!(['tube_other_down'])
+    end
+
+    it "buries the job and keeps processing" do
+      seen = []
+      @jobs.register('tube_other_down') do |job|
+        seen << job.body
+        @jobs.stop! if job.body == 'second'
+        raise Beaneater::NotConnected, "the other server is down" if job.body == 'first'
+      end
+      tube = @beanstalk.tubes.find('tube_other_down')
+      tube.put('first', :pri => 1)
+      tube.put('second', :pri => 2)
+
+      Timeout.timeout(10) { @jobs.process!(:reserve_timeout => 1) }
+      assert_equal ['first', 'second'], seen
+      assert_equal 'first', tube.peek(:buried).body
+    end
+  end
+
+  describe "for process! when the server goes away" do
+    before do
+      @port = free_port
+      @pid = start_beanstalkd(@port)
+      @client = Beaneater.new("127.0.0.1:#{@port}")
+    end
+
+    after do
+      @client.close if @client
+      stop_beanstalkd(@pid) if @pid
+    end
+
+    it "forgets the job when burying it fails, so the next run buries its own bad job" do
+      Beaneater.configure.job_parser = lambda do |body|
+        stop_beanstalkd(@pid) if body == 'kill' # the server dies before the bad job is buried
+        JSON.parse(body)
+      end
+      handled = []
+      @client.jobs.register('bury_fails') do |job|
+        handled << job.body
+        @client.jobs.stop!
+      end
+      @client.tubes.find('bury_fails').put('kill')
+      assert_raises(Beaneater::NotConnected) { Timeout.timeout(10) { @client.jobs.process!(:reserve_timeout => 1) } }
+      assert_nil @client.jobs.current_job
+
+      @pid = start_beanstalkd(@port) # a new server: job ids start again at 1
+      producer = Beaneater.new("127.0.0.1:#{@port}")
+      producer.tubes.find('bury_fails_filler').put('filler') # takes the id the lost job had
+      producer.tubes.find('bury_fails').put('not json', :pri => 1)
+      producer.tubes.find('bury_fails').put('{"ok":1}', :pri => 2)
+      Timeout.timeout(10) { @client.jobs.process!(:reserve_timeout => 1) }
+      assert_equal [{ 'ok' => 1 }], handled
+      Beaneater.configure.job_parser = lambda { |body| body }
+      buried = producer.tubes.find('bury_fails').peek(:buried)
+      refute_nil buried, "the bad job was not buried"
+      assert_equal 'not json', buried.body
+      producer.close
+    ensure
+      Beaneater.configure.job_parser = lambda { |body| body }
+    end
+
+    it "raises NotConnected instead of looping, and the client resumes once the server is back" do
+      seen = []
+      @client.jobs.register('reconnect') do |job|
+        seen << job.body
+        @client.jobs.stop! if job.body == 'after restart'
+      end
+      @client.tubes.find('reconnect').put('before outage')
+
+      worker = Thread.new do
+        begin
+          @client.jobs.process!(:reserve_timeout => 1)
+        rescue StandardError => ex
+          ex
+        end
+      end
+      Timeout.timeout(5) { sleep 0.05 while seen.empty? }
+      stop_beanstalkd(@pid)
+
+      finished = worker.join(10)
+      worker.kill unless finished
+      assert finished, "process! was still running 10s after the server went away"
+      assert_kind_of Beaneater::NotConnected, worker.value
+
+      @pid = start_beanstalkd(@port)
+      producer = Beaneater.new("127.0.0.1:#{@port}")
+      producer.tubes.find('reconnect').put('after restart')
+      producer.close
+
+      Timeout.timeout(10) { @client.jobs.process!(:reserve_timeout => 1) }
+      assert_equal ['before outage', 'after restart'], seen
+    end
+  end
 end # Beaneater::Jobs

data/test/stat_struct_test.rb

@@ -29,6 +29,11 @@ describe Beaneater::StatStruct do
       assert_equal 'foo', @struct[:baz]
       assert_equal 'demo', @struct[:"under_score"]
     end
+
+    it "should look up hyphenated beanstalkd keys" do
+      assert_equal 'demo', @struct['under-score']
+      assert_equal 'demo', @struct[:"under-score"]
+    end
   end # []
 
   describe "for #keys" do

data/test/test_helper.rb

@@ -45,4 +45,49 @@ class MiniTest::Unit::TestCase
   def teardown
     flush_all
   end
+
+  # The beanstalkd binary for tests that stop and restart their own server: BEANSTALKD_BIN, or
+  # `beanstalkd` on PATH. Skips the test when neither is available.
+  def beanstalkd_bin
+    bin = ENV['BEANSTALKD_BIN']
+    return bin if bin && !bin.empty?
+    on_path = ENV['PATH'].to_s.split(File::PATH_SEPARATOR).any? do |dir|
+      File.executable?(File.join(dir, 'beanstalkd'))
+    end
+    skip("beanstalkd not found: put it on PATH or set BEANSTALKD_BIN") unless on_path
+    'beanstalkd'
+  end
+
+  # A free local port for a private beanstalkd
+  def free_port
+    server = TCPServer.new('127.0.0.1', 0)
+    server.addr[1]
+  ensure
+    server.close if server
+  end
+
+  # Starts a private beanstalkd on port and waits until it accepts connections.
+  #
+  # @return [Integer] the server's pid
+  def start_beanstalkd(port)
+    pid = Process.spawn(beanstalkd_bin, '-l', '127.0.0.1', '-p', port.to_s, [:out, :err] => File::NULL)
+    50.times do
+      begin
+        TCPSocket.new('127.0.0.1', port).close
+        return pid
+      rescue Errno::ECONNREFUSED
+        sleep 0.05
+      end
+    end
+    stop_beanstalkd(pid)
+    flunk "beanstalkd did not start on port #{port}"
+  end
+
+  # Kills a server started by start_beanstalkd
+  def stop_beanstalkd(pid)
+    Process.kill('KILL', pid)
+    Process.wait(pid)
+  rescue Errno::ESRCH, Errno::ECHILD
+    nil
+  end
 end

data/test/tube_test.rb

@@ -96,11 +96,134 @@ describe Beaneater::Tube do
       assert_equal 'hi: there! this: is a long message', @tube.peek(:ready).body['message']
     end
 
+    it "should keep the connection usable when the custom parser raises" do
+      Beaneater.configure.job_parser = lambda { |b| JSON.parse(b) }
+      @tube.put('not json')
+      socket = @beanstalk.connection.connection
+      assert_raises(JSON::ParserError) { @tube.peek(:ready) }
+      assert_same socket, @beanstalk.connection.connection
+      assert_equal 'baz', @beanstalk.tubes.used.name
+    end
+
     after do
       Beaneater.configure.job_parser = lambda { |b| b }
     end
   end # peek
 
+  describe "for a job_parser that raises on reserve" do
+    before do
+      Beaneater.configure.job_parser = lambda { |b| JSON.parse(b) }
+      @tube = @beanstalk.tubes.find('poison_tube')
+      @poison_id = @tube.put('not json', :pri => 1)[:id]
+      @tube.put('{"ok":1}', :pri => 2)
+      @beanstalk.tubes.watch!('poison_tube')
+    end
+
+    after do
+      Beaneater.configure.job_parser = lambda { |b| b }
+      # The bad job is still reserved by this connection, which clearing the tube can't touch;
+      # left alone, it would be released when the socket is collected, into a later test.
+      begin
+        @beanstalk.connection.transmit("delete #{@poison_id}")
+      rescue Beaneater::NotFoundError
+        nil
+      end
+      cleanup_tubes!(['poison_tube'])
+    end
+
+    it "should raise the parser's own error from reserve, tagged with the job id" do
+      error = assert_raises(JSON::ParserError) { @beanstalk.tubes.reserve(0) }
+      assert_kind_of Beaneater::JobParseFailure, error
+      assert_equal @poison_id, error.job_id
+      assert_nil error.cause # the parser's error had none
+      Beaneater.configure.job_parser = lambda { |b| b }
+      assert_equal 'reserved', @beanstalk.connection.transmit("stats-job #{error.job_id}")[:body]['state']
+    end
+
+    it "should keep the parser's error intact: class, message, backtrace and cause" do
+      original = nil
+      Beaneater.configure.job_parser = lambda do |b|
+        begin
+          JSON.parse(b)
+        rescue JSON::ParserError => ex
+          original = ex
+          raise ArgumentError, 'not a job' # its cause is the ParserError
+        end
+      end
+      error = assert_raises(ArgumentError) { @beanstalk.tubes.reserve(0) }
+      assert_equal @poison_id, error.job_id
+      assert_equal 'not a job', error.message
+      assert_same original, error.cause
+      assert_operator error.backtrace.first, :include?, 'tube_test.rb'
+      refute_nil error.backtrace_locations
+    end
+
+    # An exception class that can't be copied on any Ruby (clone calls initialize_copy)
+    class UncopyableError < StandardError
+      def initialize_copy(_original)
+        raise TypeError, "can't copy"
+      end
+    end
+
+    # An exception class whose #cause is not an exception
+    class OddCauseError < StandardError
+      def cause
+        'not an exception'
+      end
+    end
+
+    it "should raise the parser's own exception, untagged, when it can't be copied" do
+      Beaneater.configure.job_parser = lambda { |b| raise UncopyableError, 'no copies' }
+      error = assert_raises(UncopyableError) { @beanstalk.tubes.reserve(0) }
+      assert_equal 'no copies', error.message
+      refute_kind_of Beaneater::JobParseFailure, error
+    end
+
+    it "should raise a frozen exception that can't be copied as it is" do
+      frozen = UncopyableError.new('frozen, no copies').freeze
+      Beaneater.configure.job_parser = lambda { |b| raise frozen }
+      error = assert_raises(UncopyableError) { @beanstalk.tubes.reserve(0) }
+      assert_same frozen, error
+      assert_nil error.cause
+    end
+
+    it "should tag the copy when the exception's cause is not an exception" do
+      Beaneater.configure.job_parser = lambda { |b| raise OddCauseError, 'odd' }
+      error = assert_raises(OddCauseError) { @beanstalk.tubes.reserve(0) }
+      assert_equal @poison_id, error.job_id
+    end
+
+    it "should not tag an exception the parser reuses, so a later error carries no old id" do
+      shared = JSON::ParserError.new('always this one')
+      Beaneater.configure.job_parser = lambda { |b| raise shared }
+      error = assert_raises(JSON::ParserError) { @beanstalk.tubes.reserve(0) }
+      assert_equal @poison_id, error.job_id
+      peeked = assert_raises(JSON::ParserError) { @tube.peek(:ready) } # not a reserve: not tagged
+      refute_kind_of Beaneater::JobParseFailure, peeked
+      refute_kind_of Beaneater::JobParseFailure, shared
+    end
+
+    it "should keep the connection, so the bad job stays reserved and the next job is delivered" do
+      socket = @beanstalk.connection.connection
+      assert_raises(JSON::ParserError) { @beanstalk.tubes.reserve(0) }
+      assert_same socket, @beanstalk.connection.connection
+      job = @beanstalk.tubes.reserve(0)
+      assert_equal({ 'ok' => 1 }, job.body)
+      job.delete
+    end
+
+    it "should keep the connection when the raising parser used the same client first" do
+      tube = 'poison_tube'
+      Beaneater.configure.job_parser = lambda { |b| @beanstalk.connection.transmit("use #{tube}"); JSON.parse(b) }
+      socket = @beanstalk.connection.connection
+      assert_raises(JSON::ParserError) { @beanstalk.tubes.reserve(0) }
+      assert_same socket, @beanstalk.connection.connection
+      job = @beanstalk.tubes.reserve(0)
+      assert_equal({ 'ok' => 1 }, job.body)
+      job.delete
+    end
+  end # job_parser that raises on reserve
+
   describe "for #reserve" do
     before do
       @time = Time.now.to_i

data/test/tubes_test.rb

@@ -60,6 +60,13 @@ describe Beaneater::Tubes do
         assert @beanstalk.tubes.all.map(&:name).include?(t)
       end
     end
+
+    it 'should return tube names that look like numbers or dates as strings' do
+      names = ['1.10', '2026-10-30', 'true', 'a-b']
+      names.each { |t| @beanstalk.tubes.find(t).put 'x' }
+      all = @beanstalk.tubes.all.map(&:name)
+      names.each { |t| assert_includes all, t }
+    end
   end # all
 
   describe "for Enumerable" do
@@ -157,8 +164,16 @@ describe Beaneater::Tubes do
       @tube.reserve.delete
       @tube.put "foo reserve #{@time}", :ttr => 1
       @beanstalk.tubes.watch 'tube'
-      @beanstalk.tubes.reserve
+      job = @beanstalk.tubes.reserve
       assert_raises(Beaneater::DeadlineSoonError) { @beanstalk.tubes.reserve(0) }
+    ensure
+      # left reserved, the job would be released (TTR, or the socket being collected) into a
+      # later #reserve test
+      begin
+        job.delete if job
+      rescue Beaneater::NotFoundError
+        nil
+      end
     end
 
   end # reserve

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beaneater
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.2.0
 platform: ruby
 authors:
 - Nico Taing
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-07 00:00:00.000000000 Z
+date: 2026-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -136,7 +136,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="