bean_counter 0.0.4 → 0.1.0

data/lib/bean_counter/strategies/stalk_climber_strategy.rb

@@ -69,7 +69,7 @@ class BeanCounter::Strategy::StalkClimberStrategy < BeanCounter::Strategy
   end
 
 
-  # Returns a Boolean indicating whether or not the provided Sta`kClimber::Job
+  # Returns a Boolean indicating whether or not the provided StalkClimber::Job
   # `job` matches the given Hash of `options`.
   #
   # See {MATCHABLE_JOB_ATTRIBUTES} for a list of

data/lib/bean_counter/version.rb

@@ -1,4 +1,4 @@
 module BeanCounter
   # BeanCounter version number
-  VERSION = '0.0.4'
+  VERSION = '0.1.0'
 end

data/test/test_helper.rb

@@ -1,3 +1,4 @@
+require 'debugger'
 require 'coveralls'
 Coveralls.wear_merged!
 
@@ -41,10 +42,32 @@ class BeanCounter::TestCase < MiniTest::Should::TestCase
   include Timeout
 
 
+  def self.create_test_gemerald_beanstalks
+    return if class_variable_defined?(:@@gemerald_strategy)
+    @@gemerald_addrs ||= ['127.0.0.1:11400', '127.0.0.1:11401']
+    previous_urls = BeanCounter.beanstalkd_url
+    BeanCounter.beanstalkd_url = @@gemerald_addrs
+    @@gemerald_strategy = BeanCounter::Strategy::GemeraldBeanstalkStrategy.new
+    @@gemerald_beanstalks = @@gemerald_strategy.send(:beanstalks)
+    clients_by_address = @@gemerald_beanstalks.map do |beanstalk|
+      [beanstalk.address, beanstalk.direct_connection_client]
+    end
+    @@gemerald_clients = Hash[clients_by_address]
+    BeanCounter.beanstalkd_url = previous_urls
+  end
+
+
   def client
     return @client ||= Beaneater::Connection.new('localhost:11300')
   end
 
+
+  def gemerald_client(gemerald_addr = nil)
+    self.class.create_test_gemerald_beanstalks
+    gemerald_addr ||= @@gemerald_addrs.first
+    return @@gemerald_clients[gemerald_addr]
+  end
+
 end
 
 

data/test/unit/strategies/gemerald_beanstalk_strategy/job_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+class GemeraldBeanstalkStrategyJobTest < BeanCounter::TestCase
+
+  Job = BeanCounter::Strategy::GemeraldBeanstalkStrategy::Job
+
+  context 'attr methods' do
+
+    should 'respond to stats attr methods and retrieve from #to_hash Hash' do
+      Job::STATS_METHODS.each do |attr|
+        job = Job.new(stub(:stats => {attr => attr}), nil)
+        assert_equal attr, job.send(attr.gsub(/-/, '_'))
+      end
+    end
+
+
+    should 'respond to #connection' do
+      assert_equal :connection, Job.new(nil, :connection).connection
+    end
+
+
+    should 'retrieve body and stats from gemerald_job' do
+      job = Job.new(stub(:stats => :stats, :body => :body), nil)
+      assert_equal :body, job.body
+      assert_equal :stats, job.stats
+    end
+
+  end
+
+
+  context '#delete' do
+
+    should 'return true if job deleted successfully' do
+      job = Job.new(stub(:stats => {'id' => 1}), stub(:transmit => "DELETED\r\n"))
+      assert job.delete
+    end
+
+
+    should 'return true if job does not exist' do
+      job = Job.new(stub(:stats => {'id' => 1}), stub(:transmit => "NOT_FOUND\r\n"))
+      assert job.delete
+    end
+
+
+    should 'return false if job could not be deleted' do
+      mock_connection = mock
+      mock_connection.expects(:transmit).twice.returns("NOT_FOUND\r\n", "FOUND\r\n")
+      job = Job.new(stub(:stats => {'id' => 1, :state => 'ready'}), mock_connection)
+      refute job.delete
+    end
+
+  end
+
+
+  context '#exists?' do
+
+    should 'return false if the job state is deleted' do
+      job = Job.new(stub(:stats => {'id' => 1, 'state' => 'deleted'}), nil)
+      refute job.exists?
+    end
+
+
+    should 'return true if job could be found on server' do
+      job = Job.new(stub(:stats => {'id' => 1, 'state' => 'ready'}), stub(:transmit => "FOUND\r\n"))
+      assert job.exists?
+    end
+
+
+    should 'return false if job could not be found on server' do
+      job = Job.new(stub(:stats => {'id' => 1, 'state' => 'ready'}), stub(:transmit => "NOT_FOUND\r\n"))
+      refute job.exists?
+    end
+
+  end
+
+
+  context '#to_hash' do
+
+    should 'return job stats less file with body and connection in alpha order' do
+      job = Job.new(stub(:stats => {'file' => :file, 'id' => 1}, :body => :body), :connection)
+      assert_equal({'body' => :body, 'connection' => :connection, 'id' => 1}, job.to_hash)
+    end
+
+  end
+
+end

data/test/unit/strategies/gemerald_beanstalk_strategy/tube_test.rb

@@ -0,0 +1,103 @@
+require 'test_helper'
+
+class GemeraldBeanstalkStrategyTubeTest < BeanCounter::TestCase
+
+  Tube = BeanCounter::Strategy::GemeraldBeanstalkStrategy::Tube
+
+  context 'attr methods' do
+
+    should 'respond to stats attr methods and retrieve from #to_hash Hash' do
+      tube = Tube.new('xxx', [])
+      Tube::STATS_METHODS.each do |attr|
+        tube.expects(:to_hash).returns({attr => attr})
+        assert_equal attr, tube.send(attr.gsub(/-/, '_'))
+      end
+    end
+
+
+    should 'respond to #name' do
+      assert_equal 'xxx', Tube.new('xxx', []).name
+    end
+
+  end
+
+
+  context 'tests against real servers' do
+
+    setup do
+      create_test_beanstalks
+      @tube_name = SecureRandom.uuid
+      client.transmit("watch #{@tube_name}")
+      @tube = @strategy.send(:strategy_tube, @tube_name)
+    end
+
+
+    context '#exists' do
+
+      should 'return true if the tube exists, false otherwise' do
+        assert @tube.exists?
+        client.transmit("ignore #{@tube_name}")
+        refute @tube.exists?
+      end
+
+    end
+
+
+    context '#to_hash' do
+
+      setup do
+        @tube_name = SecureRandom.uuid
+        client.transmit("watch #{@tube_name}")
+        @tube = @strategy.send(:strategy_tube, @tube_name)
+
+        other_client = client(@@gemerald_addrs.last)
+        other_client.transmit("watch #{@tube_name}")
+      end
+
+
+      should 'retrieve tube stats from all servers and return merged stats' do
+        stats = {
+          'cmd-delete' =>  100,
+          'cmd-pause-tube' => 101,
+          'current-jobs-buried' => 102,
+          'current-jobs-delayed' => 103,
+          'current-jobs-ready' => 104,
+          'current-jobs-reserved' => 105,
+          'current-jobs-urgent' => 106,
+          'current-using' => 107,
+          'current-waiting' => 108,
+          'current-watching' => 109,
+          'name' => @tube_name,
+          'pause' => 111,
+          'pause-time-left' => 110,
+          'total-jobs' => 112,
+        }
+        GemeraldBeanstalk::Tube.any_instance.expects(:stats).twice.returns(stats)
+        expected = Hash[stats.map{|k, v| [k, v.is_a?(Numeric) ? v * 2 : v]}]
+        assert_equal expected, @tube.to_hash
+      end
+
+
+      should 'return empty Hash if the tube does not exist' do
+        assert_equal({}, @strategy.send(:strategy_tube, 'xxxx').to_hash)
+      end
+
+    end
+
+  end
+
+
+  def client(addr = nil)
+    self.class.create_test_gemerald_beanstalks
+    addr ||= @@gemerald_addrs.first
+    return @@gemerald_clients[addr]
+  end
+
+
+  def create_test_beanstalks
+    self.class.create_test_gemerald_beanstalks
+    @strategy = @@gemerald_strategy
+    @beanstalks = @@gemerald_beanstalks
+  end
+
+end

data/test/unit/strategies/gemerald_beanstalk_strategy_test.rb

@@ -0,0 +1,604 @@
+require 'test_helper'
+require 'securerandom'
+
+class GemeraldBeanstalkStrategyTest < BeanCounter::TestCase
+
+  GemeraldBeanstalkStrategy = BeanCounter::Strategy::GemeraldBeanstalkStrategy
+
+  context 'BeanCounter::Strategy::GemeraldBeanstalkStrategy' do
+
+    should 'be a known_strategy' do
+      BeanCounter::Strategy.known_strategy?(BeanCounter::Strategy::GemeraldBeanstalkStrategy)
+      BeanCounter::Strategy.known_strategy?(GemeraldBeanstalkStrategy)
+    end
+
+  end
+
+
+  %w[jobs tubes].each do |enumerator|
+    context "##{enumerator} mocked behaviors" do
+
+      enumerator_singular = enumerator[0, enumerator.length - 1]
+
+      should "delegate to #{enumerator_singular}_enumerator returning an Enumerator" do
+        BeanCounter.expects(:beanstalkd_url).returns([])
+        @strategy = BeanCounter::Strategy::GemeraldBeanstalkStrategy.new
+        @strategy.expects(enumerator).returns([:foo].to_enum)
+        enum = @strategy.send(enumerator)
+        assert_kind_of Enumerator, enum
+        assert_equal :foo, enum.first
+      end
+
+    end
+
+  end
+
+
+  context 'gemerald_beanstalk config' do
+
+    should 'load gemerald_beanstalk introspection plugin' do
+      begin
+        included = GemeraldBeanstalk::Beanstalk.included_modules.include?(GemeraldBeanstalk::Plugin::Introspection)
+      rescue NameError => e
+        raise e unless e.message == 'uninitialized constant GemeraldBeanstalk::Plugin::Introspection'
+        included = false
+      end
+      assert included, 'Expected GemeraldBeanstalk::Plugin::Introspection to be loaded'
+    end
+
+  end
+
+
+  context '#parse_url' do
+
+    setup do
+      BeanCounter.expects(:beanstalkd_url).returns([])
+      @strategy = BeanCounter::Strategy::GemeraldBeanstalkStrategy.new
+    end
+
+
+    ['', 'beanstalk://'].each do |uri_scheme|
+      context uri_scheme == '' ? 'without uri_scheme' : 'with uri scheme' do
+        should 'correctly parse an IP address without a port' do
+          url = uri_scheme + '127.0.0.1'
+          assert_equal ['127.0.0.1'], @strategy.send(:parse_url, url)
+        end
+
+
+        should 'correctly parse an IP address a port' do
+          url = uri_scheme + '127.0.0.1:11300'
+          assert_equal ['127.0.0.1', 11300], @strategy.send(:parse_url, url)
+        end
+
+
+        should 'correctly parse a hostname without a port' do
+          url = uri_scheme + 'localhost'
+          assert_equal ['localhost'], @strategy.send(:parse_url, url)
+        end
+
+
+        should 'correctly parse a hostname with a port' do
+          url = uri_scheme + 'localhost:11300'
+          assert_equal ['localhost', 11300], @strategy.send(:parse_url, url)
+        end
+      end
+    end
+
+
+    should 'raise InvalidURIScheme if uri scheme is not beanstalk' do
+      assert_raises(ArgumentError) do
+        @strategy.send(:parse_url, 'http://localhost:11300')
+      end
+    end
+
+  end
+
+
+  context 'tests against real servers' do
+
+    setup do
+      create_test_beanstalks
+    end
+
+
+    context 'enumerators' do
+
+      %w[jobs tubes].each do |enumerator|
+        enumerator_singular = enumerator[0, enumerator.length - 1]
+
+        context "##{enumerator_singular}_enumerator" do
+
+          should 'return an enumerator' do
+            assert_kind_of Enumerator, @strategy.send(enumerator)
+          end
+
+
+          should "iterate over all #{enumerator} on all beanstalks" do
+            expected_count = @beanstalks.length
+            iterated_count = 0
+            @beanstalks.each_with_index do |beanstalk, index|
+              stub = enumerator == 'jobs' ? [index] : {index => index}
+              beanstalk.stubs(enumerator).returns(stub)
+            end
+            @strategy.expects("strategy_#{enumerator_singular}").
+              times(expected_count).
+              returns(*(expected_count.times.to_a))
+            enums = @strategy.send(enumerator).to_a
+            enums.each_with_index do |enumerable, index|
+              assert_equal index, enumerable
+              iterated_count += 1
+            end
+
+            assert_equal expected_count, iterated_count
+          end
+
+        end
+
+      end
+
+
+      context '#jobs' do
+
+        should 'get actual jobs when not mocked' do
+          @strategy.jobs.each do |job|
+            assert @strategy.delete_job(job)
+          end
+          @beanstalks.each_with_index do |beanstalk, index|
+            beanstalk.direct_connection_client.transmit("put 0 0 120 1\r\n#{index}")
+          end
+          @strategy.jobs.each_with_index do |job, index|
+            assert_kind_of BeanCounter::Strategy::GemeraldBeanstalkStrategy::Job, job
+            assert_equal index.to_s, job.body
+          end
+        end
+
+      end
+
+
+      context '#tubes' do
+
+        should 'get merged tube stats when not mocked' do
+          shared_tube = SecureRandom.uuid
+          tube_names = @@gemerald_clients.values.map do |client|
+            tube_name = SecureRandom.uuid
+            client.transmit("watch #{tube_name}")
+            client.transmit("watch #{shared_tube}")
+            tube_name
+          end
+          tube_names.concat(['default', shared_tube])
+          @strategy.tubes.each do |tube|
+            tube_names.delete(tube.name)
+          end
+          assert tube_names.empty?, 'Expected all tubes to be enumerated'
+        end
+
+      end
+
+    end
+
+
+    context '#collect_new_jobs' do
+
+      should 'raise ArgumentError unless block given' do
+        assert_raises(ArgumentError) do
+          @strategy.collect_new_jobs
+        end
+      end
+
+
+      should 'return empty array if no jobs enqueued by block' do
+        new_jobs = @strategy.collect_new_jobs {}
+        assert_equal [], new_jobs
+      end
+
+
+      should 'only return jobs enqueued during the execution of the given block' do
+        tube_name = message = SecureRandom.uuid
+        other_client = client(@@gemerald_addrs.last)
+        [client, other_client].each do |gb_client|
+          gb_client.transmit("use #{tube_name}")
+          gb_client.transmit("watch #{tube_name}")
+          gb_client.transmit('ignore default')
+          gb_client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")
+        end
+        # Add an extra job to first client to make id lists unequal and help test order
+        message = SecureRandom.uuid
+        client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")
+
+        jobs = []
+        new_jobs = @strategy.collect_new_jobs do
+          [client, other_client].each do |gb_client|
+            5.times do
+              message = SecureRandom.uuid
+              response = gb_client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")
+              jobs << insertion_id(response)
+            end
+          end
+        end
+
+        [client, other_client].each do |gb_client|
+          message = SecureRandom.uuid
+          gb_client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")
+        end
+        assert_equal new_jobs.map{|job| job.id}, jobs
+      end
+
+    end
+
+
+    context '#delete_job' do
+
+      should 'delete the given job and return true' do
+        message = SecureRandom.uuid
+        response = client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")
+        job_id = insertion_id(response)
+        job = strategy_job(client, job_id)
+        assert @strategy.delete_job(job), 'Failed to delete job'
+        assert_equal 'deleted', job.state
+        assert_equal "NOT_FOUND\r\n", client.transmit("stats-job #{job_id}")
+      end
+
+
+      should 'return true if the job has already been deleted' do
+        message = SecureRandom.uuid
+        response = client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")
+        job_id = insertion_id(response)
+        job = strategy_job(client, job_id)
+        assert @strategy.delete_job(job), 'Failed to delete job'
+        assert @strategy.delete_job(job), 'Expected deleting a deleted job to return true'
+      end
+
+
+      should 'return false if the job could not be deleted' do
+        tube_name = message = SecureRandom.uuid
+        other_client = client.beanstalk.direct_connection_client
+        other_client.transmit("use #{tube_name}")
+        other_client.transmit("watch #{tube_name}")
+        other_client.transmit('ignore defualt')
+        response = other_client.transmit("put 0 0 120 #{message.bytesize}\r\n#{message}")
+        job_id = insertion_id(response)
+        other_client.transmit('reserve')
+        job = strategy_job(client, job_id)
+        assert_equal 'reserved', job.state
+        refute @strategy.delete_job(job), 'Expected deleting job reserved by other client to fail'
+        other_client.transmit("delete #{job_id}")
+      end
+
+    end
+
+
+    context '#job_matches?' do
+
+      setup do
+        @message = @tube_name = SecureRandom.uuid
+        client.transmit("use #{@tube_name}")
+        response = client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        job_id = insertion_id(response)
+        @job = strategy_job(client, job_id)
+      end
+
+
+      should 'match string fields using string or regex' do
+        {
+          :body => @message,
+          :state => @job.state,
+          :tube => @tube_name,
+        }.each_pair do |key, value|
+          assert @strategy.job_matches?(@job, key => value)
+          assert @strategy.job_matches?(@job, key => %r[#{value[2, 3]}])
+          refute @strategy.job_matches?(@job, key => 'foobar')
+          refute @strategy.job_matches?(@job, key => /foobar/)
+        end
+      end
+
+
+      should 'match integer fields using integer or range' do
+        verify_attrs(@job, {
+          :age => @job.age,
+          :buries => @job.buries,
+          :delay => @job.delay,
+          :id => @job.id,
+          :kicks => @job.kicks,
+          :pri => @job.pri,
+          :releases => @job.releases,
+          :reserves => @job.reserves,
+          :'time-left' => @job.time_left,
+          :timeouts => @job.timeouts,
+          :ttr => @job.ttr,
+        })
+      end
+
+
+      should 'match integer fields using integer or range (with more stubs)' do
+        job_attrs = {
+          'age' => 100,
+          'buries' => 101,
+          'delay' => 102,
+          'kicks' => 103,
+          'pri' => 104,
+          'releases' => 105,
+          'reserves' => 106,
+          'time-left' => 107,
+          'timeouts' => 108,
+          'ttr' => 109,
+        }
+        @job.stubs(:exists?).returns(true)
+        @job.instance_variable_get(:@gemerald_job).stubs(:stats).returns(job_attrs)
+        verify_attrs(@job, job_attrs)
+      end
+
+
+      should 'be able to match with a proc' do
+        matching_connection_proc = proc do |connection|
+          connection.beanstalk.address == '127.0.0.1:11400'
+        end
+        assert @strategy.job_matches?(@job, :connection => matching_connection_proc)
+
+        failing_connection_proc = proc do |connection|
+          connection.beanstalk.address != '127.0.0.1:11400'
+        end
+        refute @strategy.job_matches?(@job, :connection => failing_connection_proc)
+      end
+
+
+      should 'not try to match on non-matachable attributes' do
+        # Should never be called
+        @job.expects(:bury).never
+        @job.expects(:delete).never
+        @job.expects(:deadline_approaching).never
+
+        assert @strategy.job_matches?(@job, {
+          :body => @message,
+          :bury => 'baz',
+          :deadline_approaching => 'bar',
+          :delete => 'bar',
+          :stats => 'boom',
+        })
+      end
+
+
+      should 'not match deleted job' do
+        client.transmit("delete #{@job.id}")
+        refute @strategy.job_matches?(@job, :body => @message)
+      end
+
+    end
+
+
+    context '#pretty_print_job' do
+
+      setup do
+        @message = @tube_name = SecureRandom.uuid
+        client.transmit("use #{@tube_name}")
+        response = client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        job_id = insertion_id(response)
+        @job = strategy_job(client, job_id)
+      end
+
+
+      should 'return expected text representation of job' do
+        stats = {
+          'age' => age = 3,
+          'buries' => buries = 0,
+          'delay' => delay = 0,
+          'id' => id = 4412,
+          'kicks' => kicks = 0,
+          'pri' => pri = 4294967295,
+          'releases' => releases = 0,
+          'reserves' => reserves = 0,
+          'state' => state = 'ready',
+          'time-left' => time_left = 0,
+          'timeouts' => timeouts = 0,
+          'ttr'  => ttr = 300,
+          'tube' => tube = 'default',
+        }
+        @job.expects(:stats).returns(stats)
+        expected = %W[
+          "age"=>#{age} "body"=>"#{@message}" "buries"=>#{buries}
+          "delay"=>#{delay} "id"=>#{id} "kicks"=>#{kicks} "pri"=>#{pri} "releases"=>#{releases}
+          "reserves"=>#{reserves} "state"=>"#{state}" "time-left"=>#{time_left}
+          "timeouts"=>#{timeouts} "ttr"=>#{ttr} "tube"=>"#{tube}"
+        ].join(', ')
+        assert_equal "{#{expected}}", @strategy.pretty_print_job(@job)
+      end
+
+    end
+
+
+    context '#pretty_print_tube' do
+
+      setup do
+        @tube_name = SecureRandom.uuid
+        client.transmit("watch #{@tube_name}")
+        @tube = strategy_tube(@tube_name)
+
+        other_client = client(@@gemerald_addrs.last)
+        other_client.transmit("watch #{@tube_name}")
+      end
+
+
+      should 'return expected text representation of tube' do
+        stats = {
+          'cmd-delete' => cmd_delete = 100,
+          'cmd-pause-tube' => cmd_pause_tube = 101,
+          'current-jobs-buried' => current_jobs_buried = 102,
+          'current-jobs-delayed' => current_jobs_delayed = 103,
+          'current-jobs-ready' => current_jobs_ready = 104,
+          'current-jobs-reserved' => current_jobs_reserved = 105,
+          'current-jobs-urgent' => current_jobs_urgent = 106,
+          'current-using' => current_using = 107,
+          'current-waiting' => current_waiting = 108,
+          'current-watching' => current_watching = 109,
+          'name' => name = @tube_name,
+          'pause' => pause = 111,
+          'pause-time-left' => pause_time_left = 110,
+          'total-jobs' => total_jobs = 112,
+        }
+        GemeraldBeanstalk::Tube.any_instance.expects(:stats).twice.returns(stats)
+        expected = %W[
+          "cmd-delete"=>#{cmd_delete * 2} "cmd-pause-tube"=>#{cmd_pause_tube * 2}
+          "current-jobs-buried"=>#{current_jobs_buried * 2}
+          "current-jobs-delayed"=>#{current_jobs_delayed * 2}
+          "current-jobs-ready"=>#{current_jobs_ready * 2}
+          "current-jobs-reserved"=>#{current_jobs_reserved * 2}
+          "current-jobs-urgent"=>#{current_jobs_urgent * 2}
+          "current-using"=>#{current_using * 2} "current-waiting"=>#{current_waiting * 2}
+          "current-watching"=>#{current_watching * 2} "name"=>"#{name}"
+          "pause"=>#{pause * 2} "pause-time-left"=>#{pause_time_left * 2}
+          "total-jobs"=>#{total_jobs * 2}
+        ].join(', ')
+        assert_equal "{#{expected}}", @strategy.pretty_print_tube(@tube)
+      end
+
+    end
+
+
+    context '#tube_matches?' do
+
+      setup do
+        @tube_name = SecureRandom.uuid
+        client.transmit("watch #{@tube_name}")
+        @tube = strategy_tube(@tube_name)
+      end
+
+
+      should 'match name using string or regex' do
+        assert @strategy.tube_matches?(@tube, :name => @tube_name)
+        assert @strategy.tube_matches?(@tube, :name => %r[#{@tube_name[2, 3]}])
+        refute @strategy.tube_matches?(@tube, :name => 'foobar')
+        refute @strategy.tube_matches?(@tube, :name => /foobar/)
+      end
+
+
+      should 'match integer fields using integer or range' do
+        tube_stats = @tube.to_hash
+        verify_attrs(@tube, {
+          'cmd-delete' => tube_stats['cmd-delete'],
+          'cmd-pause-tube' => tube_stats['cmd-pause-tube'],
+          'current-jobs-buried' => tube_stats['current-jobs-buried'],
+          'current-jobs-delayed' => tube_stats['current-jobs-delayed'],
+          'current-jobs-ready' => tube_stats['current-jobs-ready'],
+          'current-jobs-reserved' => tube_stats['current-jobs-reserved'],
+          'current-jobs-urgent' => tube_stats['current-jobs-urgent'],
+          'current-using' => tube_stats['current-using'],
+          'current-waiting' => tube_stats['current-waiting'],
+          'current-watching' => tube_stats['current-watching'],
+          'pause' => tube_stats['pause'],
+          'pause-time-left' => tube_stats['pause-time-left'],
+          'total-jobs' => tube_stats['total-jobs'],
+        })
+      end
+
+
+      should 'match integer fields using integer or range (with more stubs)' do
+        tube_attrs = {
+          'cmd-delete' => 100,
+          'cmd-pause-tube' => 101,
+          'current-jobs-buried' => 102,
+          'current-jobs-delayed' => 103,
+          'current-jobs-ready' => 104,
+          'current-jobs-reserved' => 105,
+          'current-jobs-urgent' => 106,
+          'current-using' => 107,
+          'current-waiting' => 108,
+          'current-watching' => 109,
+          'pause-time-left' => 110,
+          'pause' => 111,
+          'total-jobs' => 112,
+        }
+        @tube.stubs(:to_hash).returns(tube_attrs)
+        verify_attrs(@tube, tube_attrs)
+      end
+
+
+      should 'be able to match with a proc' do
+        matching_name_proc = proc do |name|
+          name == @tube_name
+        end
+        assert @strategy.tube_matches?(@tube, :name => matching_name_proc)
+
+        failing_name_proc = proc do |name|
+          name != @tube_name
+        end
+        refute @strategy.tube_matches?(@tube, :name => failing_name_proc)
+      end
+
+
+      should 'not try to match on non-matachable attributes' do
+        %w[delete put reserve].each do |method|
+          @tube.expects(method).never
+        end
+
+        assert @strategy.tube_matches?(@tube, {
+          :delete => true,
+          :name => @tube_name,
+          :put => true,
+          :reserve => true,
+        })
+      end
+
+
+      should 'not match tube that no longer exists' do
+        client.transmit("ignore #{@tube_name}")
+        refute @tube.exists?
+        refute @strategy.tube_matches?(@tube)
+      end
+
+    end
+
+  end
+
+
+  def client(addr = nil)
+    return gemerald_client(addr)
+  end
+
+
+  def create_test_beanstalks
+    self.class.create_test_gemerald_beanstalks
+    @strategy = @@gemerald_strategy
+    @beanstalks = @@gemerald_beanstalks
+  end
+
+
+  def insertion_id(response)
+    return response.scan(/INSERTED (\d+)\r\n/).flatten.first.to_i
+  end
+
+
+  def strategy_job(gb_client, job_id)
+    gb_job = gb_client.beanstalk.jobs.reverse.detect{|job| job.id == job_id}
+    return @strategy.send(:strategy_job, gb_job)
+  end
+
+
+  def strategy_tube(tube_name)
+    return @strategy.send(:strategy_tube, tube_name)
+  end
+
+
+  def verify_attrs(strategy_object, attrs)
+    method = strategy_object.is_a?(BeanCounter::Strategy::GemeraldBeanstalkStrategy::Job) ? :job_matches? : :tube_matches?
+    attrs.each_pair do |key, value|
+      obj_hash = strategy_object.to_hash
+      sanitized_key = key.to_s
+      assert(
+        @strategy.send(method, strategy_object, key => value),
+        "Expected #{key} (#{obj_hash[sanitized_key]}) to match #{value}"
+      )
+      assert(
+        @strategy.send(method, strategy_object, key => (value - 5)..(value + 1)),
+        "Expected #{key} (#{obj_hash[sanitized_key]}) to match #{value} +/-5"
+      )
+      refute(
+        @strategy.send(method, strategy_object, key => value - 1),
+        "Expected #{key} (#{obj_hash[sanitized_key]}) to not match #{value}"
+      )
+      refute(
+        @strategy.send(method, strategy_object, key => (value + 100)..(value + 200)),
+        "Expected #{key} (#{obj_hash[sanitized_key]}) to not match #{value + 100}..#{value + 200}"
+      )
+    end
+  end
+
+end