stalk_climber 0.0.6 → 0.1.0

data/test/unit/climber_enumerable.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class ClimberEnumerableTest < StalkClimber::TestCase
+
+  # Bulk of testing left to derived classes
+
+  context '::new' do
+
+    should 'return a new class with the specified enumerator method' do
+      klass = StalkClimber::ClimberEnumerable.new(:foo)
+      assert klass.included_modules.include?(StalkClimber::ClimberEnumerable), 'Expected ClimberEnumerable based class to include ClimberEnumerable'
+      assert(klass.respond_to?(:enumerator_method), 'Expected ClimberEnumerable based class to implement :enumerator_method')
+      assert_equal :foo, klass.enumerator_method
+    end
+
+  end
+
+end

data/test/unit/climber_test.rb

@@ -1,136 +1,67 @@
 require 'test_helper'
 
-class ClimberTest < Test::Unit::TestCase
+class ClimberTest < StalkClimber::TestCase
 
-  def test_each_caches_jobs_for_later_use
-    climber = StalkClimber::Climber.new(BEANSTALK_ADDRESSES)
+  context '#connection_pool' do
 
-    test_jobs = {}
-    climber.connection_pool.connections.each do |connection|
-      test_jobs[connection.address] = []
-      5.times.to_a.map! do
-          test_jobs[connection.address] << StalkClimber::Job.new(connection.transmit(StalkClimber::Connection::PROBE_TRANSMISSION))
-      end
+    should 'create a ConnectionPool' do
+      climber = StalkClimber::Climber.new('beanstalk://localhost')
+      assert_kind_of StalkClimber::ConnectionPool, climber.connection_pool
     end
 
-    jobs = {}
-    climber.each do |job|
-      jobs[job.connection.address] ||= {}
-      jobs[job.connection.address][job.id] = job
-    end
 
-    climber.expects(:with_job).never
-    climber.each do |job|
-      assert_equal jobs[job.connection.address][job.id], job
+    should 'raise an error without beanstalk addresses' do
+      climber = StalkClimber::Climber.new
+      assert_raises RuntimeError do
+        climber.connection_pool
+      end
     end
 
-    climber.connection_pool.connections.each do |connection|
-      test_jobs[connection.address].map(&:delete)
-    end
   end
 
 
-  def test_each_threaded_works_for_non_break_situation
-    climber = StalkClimber::Climber.new(BEANSTALK_ADDRESSES)
-    test_jobs = {}
-    climber.connection_pool.connections.each do |connection|
-      test_jobs[connection.address] = []
-      5.times.to_a.map! do
-          test_jobs[connection.address] << StalkClimber::Job.new(connection.transmit(StalkClimber::Connection::PROBE_TRANSMISSION))
-      end
-    end
+  context 'max_job_ids' do
 
-    assert_nothing_raised do
-      # test normal enumeration
-      climber.each_threaded do |job|
-        job
+    should 'return correct max job ids' do
+      climber = StalkClimber::Climber.new(BEANSTALK_ADDRESSES, 'test_tube')
+      max_ids = climber.max_job_ids
+      max_ids.each do |connection, max_id|
+        assert_equal connection.max_job_id - 1, max_id
       end
     end
 
-    climber.connection_pool.connections.each do |connection|
-      test_jobs[connection.address].map(&:delete)
-    end
   end
 
 
-  def test_connection_pool_creates_a_connection_pool
-    climber = StalkClimber::Climber.new('beanstalk://localhost')
-    assert_kind_of StalkClimber::ConnectionPool, climber.connection_pool
-  end
-
+  context '#jobs' do
 
-  def test_connection_pool_raises_an_error_without_beanstalk_addresses
-    climber = StalkClimber::Climber.new
-    assert_raise RuntimeError do
-      climber.connection_pool
+    should 'return an instance of Jobs' do
+      assert_kind_of StalkClimber::Jobs, StalkClimber::Climber.new(BEANSTALK_ADDRESSES).jobs
     end
-  end
 
+  end
 
-  def test_enumerable_works_correctly
-    climber = StalkClimber::Climber.new(BEANSTALK_ADDRESSES)
-    test_jobs = {}
-    climber.connection_pool.connections.each do |connection|
-      test_jobs[connection.address] = []
-      5.times.to_a.map! do
-          test_jobs[connection.address] << StalkClimber::Job.new(connection.transmit(StalkClimber::Connection::PROBE_TRANSMISSION))
-      end
-    end
-
-    assert_nothing_raised do
-      # verify enumeration can be short circuited
-      climber.any? do |job|
-        true
-      end
 
-      # test normal enumeration
-      climber.all? do |job|
-        job
-      end
-    end
+  context '#initialize' do
 
-    climber.connection_pool.connections.each do |connection|
-      test_jobs[connection.address].map(&:delete)
+    should 'accept a custom test tube' do
+      climber = StalkClimber::Climber.new(BEANSTALK_ADDRESSES, 'test_tube')
+      assert_equal 'test_tube', climber.test_tube
+      assert_equal 'test_tube', climber.connection_pool.test_tube
     end
-  end
-
 
-  def test_each_is_an_alias_for_climb
-    assert_equal(
-      StalkClimber::Climber.instance_method(:climb),
-      StalkClimber::Climber.instance_method(:each),
-      'Expected StalkClimber::Climber#each to be an alias for StalkClimber::Climber#climb'
-    )
   end
 
 
-  def test_each_threaded_is_an_alias_for_climb_threaded
-    assert_equal(
-      StalkClimber::Climber.instance_method(:climb_threaded),
-      StalkClimber::Climber.instance_method(:each_threaded),
-      'Expected StalkClimber::Climber#each_threaded to be an alias for StalkClimber::Climber#climb_threaded'
-    )
-  end
+  context '#tubes' do
 
-
-  def test_max_job_ids_returns_the_correct_max_job_ids
-    climber = StalkClimber::Climber.new(BEANSTALK_ADDRESSES, 'test_tube')
-    max_ids = climber.max_job_ids
-    max_ids.each do |connection, max_id|
-      assert_equal connection.max_job_id - 1, max_id
+    should 'delegate to connection_pool for tubes' do
+      climber = StalkClimber::Climber.new(BEANSTALK_ADDRESSES, 'test_tube')
+      connection_pool = climber.connection_pool
+      connection_pool.expects(:tubes).once
+      climber.tubes
     end
-  end
-
-
-  def test_to_enum_returns_an_enumerator
-    assert_kind_of Enumerator, StalkClimber::Climber.new(BEANSTALK_ADDRESSES).to_enum
-  end
-
 
-  def test_with_a_test_tube
-    climber = StalkClimber::Climber.new(BEANSTALK_ADDRESSES, 'test_tube')
-    assert_equal 'test_tube', climber.test_tube
-    assert_equal 'test_tube', climber.connection_pool.test_tube
   end
 
 end

data/test/unit/connection_pool_test.rb

@@ -3,54 +3,69 @@
 
 require 'test_helper'
 
-class ConnectionPoolTest < Test::Unit::TestCase
+class ConnectionPoolTest < StalkClimber::TestCase
 
-  def test_for_bad_url_it_should_raise_a_bad_url_error
-    assert_raises(StalkClimber::ConnectionPool::InvalidURIScheme) do
-      StalkClimber::ConnectionPool.new('fake://foo')
+  context '#initialize' do
+
+    should 'test for bad url and raise StalkClimber::ConnectionPool::InvalidURIScheme' do
+      assert_raises(StalkClimber::ConnectionPool::InvalidURIScheme) do
+        StalkClimber::ConnectionPool.new('fake://foo')
+      end
     end
-  end
 
 
-  def test_for_delegated_methods_it_should_delegate_methods_to_beanstalk_connection
-    connection_pool = StalkClimber::ConnectionPool.new('beanstalk://localhost')
-    assert_equal 'localhost', connection_pool.connections.first.host
-  end
+    should 'support multiple connections when passed as an array' do
+      connection_pool = StalkClimber::ConnectionPool.new(['beanstalk://localhost:11300','beanstalk://localhost'])
+      connections = connection_pool.connections
+      assert_equal 2, connection_pool.connections.size
+      assert_equal ['localhost:11300','localhost:11300'], connections.map(&:address)
+    end
 
 
-  def test_with_multiple_urls_it_should_support_array_of_connections
-    connection_pool = StalkClimber::ConnectionPool.new(['beanstalk://localhost:11300','beanstalk://localhost'])
-    connections = connection_pool.connections
-    assert_equal 2, connection_pool.connections.size
-    assert_equal ['localhost:11300','localhost:11300'], connections.map(&:address)
-  end
+    should 'support multiple connections when passed as a comma separated string' do
+      connection_pool = StalkClimber::ConnectionPool.new('beanstalk://localhost:11300,beanstalk://localhost')
+      connections = connection_pool.connections
+      assert_equal 2, connections.size
+      assert_equal ['localhost:11300','localhost:11300'], connections.map(&:address)
+    end
 
 
-  def test_with_multiple_urls_it_should_support_single_string_with_commas
-    connection_pool = StalkClimber::ConnectionPool.new('beanstalk://localhost:11300,beanstalk://localhost')
-    connections = connection_pool.connections
-    assert_equal 2, connections.size
-    assert_equal ['localhost:11300','localhost:11300'], connections.map(&:address)
-  end
+    should 'support a single connection url passed as a string' do
+      connection_pool = StalkClimber::ConnectionPool.new('beanstalk://localhost')
+      assert_kind_of StalkClimber::ConnectionPool, connection_pool
+      assert_kind_of Beaneater::Pool, connection_pool
+    end
 
 
-  def test_with_single_url_it_should_set_up_connection_pool
-    connection_pool = StalkClimber::ConnectionPool.new('beanstalk://localhost')
-    assert_kind_of StalkClimber::ConnectionPool, connection_pool
-    assert_kind_of Beaneater::Pool, connection_pool
-  end
+    should 'convert a single connection url into an array' do
+      connection_pool = StalkClimber::ConnectionPool.new('beanstalk://localhost')
+      assert_equal ['localhost:11300'], connection_pool.addresses
+    end
+
+
+    should 'support multiple URL formats' do
+      connection_pool = StalkClimber::ConnectionPool.new('127.0.0.1,0.0.0.0:11301,beanstalk://localhost:11300')
+      connections = connection_pool.connections
+      assert_equal 3, connections.size
+      assert_equal ['127.0.0.1:11300','0.0.0.0:11301', 'localhost:11300'], connections.map(&:address)
+    end
 
 
-  def test_with_a_single_url_it_should_convert_url_to_address_array
-    connection_pool = StalkClimber::ConnectionPool.new('beanstalk://localhost')
-    assert_equal ['localhost:11300'], connection_pool.addresses
+    should 'support using a custom test tube' do
+      connection_pool = StalkClimber::ConnectionPool.new('beanstalk://localhost', 'test_tube')
+      assert_equal 'test_tube', connection_pool.test_tube
+      assert connection_pool.connections.all? { |connection| connection.test_tube == 'test_tube' }
+    end
   end
 
 
-  def test_with_a_test_tube
-    connection_pool = StalkClimber::ConnectionPool.new('beanstalk://localhost', 'test_tube')
-    assert_equal 'test_tube', connection_pool.test_tube
-    assert connection_pool.connections.all? { |connection| connection.test_tube == 'test_tube' }
+  context 'delegations' do
+
+    should 'delegate methods to beanstalk connection' do
+      connection_pool = StalkClimber::ConnectionPool.new('beanstalk://localhost')
+      assert_equal 'localhost', connection_pool.connections.first.host
+    end
+
   end
 
 end

data/test/unit/connection_test.rb

@@ -1,251 +1,302 @@
 require 'test_helper'
 
-class ConnectionTest < Test::Unit::TestCase
+class ConnectionTest < StalkClimber::TestCase
 
-  def setup
+  setup do
     @connection = StalkClimber::Connection.new('localhost:11300')
   end
 
 
-  def test_cache_creates_and_returns_hash_instance_variable
-    refute @connection.instance_variable_get(:@cache)
-    assert_equal({}, @connection.cache)
-    assert_equal({}, @connection.instance_variable_get(:@cache))
-  end
+  context '#cached_jobs' do
 
+    should 'create and return a hash instance variable' do
+      refute @connection.instance_variable_get(:@cached_jobs)
+      assert_equal({}, @connection.cached_jobs)
+      assert_equal({}, @connection.instance_variable_get(:@cached_jobs))
+    end
 
-  def test_cache_is_reset_if_max_job_id_lower_than_max_climbed_job_id
-    seeds = seed_jobs
-    @connection.each {}
-    assert_not_equal({}, @connection.cache)
-    assert_not_equal(Float::INFINITY, @connection.min_climbed_job_id)
-    assert_not_equal(0, @connection.max_climbed_job_id)
 
-    @connection.send(:update_climbed_job_ids_from_max_id, 1)
-    assert_equal({}, @connection.cache)
-    assert_equal(Float::INFINITY, @connection.min_climbed_job_id)
-    assert_equal(0, @connection.max_climbed_job_id)
-    seeds.map(&:delete)
-  end
+    should 'reset if max job id lower than max climbed job id' do
+      seeds = seed_jobs
+      @connection.each_job {}
+      refute_equal({}, @connection.cached_jobs)
+      refute_equal(Float::INFINITY, @connection.min_climbed_job_id)
+      refute_equal(0, @connection.max_climbed_job_id)
 
+      @connection.send(:update_climbed_job_ids_from_max_id, 1)
+      assert_equal({}, @connection.cached_jobs)
+      assert_equal(Float::INFINITY, @connection.min_climbed_job_id)
+      assert_equal(0, @connection.max_climbed_job_id)
+      seeds.map(&:delete)
+    end
 
-  def test_connection_is_some_kind_of_enumerable
-    assert @connection.kind_of?(Enumerable)
   end
 
 
-  def test_deleted_jobs_should_not_be_enumerated
-    seeds = seed_jobs
-    seeds.map(&:delete)
-    seed_ids = seeds.map(&:id)
+  context '#job_enumerator' do
 
-    deleted = @connection.detect do |job|
-      seed_ids.include?(job.id)
+    should 'be some kind of enumerable' do
+      assert_kind_of Enumerable, @connection.job_enumerator
     end
 
-    assert_nil deleted, "Deleted job found in enumeration: #{deleted}"
   end
 
 
-  def test_each_caches_jobs_for_later_use
-    seeds = seed_jobs
+  context '#each_job' do
 
-    jobs = {}
-    @connection.each do |job|
-      jobs[job.id] = job
-    end
+    should 'not enumerate deleted jobs' do
+      seeds = seed_jobs
+      seeds.map(&:delete)
+      seed_ids = seeds.map(&:id)
+
+      deleted = @connection.each_job.detect do |job|
+        seed_ids.include?(job.id)
+      end
 
-    @connection.expects(:with_job).never
-    @connection.each do |job|
-      assert_equal jobs[job.id], job
+      assert_nil deleted, "Deleted job found in enumeration: #{deleted}"
     end
 
-    seeds.map(&:delete)
-  end
 
+    should 'cache jobs for later use' do
+      seeds = seed_jobs
+
+      jobs = {}
+      @connection.each_job do |job|
+        jobs[job.id] = job
+      end
 
-  def test_each_deletes_cached_jobs_that_no_longer_exist
-    seeds = seed_jobs
+      @connection.expects(:with_job).never
+      @connection.each_job do |job|
+        assert_equal jobs[job.id], job
+      end
 
-    jobs = {}
-    @connection.each do |job|
-      jobs[job.id] = job
+      seeds.map(&:delete)
     end
 
-    deleted_job = jobs[jobs.keys[2]]
-    deleted_job.delete
 
-    @connection.expects(:with_job).never
-    @connection.each do |job|
-      assert_equal jobs.delete(job.id), job
+    should 'delete cached jobs that no longer exists' do
+      seeds = seed_jobs
+
+      jobs = {}
+      @connection.each_job do |job|
+        jobs[job.id] = job
+      end
+
+      deleted_job = jobs[jobs.keys[2]]
+      deleted_job.delete
+
+      @connection.expects(:with_job).never
+      @connection.each_job do |job|
+        assert_equal jobs.delete(job.id), job
+      end
+
+      assert_equal 1, jobs.length
+      assert_equal deleted_job.id, jobs.values.first.id
+
+      seeds.map {|job| job.delete if job.exists? }
     end
 
-    assert_equal 1, jobs.length
-    assert_equal deleted_job.id, jobs.values.first.id
 
-    seeds.map(&:delete)
-  end
+    should 'hit jobs below climbed range that have not been previously hit' do
+      seeds = seed_jobs(10)
 
+      count = 0
+      @connection.each_job do |job|
+        count += 1
+        break if count == 5
+      end
 
-  def test_each_hits_jobs_below_climbed_range_that_have_not_been_hit
-    seeds = seed_jobs(10)
+      initial_min_climbed_job_id = @connection.min_climbed_job_id
 
-    count = 0
-    @connection.each do |job|
-      count += 1
-      break if count == 5
+      all_jobs = {}
+      @connection.each_job do |job|
+        all_jobs[job.id] = job
+      end
+
+      seeds.each do |job|
+        assert_equal all_jobs[job.id].body, job.body
+        assert_equal all_jobs[job.id].id, job.id
+        job.delete
+      end
+
+      assert @connection.min_climbed_job_id < initial_min_climbed_job_id
     end
 
-    initial_min_climbed_job_id = @connection.min_climbed_job_id
 
-    all_jobs = {}
-    @connection.each do |job|
-      all_jobs[job.id] = job
+    should 'hit each job only once' do
+      seeds = seed_jobs
+
+      jobs = {}
+      @connection.each_job do |job|
+        refute jobs[job.id]
+        jobs[job.id] = job
+      end
+
+      seeds.map(&:delete)
     end
 
-    seeds.each do |job|
-      assert_equal all_jobs[job.id].body, job.body
-      assert_equal all_jobs[job.id].id, job.id
-      job.delete
+
+    should 'get enumerator via #job_enumerator' do
+      @connection.expects(:job_enumerator).returns(Enumerator.new { |yielder| yielder << 1 })
+      @connection.each_job {}
     end
 
-    assert @connection.min_climbed_job_id < initial_min_climbed_job_id
-  end
 
+    should 'set min and max climbed job ids appropriately' do
+      assert_equal Float::INFINITY, @connection.min_climbed_job_id
+      assert_equal 0, @connection.max_climbed_job_id
 
-  def test_each_only_hits_each_job_once
-    seeds = seed_jobs
+      max_id = @connection.max_job_id
+      @connection.expects(:max_job_id).once.returns(max_id)
+      @connection.each_job {}
 
-    jobs = {}
-    @connection.each do |job|
-      refute jobs[job.id]
-      jobs[job.id] = job
+      assert_equal 1, @connection.min_climbed_job_id
+      assert_equal max_id, @connection.max_climbed_job_id
     end
 
-    seeds.map(&:delete)
-  end
 
+    should 'allow for breaking enumeration' do
+      begin
+        count = 0
+        @connection.each_job do |job|
+          break if 2 == count += 1
+          assert(false, "Connection#each_job did not break when expected") if count >= 3
+        end
+      rescue => e
+        assert(false, "Breaking from Connection#each_job raised #{e.inspect}")
+      end
+    end
 
-  def test_each_calls_to_enum
-    @connection.expects(:to_enum).returns(Enumerator.new { |yielder| yielder << 1 })
-    @connection.each {}
   end
 
+  context '#fetch_job' do
 
-  def test_fetch_job_returns_nil_or_the_requested_job_if_it_exists
-    assert_nothing_raised do
+    should 'return nil or the requested job if it exists' do
       job = @connection.fetch_job(@connection.max_job_id)
       assert_equal nil, job
+
+      probe = seed_jobs(1).first
+      assert_equal probe.id, @connection.fetch_job(probe.id).id
+      probe.delete
     end
 
-    probe = seed_jobs(1).first
-    assert_equal probe.id, @connection.fetch_job(probe.id).id
-    probe.delete
   end
 
 
-  def test_fetch_job_bang_returns_requested_job_or_raises_an_error_if_job_does_not_exist
-    assert_raise Beaneater::NotFoundError do
-      @connection.fetch_job!(@connection.max_job_id)
+  context '#fetch_job!' do
+
+    should 'return requested job or raise an error if the job does not exists' do
+      assert_raises Beaneater::NotFoundError do
+        @connection.fetch_job!(@connection.max_job_id)
+      end
+
+      probe = seed_jobs(1).first
+      assert_equal probe.id, @connection.fetch_job!(probe.id).id
+      probe.delete
     end
 
-    probe = seed_jobs(1).first
-    assert_equal probe.id, @connection.fetch_job!(probe.id).id
-    probe.delete
   end
 
 
-  def test_fetch_jobs_returns_each_requested_job_or_nil
-    assert_nothing_raised do
+  context '#fetch_jobs' do
+
+    should 'return each requested job or nil' do
       jobs = @connection.fetch_jobs(@connection.max_job_id, @connection.max_job_id)
       assert_equal [nil, nil], jobs
+
+      probes = seed_jobs(2)
+      probe_ids = probes.map(&:id)
+      assert_equal probe_ids, @connection.fetch_jobs(probe_ids).map(&:id)
+      probes.map(&:delete)
     end
 
-    probes = seed_jobs(2)
-    probe_ids = probes.map(&:id)
-    assert_equal probe_ids, @connection.fetch_jobs(probe_ids).map(&:id)
-    probes.map(&:delete)
   end
 
 
-  def test_fetch_jobs_bang_returns_requested_jobs_or_raises_an_error_if_any_job_does_not_exist
-    probes = seed_jobs(2)
+  context '#fetch_jobs!' do
+
+    should 'return the requested jobs or raise an error if any job does not exist' do
+      probes = seed_jobs(2)
 
-    probe_ids = probes.map(&:id)
-    assert_equal probe_ids, @connection.fetch_jobs!(probe_ids).map(&:id)
+      probe_ids = probes.map(&:id)
+      assert_equal probe_ids, @connection.fetch_jobs!(probe_ids).map(&:id)
 
-    assert_raise Beaneater::NotFoundError do
-      @connection.fetch_jobs!(probe_ids.first, @connection.max_job_id, probe_ids.last)
+      assert_raises Beaneater::NotFoundError do
+        @connection.fetch_jobs!(probe_ids.first, @connection.max_job_id, probe_ids.last)
+      end
+
+      probes.map(&:delete)
     end
 
-    probes.map(&:delete)
   end
 
 
-  def test_max_job_id_returns_expected_max_job_id
-    initial_max = @connection.max_job_id
-    seed_jobs(3).map(&:delete)
-    # 3 new jobs, +1 for the probe job
-    assert_equal initial_max + 4, @connection.max_job_id
-  end
+  context '#max_job_id' do
 
+    should 'return expected max job id' do
+      initial_max = @connection.max_job_id
+      seed_jobs(3).map(&:delete)
+      # 3 new jobs, +1 for the probe job
+      assert_equal initial_max + 4, @connection.max_job_id
+    end
 
-  def test_max_job_id_should_increment_max_climbed_id_if_successor
-    @connection.each {}
-    max = @connection.max_climbed_job_id
-    @connection.max_job_id
-    assert_equal max + 1, @connection.max_climbed_job_id
-  end
 
+    should 'increment max climbed id if successor visited' do
+      @connection.each_job {}
+      max = @connection.max_climbed_job_id
+      @connection.max_job_id
+      assert_equal max + 1, @connection.max_climbed_job_id
+    end
+
+
+    should 'not increment max_climbed_id unless visiting successor' do
+      @connection.each_job {}
+      max = @connection.max_climbed_job_id
+      seed_jobs(1).map(&:delete)
+      @connection.max_job_id
+      assert_equal max, @connection.max_climbed_job_id
+    end
 
-  def test_max_job_id_should_not_increment_max_climbed_id_unless_successor
-    @connection.each {}
-    max = @connection.max_climbed_job_id
-    seed_jobs(1).map(&:delete)
-    @connection.max_job_id
-    assert_equal max, @connection.max_climbed_job_id
   end
 
 
-  def test_each_sets_min_and_max_climbed_job_ids_appropriately
-    assert_equal Float::INFINITY, @connection.min_climbed_job_id
-    assert_equal 0, @connection.max_climbed_job_id
+  context '#initialize' do
 
-    max_id = @connection.max_job_id
-    @connection.expects(:max_job_id).once.returns(max_id)
-    @connection.each {}
+    should 'initialize with a test tube' do
+      StalkClimber::Connection.any_instance.expects(:use_test_tube)
+      connection = StalkClimber::Connection.new('localhost:11300', 'test_tube')
+      assert_equal 'test_tube', connection.test_tube
+    end
 
-    assert_equal 1, @connection.min_climbed_job_id
-    assert_equal max_id, @connection.max_climbed_job_id
   end
 
+  context '#test_tube=' do
+
+    should 'initialize with test tube but allow configuration' do
+      assert_equal StalkClimber::Connection::DEFAULT_TUBE, @connection.test_tube
+      tube_name = 'test_tube'
+      @connection.test_tube = tube_name
+      assert_equal tube_name, @connection.test_tube
+    end
 
-  def test_initialize_with_a_test_tube
-    StalkClimber::Connection.any_instance.expects(:use_test_tube)
-    connection = StalkClimber::Connection.new('localhost:11300', 'test_tube')
-    assert_equal 'test_tube', connection.test_tube
-  end
 
+    should 'use the supplied test tube' do
+      @connection.expects(:transmit).with('use test_tube')
+      @connection.expects(:transmit).with('watch test_tube')
+      @connection.expects(:transmit).with('ignore default')
+      @connection.test_tube = 'test_tube'
+      assert_equal 'test_tube', @connection.test_tube
+    end
 
-  def test_test_tube_is_initialized_but_configurable
-    assert_equal StalkClimber::Connection::DEFAULT_TUBE, @connection.test_tube
-    tube_name = 'test_tube'
-    @connection.test_tube = tube_name
-    assert_equal tube_name, @connection.test_tube
   end
 
 
-  def test_setting_test_tube_uses_test_tube
-    @connection.expects(:transmit).with('use test_tube')
-    @connection.expects(:transmit).with('watch test_tube')
-    @connection.expects(:transmit).with('ignore default')
-    @connection.test_tube = 'test_tube'
-    assert_equal 'test_tube', @connection.test_tube
-  end
+  context '#to_enum' do
 
+    should 'return an enumerator' do
+      assert_kind_of Enumerator, @connection.to_enum
+    end
 
-  def test_to_enum_returns_an_enumerator
-    assert_kind_of Enumerator, @connection.to_enum
   end
 
 end