beanstalk_integration_tests 0.0.1

data/lib/beanstalk_integration_tests/quit_test.rb

@@ -0,0 +1,24 @@
+require 'beanstalk_integration_tests/test_helper'
+
+class QuitTest < BeanstalkIntegrationTest
+
+  context 'quit' do
+
+    should 'close the connection' do
+      other_client = build_client
+      initial_current_connections = client.transmit('stats')[:body]['current-connections']
+      # Send quit directly because transmit will die.
+      other_client.connection.write("quit\r\n")
+      # Make sure there are no further responses
+      other_client.connection.write("stats\r\n")
+      begin
+        assert_nil other_client.connection.gets
+      rescue Errno::ECONNRESET
+        # Occasionally occurs after disconnect
+      end
+      assert_equal(initial_current_connections - 1, client.transmit('stats')[:body]['current-connections'], 'Expected current-connections to be decremented after quit')
+    end
+
+  end
+
+end

data/lib/beanstalk_integration_tests/release_test.rb

@@ -0,0 +1,191 @@
+require 'beanstalk_integration_tests/test_helper'
+
+class ReleaseTest < BeanstalkIntegrationTest
+
+  context 'release with a reserved job' do
+
+    setup do
+      client.transmit("use #{tube_name}")
+      client.transmit("watch #{tube_name}")
+      message = uuid
+      client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")
+      timeout(2) do
+        @reserved_id = client.transmit('reserve')[:id]
+      end
+      stats = client.transmit('stats')[:body]
+      @initial_cmd_release = stats['cmd-release']
+      @initial_server_jobs_urgent = stats['current-jobs-urgent']
+      @initial_server_jobs_ready = stats['current-jobs-ready']
+      @initial_server_jobs_delayed = stats['current-jobs-delayed']
+      tube_stats = client.transmit("stats-tube #{tube_name}")[:body]
+      @initial_tube_jobs_urgent = tube_stats['current-jobs-urgent']
+      @initial_tube_jobs_ready = tube_stats['current-jobs-ready']
+      @initial_tube_jobs_delayed = tube_stats['current-jobs-delayed']
+      @initial_job_releases = client.transmit("stats-job #{@reserved_id}")[:body]['releases']
+    end
+
+
+    should 'release a job reserved by the client' do
+      release_response = client.transmit("release #{@reserved_id} 0 0")
+      assert_equal 'RELEASED', release_response[:status]
+      assert_equal 'ready', client.transmit("stats-job #{@reserved_id}")[:body]['state']
+      assert_counter_delta
+    end
+
+
+    should 'release a job reserved by the client when job deadline is pending' do
+      message = uuid
+      client.transmit("delete #{@reserved_id}")
+      client.transmit("put 0 0 1 #{message.bytesize}\r\n#{message}")
+      timeout(2) do
+        @reserved_id = client.transmit('reserve')[:id]
+      end
+      assert_raises(Beaneater::DeadlineSoonError, 'Expected reserve to raise an error when deadline pending') do
+        timeout(2) do
+          client.transmit('reserve')
+        end
+      end
+      release_response = client.transmit("release #{@reserved_id} 0 0")
+      assert_equal 'RELEASED', release_response[:status]
+      assert_equal 'ready', client.transmit("stats-job #{@reserved_id}")[:body]['state']
+      assert_counter_delta
+    end
+
+
+    should 'release a job to the original tube' do
+      release_response = client.transmit("release #{@reserved_id} 0 0")
+      assert_equal 'RELEASED', release_response[:status]
+      assert_equal tube_name, client.transmit("stats-job #{@reserved_id}")[:body]['tube']
+    end
+
+
+    should 'release a job with the provided delay' do
+      delay = 25
+      release_response = client.transmit("release #{@reserved_id} 0 #{delay}")
+      assert_equal 'RELEASED', release_response[:status]
+      job_stats = client.transmit("stats-job #{@reserved_id}")[:body]
+      assert_equal delay, job_stats['delay']
+      assert_equal 'delayed', job_stats['state']
+      assert_counter_delta(1, 'delayed')
+    end
+
+
+    should 'release a job with the provided priority' do
+      pri = 25
+      release_response = client.transmit("release #{@reserved_id} #{pri} 0")
+      assert_equal 'RELEASED', release_response[:status]
+      job_stats = client.transmit("stats-job #{@reserved_id}")[:body]
+      assert_equal pri, job_stats['pri']
+    end
+
+
+    should 'return a job released with a delay to ready after timeout' do
+      delay = 1
+      release_response = client.transmit("release #{@reserved_id} 0 #{delay}")
+      assert_equal 'RELEASED', release_response[:status]
+      job_stats = client.transmit("stats-job #{@reserved_id}")[:body]
+      assert_equal delay, job_stats['delay']
+      assert_equal 'delayed', job_stats['state']
+      assert_counter_delta(1, 'delayed')
+      sleep 1.1
+      assert_equal 'ready', client.transmit("stats-job #{@reserved_id}")[:body]['state']
+      assert_counter_delta
+    end
+
+
+    should 'not be able to release a job reserved by another client' do
+      initial_cmd_release = client.transmit('stats')[:body]['cmd-release']
+      assert_raises(Beaneater::NotFoundError, 'Expected releaing a job reserved by another client to raise an error') do
+        build_client.transmit("release #{@reserved_id} 0 0")
+      end
+      assert_equal(initial_cmd_release + 1, client.transmit('stats')[:body]['cmd-release'], 'Expected cmd-release stats to be incremented')
+      client.transmit("delete #{@reserved_id}")
+    end
+
+
+    should 'not be able to release an unreserved job' do
+      initial_cmd_release = client.transmit('stats')[:body]['cmd-release']
+      initial_job_releases = client.transmit("stats-job #{@reserved_id}")[:body]['releases']
+      client.transmit("release #{@reserved_id} 0 0")
+      assert_raises(Beaneater::NotFoundError, 'Expected releaing an unreserved job to raise an error') do
+        client.transmit("release #{@reserved_id} 0 0")
+      end
+      assert_equal(initial_cmd_release + 2, client.transmit('stats')[:body]['cmd-release'], 'Expected cmd-release stats to be incremented')
+      assert_equal(initial_job_releases + 1, client.transmit("stats-job #{@reserved_id}")[:body]['releases'], 'Expected job releases to be unchanged')
+    end
+
+
+    should 'return BAD_FORMAT with negative delay or priority' do
+      args = [-1, 1]
+      initial_cmd_release = client.transmit('stats')[:body]['cmd-release']
+      initial_job_releases = client.transmit("stats-job #{@reserved_id}")[:body]['releases']
+      args.length.times do
+        assert_raises(Beaneater::BadFormatError, 'Expected release with negative argument to raise BAD_FORMAT') do
+          client.transmit(['release', @reserved_id].concat(args).join(' '))
+        end
+        assert_equal(initial_cmd_release, client.transmit('stats')[:body]['cmd-release'], 'Expected cmd-release to be unchanged')
+        assert_equal(initial_job_releases, client.transmit("stats-job #{@reserved_id}")[:body]['releases'], 'Expected job releases to be unchanged')
+        args.cycle
+      end
+      client.transmit("delete #{@reserved_id}")
+    end
+
+  end
+
+
+  context 'release not requiring a reserved job' do
+
+    should 'return BAD_FORMAT with trailing space or arguments' do
+      initial_cmd_release = client.transmit('stats')[:body]['cmd-release']
+      assert_raises(Beaneater::BadFormatError, 'Expected release with trailing space to return BAD_FORMAT') do
+        client.transmit('release 1 0 0 ')
+      end
+      assert_equal(initial_cmd_release, client.transmit('stats')[:body]['cmd-release'], 'Expected cmd-release stats to be unchanged')
+
+      assert_raises(Beaneater::BadFormatError, 'Expected release with trailing space to return BAD_FORMAT') do
+        client.transmit('release 1 0 0 x')
+      end
+      assert_equal(initial_cmd_release, client.transmit('stats')[:body]['cmd-release'], 'Expected cmd-release stats to be unchanged')
+    end
+
+
+    should 'return BAD_FORMAT with non-integer job_id, delay, or priority' do
+      args = ['foo', 1, 1]
+      args.length.times do
+        initial_cmd_release = client.transmit('stats')[:body]['cmd-release']
+        assert_raises(Beaneater::BadFormatError, 'Expected release with non-integer argument to raise BAD_FORMAT') do
+          client.transmit(['release'].concat(args).join(' '))
+        end
+        assert_equal(initial_cmd_release, client.transmit('stats')[:body]['cmd-release'], 'Expected cmd-release stats to be unchanged')
+        args.cycle
+      end
+    end
+
+
+    should 'return NOT_FOUND with negative job_id' do
+      initial_cmd_release = client.transmit('stats')[:body]['cmd-release']
+      assert_raises(Beaneater::NotFoundError, 'Expected release with negative job_id to raise NOT_FOUND') do
+        client.transmit('release -1 0 0')
+      end
+      assert_equal(initial_cmd_release + 1, client.transmit('stats')[:body]['cmd-release'], 'Expected cmd-release stats to be incremented')
+    end
+
+  end
+
+
+  def assert_counter_delta(delta = 1, job_state = 'ready')
+    stats = client.transmit('stats')[:body]
+    tube_stats = client.transmit("stats-tube #{tube_name}")[:body]
+    assert_equal(@initial_cmd_release + delta, stats['cmd-release'], 'Expected cmd-release to be incremented')
+    assert_equal(instance_variable_get("@initial_server_jobs_#{job_state}") + delta, stats["current-jobs-#{job_state}"], "Expected server current-jobs-#{job_state} to be incremented")
+    assert_equal(instance_variable_get("@initial_tube_jobs_#{job_state}") + delta, tube_stats["current-jobs-#{job_state}"], "Expected tube current-jobs-#{job_state} to be incremented")
+    if job_state == 'ready'
+      assert_equal(@initial_server_jobs_urgent + delta, stats['current-jobs-urgent'], 'Expected server current-jobs-urgent to be incremented')
+      assert_equal(@initial_tube_jobs_urgent + delta, tube_stats['current-jobs-urgent'], 'Expected tube current-jobs-urgent to be incremented')
+    end
+    assert_equal(@initial_job_releases + delta, client.transmit("stats-job #{@reserved_id}")[:body]['releases'], 'Expected job releases to be incremented')
+    assert_equal(0, stats['current-jobs-reserved'], 'Expected server current-jobs-reserved to be zero')
+    assert_equal(0, tube_stats['current-jobs-reserved'], 'Expected tube current-jobs-reserved to be zero')
+  end
+
+end

data/lib/beanstalk_integration_tests/reserve_test.rb

@@ -0,0 +1,385 @@
+require 'beanstalk_integration_tests/test_helper'
+require 'timeout'
+
+class ReserveTest < BeanstalkIntegrationTest
+
+  context 'common reserve behavior' do
+
+    setup do
+      client.transmit("watch #{tube_name}")
+      client.transmit("use #{tube_name}")
+      @message = uuid
+    end
+
+    {
+      'reserve' => 'reserve',
+      'reserve-with-timeout' => 'reserve-with-timeout 0'
+    }.each do |command, reserve_command|
+      context reserve_command.split(/\s/).first do
+
+        context 'a single watched tube' do
+
+          should 'reserve a job' do
+            put_response = client.transmit("put 0 0 60 #{@message.bytesize}\r\n#{@message}")
+            job_id = put_response[:id]
+            assert_equal tube_name, client.transmit("stats-job #{job_id}")[:body]['tube']
+            assert client.transmit('list-tubes-watched')[:body].include?(tube_name)
+            timeout(2) do
+              reservation_id = client.transmit(reserve_command)[:id]
+              assert_equal job_id, reservation_id
+              client.transmit("delete #{job_id}")
+            end
+          end
+
+
+          should "increment reserves count on job, current-jobs-reserved on tube, and current-jobs-reserved, current-producers, and cmd-#{command} on server" do
+            other_client = build_client
+            other_client.transmit("use #{tube_name}")
+            job_id = other_client.transmit("put 0 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+            initial_job_reserves = client.transmit("stats-job #{job_id}")[:body]['reserves']
+            initial_tube_reserved = client.transmit("stats-tube #{tube_name}")[:body]['current-jobs-reserved']
+            server_stats = client.transmit('stats')[:body]
+            initial_server_reserved = server_stats['current-jobs-reserved']
+            initial_server_cmds = server_stats["cmd-#{command}"]
+            initial_server_workers = server_stats['current-workers']
+
+            timeout(2) do
+              client.transmit(reserve_command)[:id]
+            end
+
+            assert_equal initial_job_reserves + 1, client.transmit("stats-job #{job_id}")[:body]['reserves']
+            assert_equal initial_tube_reserved + 1, client.transmit("stats-tube #{tube_name}")[:body]['current-jobs-reserved']
+            server_stats = client.transmit('stats')[:body]
+            assert_equal initial_server_reserved + 1, server_stats['current-jobs-reserved']
+            assert_equal initial_server_cmds + 1, server_stats["cmd-#{command}"]
+            assert_equal initial_server_workers + 1, server_stats['current-workers']
+            client.transmit("delete #{job_id}")
+          end
+
+
+          should 'receive a job enqueued to the watched tube while reserving' do
+            client2 = build_client
+            client2.transmit("use #{tube_name}")
+
+            thread = Thread.new do
+              timeout(2) do
+                alt_command = command == 'reserve' ? 'reserve' : 'reserve-with-timeout 1'
+                reservation_id = client.transmit(alt_command)[:id]
+                assert reservation_id
+                client.transmit("delete #{reservation_id}")
+              end
+              assert_equal 0, client.transmit("stats-tube #{tube_name}")[:body]['current-waiting']
+            end
+            while client2.transmit("stats-tube #{tube_name}")[:body]['current-waiting'] == 0
+              sleep 0.1
+            end
+            client2.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+            thread.join
+          end
+
+
+          should 'reserve the job with the lowest priority' do
+            job_ids = []
+            job_ids << client.transmit("put 5000 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+            job_ids << client.transmit("put 1024 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+            job_ids << client.transmit("put 1023 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+            job_ids << client.transmit("put 0 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+            job_ids.length.times do
+              timeout(2) do
+                job_id = job_ids.pop
+                assert_equal job_id, client.transmit(reserve_command)[:id]
+                client.transmit("delete #{job_id}")
+              end
+            end
+          end
+
+
+          should 'reserve the job received first if priorities equal' do
+            job_ids = 4.times.map do
+              client.transmit("put 0 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+            end
+            job_ids.length.times do
+              timeout(2) do
+                job_id = job_ids.shift
+                assert_equal job_id, client.transmit(reserve_command)[:id]
+                client.transmit("delete #{job_id}")
+              end
+            end
+          end
+
+        end
+
+        context 'multiple watched tubes' do
+
+          setup do
+            @client2 = build_client
+            @client2_tube = generate_tube_name
+            @client2.transmit("use #{@client2_tube}")
+            @client3 = build_client
+            @client3_tube = generate_tube_name
+            @client3.transmit("use #{@client3_tube}")
+            client.transmit("watch #{@client2_tube}")
+            client.transmit("watch #{@client3_tube}")
+          end
+
+
+          should 'reserve a job from any watched tube' do
+            [client, @client2, @client3].each do |tube_client|
+              timeout(2) do
+                job_id = tube_client.transmit("put 0 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+                assert_equal job_id, client.transmit(reserve_command)[:id]
+                client.transmit("delete #{job_id}")
+              end
+            end
+          end
+
+
+          should 'receive a job enqueued to any watched tube while reserving' do
+            client_clone = build_client
+            client_clone.transmit("use #{tube_name}")
+            alt_command = command == 'reserve' ? 'reserve' : 'reserve-with-timeout 1'
+            {client_clone => tube_name, @client2 => @client2_tube, @client3 => @client3_tube}.each do |tube_client, tube_client_tube|
+              thread = Thread.new do
+                timeout(2) do
+                  job_id = client.transmit(alt_command)[:id]
+                  assert_equal tube_client_tube, client.transmit("stats-job #{job_id}")[:body]['tube']
+                  client.transmit("delete #{job_id}")
+                end
+              end
+
+              while tube_client.transmit("stats-tube #{tube_client_tube}")[:body]['current-waiting'] == 0
+                sleep 0.1
+              end
+
+              tube_client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+              thread.join
+            end
+          end
+
+
+          should 'reserve the job with the lowest priority' do
+            job_ids = []
+            subset_ids = []
+            [5000, 1024, 1023, 0].each do |pri|
+              subset_ids << client.transmit("put #{pri} 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+              subset_ids << @client2.transmit("put #{pri} 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+              subset_ids << @client3.transmit("put #{pri} 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+              job_ids.concat(subset_ids.reverse)
+              subset_ids.clear
+            end
+            job_ids.length.times do
+              timeout(2) do
+                job_id = job_ids.pop
+                assert_equal job_id, client.transmit(reserve_command)[:id]
+                client.transmit("delete #{job_id}")
+              end
+            end
+          end
+
+
+          should 'reserve the job received first if priorities equal' do
+            job_ids = []
+            job_ids << client.transmit("put 0 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+            job_ids << @client2.transmit("put 0 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+            job_ids << @client3.transmit("put 0 0 60 #{@message.bytesize}\r\n#{@message}")[:id]
+
+            client.transmit("watch #{@client2_tube}")
+            client.transmit("watch #{@client3_tube}")
+
+            job_ids.length.times do
+              timeout(2) do
+                job_id = job_ids.shift
+                assert_equal job_id, client.transmit(reserve_command)[:id]
+                client.transmit("delete #{job_id}")
+              end
+            end
+          end
+
+
+          should 'not reserve a job from a tube not watched' do
+            client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+            client.transmit("watch #{generate_tube_name}")
+            client.transmit("ignore #{tube_name}")
+
+            expected_error = command == 'reserve' ? Timeout::Error : Beaneater::TimedOutError
+            assert_raises(expected_error, 'Expected client to timeout while waiting for reservation') do
+              timeout(1) do
+                client.transmit(reserve_command)
+              end
+            end
+          end
+
+
+          should 'supply clients with jobs in the order client reservations were received' do
+            clients = Hash[[build_client, @client2, @client3].shuffle.zip([0, 1, 2])]
+            alt_command = command == 'reserve' ? 'reserve' : 'reserve-with-timeout 1'
+            threads = []
+            clients.each_pair do |tube_client, reservation_number|
+              tube_client.transmit("watch #{tube_name}")
+              sleep 0.25
+              threads << Thread.new do
+                timeout(3) do
+                  reservation = tube_client.transmit(alt_command)
+                  assert_equal reservation_number.to_s, reservation[:body][-1]
+                  tube_client.transmit("delete #{reservation[:id]}")
+                end
+              end
+            end
+
+            while client.transmit("stats-tube #{tube_name}")[:body]['current-waiting'] != 3
+              sleep 0.1
+            end
+
+            3.times do |reservation_number|
+              message = [@message, reservation_number].join(' ')
+              client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")
+            end
+            threads.each(&:join)
+          end
+
+
+          should 'return a reserved job to the ready state and correct tube if the ttr expires' do
+            [client, @client2, @client3].each do |tube_client|
+              tube_client.transmit("put 0 0 1 #{@message.bytesize}\r\n#{@message}")
+            end
+            [tube_name, @client2_tube, @client3_tube].each do |tube_client_tube|
+              job_id = nil
+              timeout(2) do
+                job_id = client.transmit('reserve')[:id]
+              end
+              assert_equal 'reserved', client.transmit("stats-job #{job_id}")[:body]['state']
+              sleep 1
+              job_stats = client.transmit("stats-job #{job_id}")[:body]
+              assert_equal 'ready', job_stats['state']
+              assert_equal tube_client_tube, job_stats['tube']
+              client.transmit("delete #{job_id}")
+            end
+          end
+
+        end
+
+
+        should 'return deadline_soon if a ttr expiration is pending' do
+          job_id = client.transmit("put 0 0 1 #{@message.bytesize}\r\n#{@message}")[:id]
+          timeout(2) do
+            client.transmit('reserve')
+            assert_raises(Beaneater::DeadlineSoonError, 'Expected reserve during ttr expiration to return deadlinesoon') do
+              client.transmit('reserve')
+            end
+          end
+          client.transmit("delete #{job_id}")
+        end
+
+      end
+
+    end
+
+  end
+
+
+  context 'reserve' do
+
+    should 'return BAD_FORMAT with trailing space or any trailing args' do
+      initial_cmd_reserve = client.transmit('stats')[:body]['cmd-reserve']
+      timeout(1) do
+        assert_raises(Beaneater::BadFormatError, 'Expected reserve with trailing space to return BAD_FORMAT') do
+          client.transmit('reserve ')
+        end
+      end
+      assert_equal(initial_cmd_reserve, client.transmit('stats')[:body]['cmd-reserve'], 'Expected cmd-reserve to be unchanged')
+
+      timeout(1) do
+        assert_raises(Beaneater::BadFormatError, 'Expected reserve with args to return BAD_FORMAT') do
+          client.transmit('reserve 1')
+        end
+      end
+      assert_equal(initial_cmd_reserve, client.transmit('stats')[:body]['cmd-reserve'], 'Expected cmd-reserve to be unchanged')
+    end
+
+  end
+
+  context 'reserve-with-timeout' do
+
+    should 'return TIMED_OUT immediately if timeout of zero and no jobs available' do
+      initial_cmd_reserve_with_timeout = client.transmit('stats')[:body]['cmd-reserve-with-timeout']
+      timeout(1) do
+        assert_raises(Beaneater::TimedOutError, 'Expected reserve-with-timeout to timeout') do
+          client.transmit('reserve-with-timeout 0')
+        end
+      end
+      assert_equal(initial_cmd_reserve_with_timeout + 1, client.transmit('stats')[:body]['cmd-reserve-with-timeout'], 'Expected cmd-reserve-with-timeout to be incremented')
+    end
+
+
+    should 'return TIMED_OUT after timeout if no jobs available' do
+      initial_cmd_reserve_with_timeout = client.transmit('stats')[:body]['cmd-reserve-with-timeout']
+      timeout(2) do
+        assert_raises(Beaneater::TimedOutError, 'Expected reserve-with-timeout to timeout') do
+          client.transmit('reserve-with-timeout 1')
+        end
+      end
+      assert_equal(initial_cmd_reserve_with_timeout + 1, client.transmit('stats')[:body]['cmd-reserve-with-timeout'], 'Expected cmd-reserve-with-timeout to be incremented')
+    end
+
+
+    should 'return BAD_FORMAT without space trailing space or timeout' do
+      initial_cmd_reserve_with_timeout = client.transmit('stats')[:body]['cmd-reserve-with-timeout']
+      timeout(2) do
+        assert_raises(Beaneater::BadFormatError, 'Expected reserve-with-timeout to return BAD_FORMAT without trailing space or timeout') do
+          client.transmit('reserve-with-timeout')
+        end
+      end
+      assert_equal(initial_cmd_reserve_with_timeout, client.transmit('stats')[:body]['cmd-reserve-with-timeout'], 'Expected cmd-reserve-with-timeout to be unchanged')
+    end
+
+
+    should 'should coerce non-integer timeouts to zero' do
+      initial_cmd_reserve_with_timeout = client.transmit('stats')[:body]['cmd-reserve-with-timeout']
+      message = uuid
+      job_id = client.transmit("put 0 0 1 #{message.bytesize}\r\n#{message}")[:id]
+      timeout(1) do
+        assert_equal job_id, client.transmit("reserve-with-timeout I really don't think this should be valid.")[:id]
+      end
+      client.transmit("delete #{job_id}")
+      assert_equal(initial_cmd_reserve_with_timeout + 1, client.transmit('stats')[:body]['cmd-reserve-with-timeout'], 'Expected cmd-reserve-with-timeout to be incremented')
+    end
+
+
+    should 'should coerce space with no timeout to zero' do
+      initial_cmd_reserve_with_timeout = client.transmit('stats')[:body]['cmd-reserve-with-timeout']
+      message = uuid
+      job_id = client.transmit("put 0 0 1 #{message.bytesize}\r\n#{message}")[:id]
+      timeout(1) do
+        assert_equal job_id, client.transmit("reserve-with-timeout ")[:id]
+      end
+      client.transmit("delete #{job_id}")
+      assert_equal(initial_cmd_reserve_with_timeout + 1, client.transmit('stats')[:body]['cmd-reserve-with-timeout'], 'Expected cmd-reserve-with-timeout to be incremented')
+    end
+
+
+    should 'should handle negative timeout like normal reserve' do
+      initial_cmd_reserve_with_timeout = client.transmit('stats')[:body]['cmd-reserve-with-timeout']
+      message = uuid
+      client.transmit("watch #{tube_name}")
+      other_client = build_client
+      other_client.transmit("use #{tube_name}")
+
+      reserve_thread = Thread.new do
+        value = nil
+        timeout(2) do
+          value = client.transmit("reserve-with-timeout -1")[:id]
+        end
+        value
+      end
+
+      # Sleep one to verify abs(timeout) not used
+      sleep 1
+      job_id = other_client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")[:id]
+      assert_equal job_id, reserve_thread.value
+      assert_equal(initial_cmd_reserve_with_timeout + 1, client.transmit('stats')[:body]['cmd-reserve-with-timeout'], 'Expected cmd-reserve-with-timeout to be incremented')
+      client.transmit("delete #{job_id}")
+    end
+
+  end
+
+end