beanstalk_integration_tests 0.0.1

data/lib/beanstalk_integration_tests/kick_job_test.rb

@@ -0,0 +1,68 @@
+require 'beanstalk_integration_tests/test_helper'
+
+class KickJobTest < BeanstalkIntegrationTest
+
+  context 'kick-job' do
+
+    setup do
+      client.transmit("use #{tube_name}")
+      client.transmit("watch #{tube_name}")
+    end
+
+
+    should 'kick the specified buried job' do
+      message = uuid
+      {
+        'buried' => create_buried_jobs(1).first,
+        'delayed' => client.transmit("put 0 120 120 #{message.bytesize}\r\n#{message}")[:id],
+      }.each_pair do |job_state, job_id|
+        assert_equal job_state, client.transmit("stats-job #{job_id}")[:body]['state']
+        response = client.transmit("kick-job #{job_id}")
+        assert_equal 'KICKED', response[:status]
+        job_stats = client.transmit("stats-job #{job_id}")[:body]
+        assert_equal('ready', job_stats['state'], "Expected #{job_state} job to be ready after kick")
+        assert_equal(1, job_stats['kicks'], 'Expected job kicks to be incremented')
+        assert_equal tube_name, job_stats['tube']
+      end
+    end
+
+
+    should 'return NOT_FOUND if the job is not in a kickable state' do
+      message = uuid
+      job_id = client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")[:id]
+      response = nil
+      assert_raises(Beaneater::NotFoundError, 'Expected kicking unkickable job to return NOT_FOUND') do
+        response = client.transmit("kick-job #{job_id}")
+      end
+      assert_equal(0, client.transmit("stats-job #{job_id}")[:body]['kicks'], 'Expected job kicks to be unchanged')
+    end
+
+
+    should 'return UNKNOWN_COMMAND unless command followed by space' do
+      assert_raises(Beaneater::UnknownCommandError, 'Expected kick-job without a space to return UNKNOWN_COMMAND') do
+        client.transmit('kick-job')
+      end
+    end
+
+
+    should 'return NOT_FOUND when job_id is null, negative, or non-integer' do
+      ['', -1, 'x'].each do |job_id|
+        assert_raises(Beaneater::NotFoundError, 'Expected kick-job with bad job id to return NOT_FOUND') do
+          client.transmit("kick-job #{job_id}")
+        end
+      end
+    end
+
+
+    should 'ignore trailing space, arguments, and chars' do
+      [' ', ' and ignore these arguments', '_and_ignore_these_letters'].each do |trailer|
+        job_id = create_buried_jobs(1).first
+        client.transmit("kick-job #{job_id}#{trailer}")
+        assert_equal 1, client.transmit("stats-job #{job_id}")[:body]['kicks']
+        client.transmit("delete #{job_id}")
+      end
+    end
+
+  end
+
+end

data/lib/beanstalk_integration_tests/kick_test.rb

@@ -0,0 +1,207 @@
+require 'beanstalk_integration_tests/test_helper'
+
+class KickTest < BeanstalkIntegrationTest
+
+  context 'kick' do
+
+    setup do
+      client.transmit("watch #{tube_name}")
+      client.transmit("use #{tube_name}")
+    end
+
+
+    should 'return UNKNOWN_COMMAND without a space following the command' do
+      initial_cmd_kick = client.transmit('stats')[:body]['cmd-kick']
+      assert_raises(Beaneater::UnknownCommandError, 'Expected kick without a space to return UNKNOWN_COMMAND') do
+        client.transmit('kick')
+      end
+      assert_equal(initial_cmd_kick, client.transmit('stats')[:body]['cmd-kick'], 'Expected cmd-kick to be unchanged')
+    end
+
+
+    should 'return BAD_FORMAT with a null or non-integer bound' do
+      initial_cmd_kick = client.transmit('stats')[:body]['cmd-kick']
+      ['', 'foo'].each do |bound|
+        assert_raises(Beaneater::BadFormatError, 'Expected kick with an invalid bound to return BAD_FORMAT') do
+          client.transmit("kick #{bound}")
+        end
+      end
+      assert_equal(initial_cmd_kick, client.transmit('stats')[:body]['cmd-kick'], 'Expected cmd-kick to be unchanged')
+    end
+
+
+    should 'kick 0 jobs if bound <= 0' do
+      initial_cmd_kick = client.transmit('stats')[:body]['cmd-kick']
+      [0, -5].each_with_index do |bound, index|
+        response = client.transmit("kick #{bound}")
+        assert_equal 'KICKED', response[:status]
+        assert_equal '0', response[:id]
+        assert_equal(initial_cmd_kick + index + 1, client.transmit('stats')[:body]['cmd-kick'], 'Expected cmd-kick to be incremented')
+      end
+    end
+
+
+    should 'kick 0 jobs if no jobs to kick' do
+      initial_cmd_kick = client.transmit('stats')[:body]['cmd-kick']
+      response = client.transmit('kick 1000')
+      assert_equal 'KICKED', response[:status]
+      assert_equal '0', response[:id]
+      assert_equal(initial_cmd_kick + 1, client.transmit('stats')[:body]['cmd-kick'], 'Expected cmd-kick to be incremented')
+    end
+
+
+    should 'only kick jobs in the currently used tube' do
+      initial_cmd_kick = client.transmit('stats')[:body]['cmd-kick']
+      create_buried_jobs
+      5.times do
+        message = uuid
+        client.transmit("put 0 120 120 #{message.bytesize}\r\n#{message}")
+      end
+      other_client = build_client
+      response = other_client.transmit('kick 1000')
+      assert_equal 'KICKED', response[:status]
+      assert_equal '0', response[:id]
+      assert_equal(initial_cmd_kick + 1, client.transmit('stats')[:body]['cmd-kick'], 'Expected cmd-kick to be incremented')
+      assert_equal 0, client.transmit('stats')[:body]['current-jobs-ready']
+      other_client.transmit("use #{tube_name}")
+      other_client.transmit('kick 5')
+      other_client.transmit('kick 5')
+      assert_equal 10, other_client.transmit('stats')[:body]['current-jobs-ready']
+    end
+
+
+    should 'ignore trailing space, arguments, and chars' do
+      create_buried_jobs
+      initial_cmd_kick = client.transmit('stats')[:body]['cmd-kick']
+      [' ', ' and ignore these arguments', '_and_ignore_these_letters'].each do |trailer|
+        response = client.transmit("kick 1#{trailer}")
+        assert_equal 'KICKED', response[:status]
+        assert_equal '1', response[:id]
+        job_id = client.transmit('peek-ready')[:id]
+        assert_equal 1, client.transmit("stats-job #{job_id}")[:body]['kicks']
+        client.transmit("delete #{job_id}")
+      end
+      assert_equal(initial_cmd_kick + 3, client.transmit('stats')[:body]['cmd-kick'], 'Expected cmd-kick to be incremented')
+    end
+
+
+    context 'buried jobs' do
+      should 'kick at most the requested number of jobs' do
+        buried_count = 9
+        job_ids = create_buried_jobs(buried_count)
+        stats = client.transmit('stats')[:body]
+        assert_equal buried_count, stats['current-jobs-buried']
+        assert_equal buried_count, client.transmit("stats-tube #{tube_name}")[:body]['current-jobs-buried']
+        initial_cmd_kick = stats['cmd-kick']
+        kicked = 0
+        [1, 2, 3].each do |slice_size|
+          client.transmit("kick #{slice_size}")
+          kicked += slice_size
+          stats = client.transmit('stats')[:body]
+          assert_equal buried_count - kicked, stats['current-jobs-buried']
+          assert_equal slice_size, stats['current-jobs-ready']
+          slice_size.times do
+            job_id = client.transmit('peek-ready')[:id]
+            assert_equal job_ids.shift, job_id
+            assert_equal(1, client.transmit("stats-job #{job_id}")[:body]['kicks'], 'Expected job kicks to be incremented')
+            client.transmit("delete #{job_id}")
+          end
+        end
+        # Kick 4 with only 3 remaining
+        client.transmit("kick 4")
+        assert_equal 0, client.transmit('stats')[:body]['current-jobs-buried']
+        assert_equal 3, client.transmit('stats')[:body]['current-jobs-ready']
+        assert_equal 0, client.transmit("stats-tube #{tube_name}")[:body]['current-jobs-buried']
+        3.times do
+          job_id = client.transmit('peek-ready')[:id]
+          assert_equal job_ids.shift, job_id
+          assert_equal(1, client.transmit("stats-job #{job_id}")[:body]['kicks'], 'Expected job kicks to be incremented')
+          client.transmit("delete #{job_id}")
+        end
+
+        assert_equal(initial_cmd_kick + 4, client.transmit('stats')[:body]['cmd-kick'], 'Expected cmd-kick to be incremented')
+      end
+
+
+      should 'kick only buried jobs if buried and delayed jobs available' do
+        buried_count = delayed_count = 3
+        buried_job_ids = create_buried_jobs(buried_count)
+        delayed_job_ids = []
+        delayed_count.times do
+          message = uuid
+          delayed_job_ids << client.transmit("put 0 120 120 #{message.bytesize}\r\n#{message}")[:id]
+        end
+        stats = client.transmit('stats')[:body]
+        assert_equal buried_count, stats['current-jobs-buried']
+        assert_equal delayed_count, stats['current-jobs-delayed']
+        initial_cmd_kick = stats['cmd-kick']
+
+        client.transmit("kick #{buried_count + delayed_count}")
+        stats = client.transmit('stats')[:body]
+        assert_equal 0, stats['current-jobs-buried']
+        assert_equal buried_count, stats['current-jobs-ready']
+        assert_equal delayed_count, stats['current-jobs-delayed']
+        buried_count.times do
+          job_id = client.transmit('peek-ready')[:id]
+          assert_equal buried_job_ids.shift, job_id
+          assert_equal(1, client.transmit("stats-job #{job_id}")[:body]['kicks'], 'Expected job kicks to be incremented')
+          client.transmit("delete #{job_id}")
+        end
+        delayed_count.times do
+          job_id = client.transmit('peek-delayed')[:id]
+          assert_equal delayed_job_ids.shift, job_id
+          assert_equal(0, client.transmit("stats-job #{job_id}")[:body]['kicks'], 'Expected job kicks to be unchanged')
+          client.transmit("delete #{job_id}")
+        end
+
+        assert_equal(initial_cmd_kick + 1, client.transmit('stats')[:body]['cmd-kick'], 'Expected cmd-kick to be incremented')
+      end
+
+    end
+
+
+    context 'delayed jobs' do
+      should 'kick at most the requested number of jobs' do
+        delayed_count = 9
+        job_ids = delayed_count.times.map do
+          message = uuid
+          client.transmit("put 0 120 120 #{message.bytesize}\r\n#{message}")[:id]
+        end
+        stats = client.transmit('stats')[:body]
+        assert_equal 0, stats['current-jobs-buried']
+        assert_equal delayed_count, stats['current-jobs-delayed']
+        assert_equal delayed_count, client.transmit("stats-tube #{tube_name}")[:body]['current-jobs-delayed']
+        initial_cmd_kick = stats['cmd-kick']
+        kicked = 0
+        [1, 2, 3].each do |slice_size|
+          client.transmit("kick #{slice_size}")
+          kicked += slice_size
+          stats = client.transmit('stats')[:body]
+          assert_equal delayed_count - kicked, stats['current-jobs-delayed']
+          assert_equal slice_size, stats['current-jobs-ready']
+          slice_size.times do
+            job_id = client.transmit('peek-ready')[:id]
+            assert_equal job_ids.shift, job_id
+            assert_equal(1, client.transmit("stats-job #{job_id}")[:body]['kicks'], 'Expected job kicks to be incremented')
+            client.transmit("delete #{job_id}")
+          end
+        end
+        # Kick 4 with only 3 remaining
+        client.transmit("kick 4")
+        assert_equal 0, client.transmit('stats')[:body]['current-jobs-delayed']
+        assert_equal 3, client.transmit('stats')[:body]['current-jobs-ready']
+        assert_equal 0, client.transmit("stats-tube #{tube_name}")[:body]['current-jobs-delayed']
+        3.times do
+          job_id = client.transmit('peek-ready')[:id]
+          assert_equal job_ids.shift, job_id
+          assert_equal(1, client.transmit("stats-job #{job_id}")[:body]['kicks'], 'Expected job kicks to be incremented')
+          client.transmit("delete #{job_id}")
+        end
+
+        assert_equal(initial_cmd_kick + 4, client.transmit('stats')[:body]['cmd-kick'], 'Expected cmd-kick to be incremented')
+      end
+    end
+
+  end
+
+end

data/lib/beanstalk_integration_tests/list_tube_used_test.rb

@@ -0,0 +1,26 @@
+require 'beanstalk_integration_tests/test_helper'
+
+class ListTubeUsedTest < BeanstalkIntegrationTest
+
+  # Checking if tube is correctly maintained is handled by UseTest
+
+  context 'list-tube-used' do
+
+    should 'should update cmd-list-tube-used' do
+      initial_cmd_list_tube_used = client.transmit('stats')[:body]['cmd-list-tube-used']
+      client.transmit('list-tube-used')
+      assert_equal(initial_cmd_list_tube_used + 1, client.transmit('stats')[:body]['cmd-list-tube-used'], 'Expected cmd-list-tube-used to be incremented')
+    end
+
+
+    should 'return bad_format with trailing space or args' do
+      [' ', ' trailing_arg'].each do |trailer|
+        assert_raises(Beaneater::BadFormatError, 'Expected list-tubes with trailer to return BAD_FORMAT') do
+          client.transmit("list-tube-used#{trailer}")
+        end
+      end
+    end
+
+  end
+
+end

data/lib/beanstalk_integration_tests/list_tubes_test.rb

@@ -0,0 +1,26 @@
+require 'beanstalk_integration_tests/test_helper'
+
+class ListTubesTest < BeanstalkIntegrationTest
+
+  # Checking if tubes are correctly added/removed is handled by UseTest and WatchTest
+
+  context 'list-tubes' do
+
+    should 'should update cmd-list-tubes' do
+      initial_cmd_list_tubes = client.transmit('stats')[:body]['cmd-list-tubes']
+      client.transmit('list-tubes')
+      assert_equal(initial_cmd_list_tubes + 1, client.transmit('stats')[:body]['cmd-list-tubes'], 'Expected cmd-list-tubes to be incremented')
+    end
+
+
+    should 'return bad_format with trailing space or args' do
+      [' ', ' trailing_arg'].each do |trailer|
+        assert_raises(Beaneater::BadFormatError, 'Expected list-tubes with trailer to return BAD_FORMAT') do
+          client.transmit("list-tubes#{trailer}")
+        end
+      end
+    end
+
+  end
+
+end

data/lib/beanstalk_integration_tests/list_tubes_watched_test.rb

@@ -0,0 +1,26 @@
+require 'beanstalk_integration_tests/test_helper'
+
+class ListTubesWatchedTest < BeanstalkIntegrationTest
+
+  # Checking if tubes are correctly added/removed is handled by WatchTest and IgnoreTest
+
+  context 'list-tubes-watched' do
+
+    should 'should update cmd-list-tubes-watched' do
+      initial_cmd_list_tubes_watched = client.transmit('stats')[:body]['cmd-list-tubes-watched']
+      client.transmit('list-tubes-watched')
+      assert_equal(initial_cmd_list_tubes_watched + 1, client.transmit('stats')[:body]['cmd-list-tubes-watched'], 'Expected cmd-list-tubes-watched to be incremented')
+    end
+
+
+    should 'return bad_format with trailing space or args' do
+      [' ', ' trailing_arg'].each do |trailer|
+        assert_raises(Beaneater::BadFormatError, 'Expected list-tubes-watched with trailer to return BAD_FORMAT') do
+          client.transmit("list-tubes-watched#{trailer}")
+        end
+      end
+    end
+
+  end
+
+end

data/lib/beanstalk_integration_tests/pause_tube_test.rb

@@ -0,0 +1,166 @@
+require 'beanstalk_integration_tests/test_helper'
+
+class PauseTubeTest < BeanstalkIntegrationTest
+
+  context 'pause-tube' do
+
+    setup do
+      client.transmit("watch #{tube_name}")
+      client.transmit("use #{tube_name}")
+    end
+
+
+    should 'pause the provided tube for the provided delay' do
+      pause = 120
+      initial_tube_cmd_pause = client.transmit("stats-tube #{tube_name}")[:body]['cmd-pause-tube']
+      response = client.transmit("pause-tube #{tube_name} #{pause}")
+      assert_equal 'PAUSED', response[:status]
+      tube_stats = client.transmit("stats-tube #{tube_name}")[:body]
+      assert_equal pause, tube_stats['pause']
+      assert(tube_stats['pause-time-left'] < pause, 'Expected tube pause-time-left to be less than total pause time')
+      assert_equal(initial_tube_cmd_pause + 1, tube_stats['cmd-pause-tube'], 'Expected tube cmd-pause-tube to be incremented')
+    end
+
+
+    should 'should reduce large delays to mod 2**32' do
+      pause_overflow = 10
+      pause = 2**32 + pause_overflow
+      initial_tube_cmd_pause = client.transmit("stats-tube #{tube_name}")[:body]['cmd-pause-tube']
+      response = client.transmit("pause-tube #{tube_name} #{pause}")
+      assert_equal 'PAUSED', response[:status]
+      tube_stats = client.transmit("stats-tube #{tube_name}")[:body]
+      assert_equal pause_overflow, tube_stats['pause']
+      assert_equal(initial_tube_cmd_pause + 1, tube_stats['cmd-pause-tube'], 'Expected tube cmd-pause-tube to be incremented')
+    end
+
+
+    should 'activate a tube after the timeout has expired' do
+      pause = 1
+      initial_tube_cmd_pause = client.transmit("stats-tube #{tube_name}")[:body]['cmd-pause-tube']
+      response = client.transmit("pause-tube #{tube_name} #{pause}")
+      assert_equal 'PAUSED', response[:status]
+      sleep 1
+      tube_stats = client.transmit("stats-tube #{tube_name}")[:body]
+      assert_equal(0, tube_stats['pause'], 'Expected tube pause to reset after pause expired')
+      assert_equal(0, tube_stats['pause-time-left'], 'Expected tube pause-time-left to reset after pause expired')
+      assert_equal(initial_tube_cmd_pause + 1, tube_stats['cmd-pause-tube'], 'Expected tube cmd-pause-tube to be incremented')
+    end
+
+
+    should 'honor reservations as soon as pause expires' do
+      message = uuid
+      client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")
+      client.transmit("pause-tube #{tube_name} 1")
+
+      tube_stats = client.transmit("stats-tube #{tube_name}")[:body]
+      assert(tube_stats['pause'] != 0, 'Expected tube to be paused')
+      assert_raises(Beaneater::TimedOutError, 'Expected reserve to fail while tube paused') do
+        client.transmit('reserve-with-timeout 0')
+      end
+      tube_stats = client.transmit("stats-tube #{tube_name}")[:body]
+      assert(tube_stats['pause'] != 0, 'Expected tube to be paused')
+      begin
+        job = client.transmit('reserve-with-timeout 2')
+      rescue Beaneater::TimedOutError => e
+        puts 'Tube did not honor reservation in expected period following pause'
+        raise e
+      end
+      assert_equal(message, job[:body], 'Did not reserve expected job')
+      client.transmit("delete #{job[:id]}")
+    end
+
+
+    should 'allow reservations while paused, but not reply' do
+      client.transmit("pause-tube #{tube_name} 120")
+
+      Thread.new do
+        other_client = build_client
+        other_client.transmit("watch #{tube_name}")
+        assert_raises('Beaneater::TimedOutError', 'Expected waiting for paused tube to timeout') do
+          other_client.transmit('reserve-with-timeout 2')
+        end
+      end
+
+      sleep 0.5
+      tube_stats = client.transmit("stats-tube #{tube_name}")[:body]
+      assert_equal(1, tube_stats['current-waiting'])
+    end
+
+
+    should 'accept jobs while paused' do
+      client.transmit("pause-tube #{tube_name} 120")
+      tube_stats = client.transmit("stats-tube #{tube_name}")[:body]
+      assert(tube_stats['pause'] != 0, 'Expected tube to be paused')
+      message = uuid
+      client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")
+      assert_equal(1, client.transmit("stats-tube #{tube_name}")[:body]['current-jobs-ready'], 'Expected paused tube to accept put commands')
+    end
+
+
+    should 'return BAD_FORMAT without trailing space, tube name, or pause' do
+      ['', ' ', " #{tube_name}"].each do |trailer|
+        assert_raises(Beaneater::BadFormatError, 'Expected pause-tube without space/tube name to return BAD_FORMAT') do
+          client.transmit("pause-tube#{trailer}")
+        end
+      end
+    end
+
+
+    should 'be able to handle tube name of maximum length' do
+      name = 'c' * 200
+      response = client.transmit("watch #{name}")
+      response = client.transmit("pause-tube #{name} 10")
+      assert_equal 'PAUSED', response[:status]
+      tube_stats = client.transmit("stats-tube #{name}")[:body]
+      assert(tube_stats['pause'] != 0, 'Expected tube to be paused')
+    end
+
+
+    should 'return BAD_FORMAT if tube name > 200 bytes' do
+      assert_raises Beaneater::BadFormatError do
+        client.transmit("pause-tube #{'x' * 201} 10")
+      end
+    end
+
+
+    should 'return BAD_FORMAT if line has a trailing space' do
+      initital_cmd_pause_tube = client.transmit("stats-tube #{tube_name}")[:body]['cmd-pause-tube']
+      assert_raises Beaneater::BadFormatError do
+        client.transmit("pause-tube #{tube_name} 10 ")
+      end
+      assert_equal(initital_cmd_pause_tube, client.transmit("stats-tube #{tube_name}")[:body]['cmd-pause-tube'], 'Expected cmd-pause-tube to be unchanged')
+    end
+
+
+    should 'return BAD_FORMAT if tube name includes invalid characters or starts with hyphen' do
+      valid_chars = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a + %w[- + / ; . $ _ ( )] + [' ']
+      # Beanstalk hangs on char 13
+      bad_chars = (0..12).to_a.concat((14..255).to_a).to_a.map!(&:chr) - valid_chars
+
+      assert_raises(Beaneater::BadFormatError, 'Expected tube name starting with hyphen to be invalid') do
+        client.transmit('pause-tube -starts-with-hyphen 10')
+      end
+
+      bad_chars.each do |bad_char|
+        assert_raises(Beaneater::BadFormatError, "Expected tube name with char #{bad_char} to be invalid") do
+          client.transmit("pause-tube name_with_#{bad_char}_in_it 10")
+        end
+      end
+    end
+
+
+    should 'should be able to handle tube name of max length with delay of max length' do
+      pause = 2**32 - 1
+      name = 'c' * 200
+      initial_tube_cmd_pause = client.transmit("stats-tube #{tube_name}")[:body]['cmd-pause-tube']
+      client.transmit("watch #{name}")
+      response = client.transmit("pause-tube #{name} #{pause}")
+      assert_equal 'PAUSED', response[:status]
+      tube_stats = client.transmit("stats-tube #{name}")[:body]
+      assert_equal pause, tube_stats['pause']
+      assert_equal(initial_tube_cmd_pause + 1, tube_stats['cmd-pause-tube'], 'Expected tube cmd-pause-tube to be incremented')
+    end
+
+  end
+
+end