beanstalk_integration_tests 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Danny Guinther
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+# BeanstalkIntegrationTests
+
+A suite of integration tests to test adherence to the Beanstalkd protocol (https://github.com/kr/beanstalkd/blob/master/doc/protocol.md).
+
+Some tests will fail at present (as of version 1.9+9+g157d88b or https://github.com/kr/beanstalkd/commit/157d88bf9435a23b71a1940a9afb617e52a2b9e9). I maybe incorrect, but I believe these are related to previously undiagnosed bugs in the current version of beanstalkd.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'beanstalk_integration_tests'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install beanstalk_integration_tests
+
+
+## Usage
+
+Start your beanstalkd server on 127.0.0.1:11300 or localhost:11300
+
+Run integration tests:
+
+    $ rake
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib/beanstalk_integration_tests'
+  t.pattern = 'lib/beanstalk_integration_tests/**/*_test.rb'
+end
+
+task :default => :test

data/beanstalk_integration_tests.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'beanstalk_integration_tests/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'beanstalk_integration_tests'
+  spec.version       = BeanstalkIntegrationTests::VERSION
+  spec.authors       = ['Danny Guinther']
+  spec.email         = ['dannyguinther@gmail.com']
+  spec.description   = %q{Integration tests for testing adherence to the beanstalkd protocol}
+  spec.summary       = %q{Beanstalk protocol integration tests}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^lib/beanstalk_integration_tests/test/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'beaneater'
+  spec.add_development_dependency 'minitest_should'
+  spec.add_development_dependency 'mocha'
+end

data/lib/beanstalk_integration_tests.rb

@@ -0,0 +1,2 @@
+require 'beanstalk_integration_tests/version'
+require 'beanstalk_integration_tests/test_helper'

data/lib/beanstalk_integration_tests/bury_test.rb

@@ -0,0 +1,137 @@
+require 'beanstalk_integration_tests/test_helper'
+
+class BuryTest < BeanstalkIntegrationTest
+
+  context 'bury of reserved job' do
+
+    setup do
+      message = uuid
+      client.transmit("use #{tube_name}")
+      client.transmit("watch #{tube_name}")
+      client.transmit("put 0 0 10 #{message.bytesize}\r\n#{message}")
+      timeout(2) do
+        @reserved_id = client.transmit('reserve')[:id]
+      end
+    end
+
+    should 'bury a reserved job' do
+      response = client.transmit("bury #{@reserved_id} 0")
+      assert_equal 'BURIED', response[:status]
+      assert_equal 'buried', client.transmit("stats-job #{@reserved_id}")[:body]['state']
+    end
+
+
+    should 'bury a reserved job if the job deadline is approaching' 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
+      response = client.transmit("bury #{@reserved_id} 0")
+      assert_equal 'BURIED', response[:status]
+      assert_equal 'buried', client.transmit("stats-job #{@reserved_id}")[:body]['state']
+    end
+
+
+    should 'bury a reserved job with the given priority' do
+      pri = 1023
+      response = client.transmit("bury #{@reserved_id} #{pri}")
+      assert_equal 'BURIED', response[:status]
+      job_stats = client.transmit("stats-job #{@reserved_id}")[:body]
+      assert_equal 'buried', job_stats['state']
+      assert_equal pri, job_stats['pri']
+    end
+
+
+    should 'increment buries count for job, current-jobs-buried for tube and server, and server cmd-bury counts' do
+      initial_job_buries = client.transmit("stats-job #{@reserved_id}")[:body]['buries']
+      initial_tube_jobs_buried = client.transmit("stats-tube #{tube_name}")[:body]['current-jobs-buried']
+      server_stats = client.transmit('stats')[:body]
+      initial_server_cmd_bury = server_stats['cmd-bury']
+      initial_server_jobs_buried = server_stats['current-jobs-buried']
+
+      response = client.transmit("bury #{@reserved_id} 0")
+      assert_equal 'BURIED', response[:status]
+      assert_equal 'buried', client.transmit("stats-job #{@reserved_id}")[:body]['state']
+
+      assert_equal initial_job_buries + 1, client.transmit("stats-job #{@reserved_id}")[:body]['buries']
+      assert_equal initial_tube_jobs_buried + 1, client.transmit("stats-tube #{tube_name}")[:body]['current-jobs-buried']
+      server_stats = client.transmit('stats')[:body]
+      assert_equal initial_server_cmd_bury + 1, server_stats['cmd-bury']
+      assert_equal initial_server_jobs_buried + 1, server_stats['current-jobs-buried']
+    end
+
+
+    should 'return NOT_FOUND when burying a job that the client has not reserved' do
+      initial_cmd_bury = client.transmit('stats')[:body]['cmd-bury']
+      client.transmit("release #{@reserved_id} 0 0")
+      assert_raises(Beaneater::NotFoundError, 'Expected bury of unreserved job to raise error') do
+        client.transmit("bury #{@reserved_id} 0")
+      end
+      assert_equal(initial_cmd_bury + 1, client.transmit('stats')[:body]['cmd-bury'], 'Expected cmd-bury to be incremented')
+    end
+
+
+    should 'return NOT_FOUND when burying a job reserved by another client' do
+      initial_cmd_bury = client.transmit('stats')[:body]['cmd-bury']
+      assert_raises(Beaneater::NotFoundError, 'Expected bury of job reserved by another client to raise error') do
+        build_client.transmit("bury #{@reserved_id} 0")
+      end
+      client.transmit("delete #{@reserved_id}")
+      assert_equal(initial_cmd_bury + 1, client.transmit('stats')[:body]['cmd-bury'], 'Expected cmd-bury to be incremented')
+    end
+
+
+    should 'return BAD_FORMAT if job_id or priority are not integers' do
+      initial_cmd_bury = client.transmit('stats')[:body]['cmd-bury']
+      assert_raises(Beaneater::BadFormatError, 'Expected bury of non-integer job_id to raise error') do
+        client.transmit("bury foo 0")
+      end
+
+      assert_raises(Beaneater::BadFormatError, 'Expected bury with non-integer priority to raise error') do
+        client.transmit("bury #{@reserved_id} foo")
+      end
+      client.transmit("delete #{@reserved_id}")
+      assert_equal(initial_cmd_bury, client.transmit('stats')[:body]['cmd-bury'], 'Expected cmd-bury to remain the same')
+    end
+  end
+
+  context 'bury not requiring reserved job' do
+    should 'return NOT_FOUND when burying a job with an ID <= 0' do
+      (-1..0).each do |job_id|
+        assert_raises(Beaneater::NotFoundError, "Expected bury of job_id #{job_id} to raise NOT_FOUND error") do
+          build_client.transmit("bury #{job_id} 0")
+        end
+      end
+    end
+
+
+    should 'return BAD_FORMAT if priority is negative' do
+      assert_raises(Beaneater::BadFormatError, 'Expected bury with negative timeout to raise error') do
+        client.transmit("bury 1 -1")
+      end
+    end
+
+
+    should 'return BAD_FORMAT if line includes trailing space' do
+      assert_raises(Beaneater::BadFormatError, 'Expected bury with trailing space to raise error') do
+        client.transmit("bury 1 1 ")
+      end
+    end
+
+
+    should 'return BAD_FORMAT if excess arguments' do
+      assert_raises(Beaneater::BadFormatError, 'Expected bury with excess arguments to raise error') do
+        client.transmit("bury 1 1 1")
+      end
+    end
+
+  end
+
+end

data/lib/beanstalk_integration_tests/delete_test.rb

@@ -0,0 +1,160 @@
+require 'beanstalk_integration_tests/test_helper'
+
+class DeleteTest < BeanstalkIntegrationTest
+
+  setup do
+    client.transmit("use #{tube_name}")
+    client.transmit("watch #{tube_name}")
+    @message = uuid
+  end
+
+
+  context 'delete' do
+
+    should 'delete a job that is ready' do
+      initial_server_cmd_delete = client.transmit('stats')[:body]['cmd-delete']
+      initial_tube_cmd_delete = client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete']
+      job_id = client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")[:id]
+      response = client.transmit("delete #{job_id}")
+      assert_equal 'DELETED', response[:status]
+      assert_equal(initial_server_cmd_delete + 1, client.transmit('stats')[:body]['cmd-delete'], 'Expected server cmd-delete to be incremented')
+      assert_equal(initial_tube_cmd_delete + 1, client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete'], 'Expected tube cmd-delete to be incremented')
+
+      assert_raises(Beaneater::NotFoundError, 'Expected deleted job to not be found') do
+        client.transmit("peek #{job_id}")
+      end
+    end
+
+
+    should 'delete a job that is buried' do
+      job_id = client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")[:id]
+      timeout(2) do
+        client.transmit('reserve')
+      end
+      bury_response = client.transmit("bury #{job_id} 120")
+      assert_equal 'BURIED', bury_response[:status]
+      initial_server_cmd_delete = client.transmit('stats')[:body]['cmd-delete']
+      initial_tube_cmd_delete = client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete']
+      response = client.transmit("delete #{job_id}")
+      assert_equal 'DELETED', response[:status]
+      assert_equal(initial_server_cmd_delete + 1, client.transmit('stats')[:body]['cmd-delete'], 'Expected server cmd-delete to be incremented')
+      assert_equal(initial_tube_cmd_delete + 1, client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete'], 'Expected tube cmd-delete to be incremented')
+
+      assert_raises(Beaneater::NotFoundError, 'Expected deleted job to not be found') do
+        client.transmit("peek #{job_id}")
+      end
+    end
+
+
+    should 'delete a job that is delayed' do
+      job_id = client.transmit("put 0 120 120 #{@message.bytesize}\r\n#{@message}")[:id]
+      initial_server_cmd_delete = client.transmit('stats')[:body]['cmd-delete']
+      initial_tube_cmd_delete = client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete']
+      response = client.transmit("delete #{job_id}")
+      assert_equal 'DELETED', response[:status]
+      assert_equal(initial_server_cmd_delete + 1, client.transmit('stats')[:body]['cmd-delete'], 'Expected server cmd-delete to be incremented')
+      assert_equal(initial_tube_cmd_delete + 1, client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete'], 'Expected tube cmd-delete to be incremented')
+
+      assert_raises(Beaneater::NotFoundError, 'Expected deleted job to not be found') do
+        client.transmit("peek #{job_id}")
+      end
+    end
+
+
+    should 'delete a job that is reserved by the client' do
+      job_id = client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")[:id]
+      timeout(2) do
+        client.transmit('reserve')
+      end
+      initial_server_cmd_delete = client.transmit('stats')[:body]['cmd-delete']
+      initial_tube_cmd_delete = client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete']
+      response = client.transmit("delete #{job_id}")
+      assert_equal 'DELETED', response[:status]
+      assert_equal(initial_server_cmd_delete + 1, client.transmit('stats')[:body]['cmd-delete'], 'Expected server cmd-delete to be incremented')
+      assert_equal(initial_tube_cmd_delete + 1, client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete'], 'Expected tube cmd-delete to be incremented')
+      assert_raises(Beaneater::NotFoundError, 'Expected deleted job to not be found') do
+        client.transmit("peek #{job_id}")
+      end
+    end
+
+
+    should 'not delete a job that is deleted' do
+      job_id = client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")[:id]
+      initial_server_cmd_delete = client.transmit('stats')[:body]['cmd-delete']
+      initial_tube_cmd_delete = client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete']
+      response = client.transmit("delete #{job_id}")
+      assert_equal 'DELETED', response[:status]
+      assert_raises(Beaneater::NotFoundError, 'Expected deleted job to not be found') do
+        client.transmit("delete #{job_id}")
+      end
+      assert_equal(initial_server_cmd_delete + 2, client.transmit('stats')[:body]['cmd-delete'], 'Expected server cmd-delete to be incremented')
+      assert_equal(initial_tube_cmd_delete + 1, client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete'], 'Expected tube cmd-delete to be incremented')
+    end
+
+
+    should 'not delete a job that is reserved by another client' do
+      client2 = build_client
+      client2.transmit("watch #{tube_name}")
+      job_id = client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")[:id]
+      timeout(2) do
+        client2.transmit('reserve')
+      end
+      initial_server_cmd_delete = client.transmit('stats')[:body]['cmd-delete']
+      initial_tube_cmd_delete = client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete']
+      assert_raises(Beaneater::NotFoundError, 'Expected deleted job to not be found') do
+        client.transmit("delete #{job_id}")
+      end
+      client2.transmit("delete #{job_id}")
+      assert_equal(initial_server_cmd_delete + 2, client.transmit('stats')[:body]['cmd-delete'], 'Expected server cmd-delete to be incremented')
+      assert_equal(initial_tube_cmd_delete + 1, client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete'], 'Expected tube cmd-delete to be incremented')
+    end
+
+
+    should 'return UNKNOWN_COMMAND without a space and job_id' do
+      initial_server_cmd_delete = client.transmit('stats')[:body]['cmd-delete']
+      assert_raises(Beaneater::UnknownCommandError, 'Expected delete with out space and job_id to raise UNKNOWN_COMMAND') do
+        client.transmit('delete')
+      end
+      assert_equal(initial_server_cmd_delete, client.transmit('stats')[:body]['cmd-delete'], 'Expected server cmd-delete to be unchanged')
+    end
+
+
+    should 'return NOT_FOUND with a space but without a job_id' do
+      initial_server_cmd_delete = client.transmit('stats')[:body]['cmd-delete']
+      assert_raises(Beaneater::NotFoundError, 'Expected delete with space but without job_id to raise NOT_FOUND') do
+        client.transmit('delete ')
+      end
+      assert_equal(initial_server_cmd_delete + 1, client.transmit('stats')[:body]['cmd-delete'], 'Expected server cmd-delete to be incremented')
+    end
+
+
+    should 'ignore extraneous parameters' do
+      job_id = client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")[:id]
+      initial_server_cmd_delete = client.transmit('stats')[:body]['cmd-delete']
+      initial_tube_cmd_delete = client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete']
+      response = client.transmit("delete #{job_id} but don't care about these params")
+      assert_equal 'DELETED', response[:status]
+      assert_raises(Beaneater::NotFoundError, 'Expected delete with extraneous parameters to raise NOT_FOUND for deleted job') do
+        client.transmit("delete #{job_id} but ignore these params")
+      end
+      assert_equal(initial_server_cmd_delete + 2, client.transmit('stats')[:body]['cmd-delete'], 'Expected server cmd-delete to be incremented')
+      assert_equal(initial_tube_cmd_delete + 1, client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete'], 'Expected tube cmd-delete to be incremented')
+    end
+
+
+    should 'ignore characters following a valid number' do
+      job_id = client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")[:id]
+      initial_server_cmd_delete = client.transmit('stats')[:body]['cmd-delete']
+      initial_tube_cmd_delete = client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete']
+      response = client.transmit("delete #{job_id}_but_ignore_these_words")
+      assert_equal 'DELETED', response[:status]
+      assert_raises(Beaneater::NotFoundError, 'Expected delete with extraneous parameters to raise NOT_FOUND for deleted job') do
+        client.transmit("delete #{job_id}_but_ignore_these_words")
+      end
+      assert_equal(initial_server_cmd_delete + 2, client.transmit('stats')[:body]['cmd-delete'], 'Expected server cmd-delete to be incremented')
+      assert_equal(initial_tube_cmd_delete + 1, client.transmit("stats-tube #{tube_name}")[:body]['cmd-delete'], 'Expected tube cmd-delete to be incremented')
+    end
+
+  end
+
+end

data/lib/beanstalk_integration_tests/ignore_test.rb

@@ -0,0 +1,127 @@
+require 'beanstalk_integration_tests/test_helper'
+
+class IgnoreTest < BeanstalkIntegrationTest
+
+  context 'ignore' do
+
+    context 'when a tube is watched' do
+
+      setup do
+        client.transmit("watch #{tube_name}")
+
+        # Use a second client to keep tube open
+        @other_client = build_client
+        @other_client.transmit("watch #{tube_name}")
+      end
+
+
+      should 'ignore the provided tube' do
+        initial_cmd_ignore = client.transmit('stats')[:body]['cmd-ignore']
+        initial_tube_watching = client.transmit("stats-tube #{tube_name}")[:body]['current-watching']
+        assert(client.transmit('list-tubes-watched')[:body].include?(tube_name), 'Expected watched tube to be listed in list-tubes-watched')
+        response = client.transmit("ignore #{tube_name}")
+        assert_equal 'WATCHING', response[:status]
+        assert_equal '1', response[:id]
+        refute(client.transmit('list-tubes-watched')[:body].include?(tube_name), 'Expected ignore to remove tube from list-tubes-watched')
+        assert_equal(initial_cmd_ignore + 1, client.transmit('stats')[:body]['cmd-ignore'], 'Expected cmd-ignore to be incremented')
+        assert_equal(initial_tube_watching - 1, client.transmit("stats-tube #{tube_name}")[:body]['current-watching'], 'Expected tube current-watching to be decremented')
+
+        @other_client.transmit("ignore #{tube_name}")
+        assert_equal(initial_cmd_ignore + 2, client.transmit('stats')[:body]['cmd-ignore'], 'Expected cmd-ignore to be incremented')
+        assert_raises(Beaneater::NotFoundError, 'Expected unwatched tube to be destroyed') do
+          client.transmit("stats-tube #{tube_name}")
+        end
+        refute(client.transmit('list-tubes')[:body].include?(tube_name), 'Expected ignore to remove tube from list-tubes')
+      end
+
+
+      should 'not ignore the provided tube if no other tubes are watched' do
+        initial_cmd_ignore = client.transmit('stats')[:body]['cmd-ignore']
+        initial_tube_watching = client.transmit("stats-tube #{tube_name}")[:body]['current-watching']
+        client.transmit('ignore default')
+        assert_raises(Beaneater::NotIgnoredError, 'Expected ignoring last watched tube to return NOT_IGNORED') do
+          client.transmit("ignore #{tube_name}")
+        end
+        assert(client.transmit('list-tubes-watched')[:body].include?(tube_name), 'Expected watched tube to be listed in list-tubes-watched')
+        assert_equal(initial_cmd_ignore + 2, client.transmit('stats')[:body]['cmd-ignore'], 'Expected cmd-ignore to be incremented')
+        assert_equal(initial_tube_watching, client.transmit("stats-tube #{tube_name}")[:body]['current-watching'], 'Expected tube current-watching to be unchanged')
+      end
+
+
+      should 'return count of tubes watched when ignoring unwatched or non-existent tube' do
+        %w[unwatched non-existant].each do |name|
+          initial_cmd_ignore = client.transmit('stats')[:body]['cmd-ignore']
+          response = client.transmit("ignore #{name}")
+          assert_equal 'WATCHING', response[:status]
+          assert_equal '2', response[:id]
+          assert_equal(initial_cmd_ignore + 1, client.transmit('stats')[:body]['cmd-ignore'], "Expected cmd-ignore to be incremented when ignoring #{name} tube")
+        end
+      end
+
+
+      should 'return UNKNOWN_COMMAND if command does not include space' do
+        assert_raises(Beaneater::UnknownCommandError, 'Expected ignore without space to return UNKNOWN_COMMAND') do
+          client.transmit('ignore')
+        end
+      end
+
+
+      should 'return BAD_FORMAT if tube name is not provided' do
+        assert_raises(Beaneater::BadFormatError, 'Expected ignore without tube name to return BAD_FORMAT') do
+          client.transmit('ignore ')
+        end
+      end
+
+
+      should 'be able to handle tube name of maximum length' do
+        name = 'c' * 200
+        initial_watch_count = client.transmit('list-tubes-watched')[:body].length
+        client.transmit("watch #{name}")
+        response = client.transmit("ignore #{name}")
+        assert_equal 'WATCHING', response[:status]
+        assert_equal initial_watch_count.to_s, response[:id]
+      end
+
+
+      should 'return BAD_FORMAT if tube name > 200 bytes' do
+        initital_cmd_ignore = client.transmit('stats')[:body]['cmd-ignore']
+        assert_raises Beaneater::BadFormatError do
+          client.transmit("ignore #{'x' * 201}")
+        end
+        # Use other client because extra long tube name leaves client in weird state
+        assert_equal(initital_cmd_ignore, build_client.transmit('stats')[:body]['cmd-ignore'], 'Expected cmd-ignore to be unchanged')
+      end
+
+
+      should 'return BAD_FORMAT if line has a trailing space' do
+        initital_cmd_ignore = client.transmit('stats')[:body]['cmd-ignore']
+        assert_raises Beaneater::BadFormatError do
+          client.transmit("ignore #{tube_name} ")
+        end
+        assert_equal(initital_cmd_ignore, client.transmit('stats')[:body]['cmd-ignore'], 'Expected cmd-ignore to be unchanged')
+      end
+
+
+      should 'return BAD_FORMAT if tube name includes invalid characters or starts with hyphen' do
+        initital_cmd_ignore = client.transmit('stats')[:body]['cmd-ignore']
+        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('ignore -starts-with-hyphen')
+        end
+        assert_equal(initital_cmd_ignore, client.transmit('stats')[:body]['cmd-ignore'], 'Expected cmd-ignore to be unchanged')
+
+        bad_chars.each do |bad_char|
+          assert_raises(Beaneater::BadFormatError, "Expected tube name with char #{bad_char} to be invalid") do
+            client.transmit("ignore name_with_#{bad_char}_in_it")
+          end
+        end
+        assert_equal(initital_cmd_ignore, client.transmit('stats')[:body]['cmd-ignore'], 'Expected cmd-ignore to be unchanged')
+      end
+    end
+
+  end
+
+end