bean_counter 0.0.1

data/lib/bean_counter/test_assertions.rb

@@ -0,0 +1,227 @@
+module BeanCounter::TestAssertions
+
+  # :call-seq:
+  #   assert_enqueued(options = {Symbol,String => Numeric,Proc,Range,Regexp,String})
+  #
+  # Asserts that some number of jobs are enqueued that match the given Hash of
+  # +options+. If no +options+ are given, asserts that at least one job exists.
+  #
+  # Each _key_ in +options+ is a String or a Symbol that identifies an attribute
+  # of a job that the corresponding _value_ should be compared against. All attribute
+  # comparisons are performed using the triple equal (===) operator/method of
+  # the given _value_.
+  #
+  # +options+ may additionally include a _count_ key of 'count' or :count that
+  # can be used to assert that a particular number of matching jobs are found.
+  #
+  # If no _count_ option is provided, the assertion succeeds if any job is found
+  # that matches all of the +options+ given. If no jobs are found that match the
+  # +options+ given, the assertion fails.
+  #
+  # If a _count_ option is provided the assertion only succeeds if the triple equal
+  # (===) operator/method of the value of _count_ evaluates to true when given the
+  # total number of matching jobs. Otherwise the assertion fails. The use of ===
+  # allows for more advanced comparisons using Procs, Ranges, Regexps, etc.
+  #
+  # See Strategy#job_matches? and/or the #job_matches? method of the strategy
+  # in use for more detailed information on how it is determined whether or not
+  # a job matches the given +options+.
+  #
+  #   assert_enqueued
+  #
+  #   assert_enqueued(:body => /test/, :count => 5)
+  #
+  #   assert_enqueued('state' => 'buried', 'count' => 3)
+  def assert_enqueued(options = {})
+    enqueue_expectation(:assert, options)
+  end
+
+
+  # :call-seq:
+  #   assert_enqueues(options = {Symbol,String => Numeric,Proc,Range,Regexp,String}) { block }
+  #
+  # Asserts that the given +block+ enqueues some number of jobs that match the
+  # given Hash of +options+. If no +options+ are given, asserts that at least
+  # one job is enqueued during the execution of the +block+.
+  #
+  # Unlike #assert_enqueued, which will evaluate all jobs in the beanstalkd pool,
+  # this method will only evaluate jobs that were enqueued during the
+  # execution of the given +block+. This can be useful for performance and for
+  # making assertions that could return false positives if all jobs were
+  # evaluated.
+  #
+  # Each _key_ in +options+ is a String or a Symbol that identifies an attribute
+  # of a job that the corresponding _value_ should be compared against. All attribute
+  # comparisons are performed using the triple equal (===) operator/method of
+  # the given _value_.
+  #
+  # +options+ may additionally include a _count_ key of 'count' or :count that
+  # can be used to assert that a particular number of matching jobs are found.
+  #
+  # If no _count_ option is provided, the assertion succeeds if any job is found
+  # that matches all of the +options+ given. If no jobs are found that match the
+  # +options+ given, the assertion fails.
+  #
+  # If a _count_ option is provided the assertion only succeeds if the triple equal
+  # (===) operator/method of the value of _count_ evaluates to true when given the
+  # total number of matching jobs. Otherwise the assertion fails. The use of ===
+  # allows for more advanced comparisons using Procs, Ranges, Regexps, etc.
+  #
+  # See Strategy#job_matches? and/or the #job_matches? method of the strategy
+  # in use for more detailed information on how it is determined whether or not
+  # a job matches the given +options+.
+  #
+  #   assert_enqueues(:body => /test/) do
+  #     enqueue_some_jobs
+  #   end
+  def assert_enqueues(options = {})
+    raise ArgumentError, 'Block required' unless block_given?
+
+    enqueue_expectation(:assert, options, &Proc.new)
+  end
+
+
+  # :call-seq:
+  #   assert_tube(options = {Symbol,String => Numeric,Proc,Range,Regexp,String})
+  #
+  # Asserts that at least one tube exist that matches the given Hash of
+  # +options+. If no +options+ are given, asserts that at least one tube exists,
+  # which will always succeed.
+  #
+  # Each _key_ in +options+ is a String or a Symbol that identifies an attribute
+  # of a tube that the corresponding _value_ should be compared against. All attribute
+  # comparisons are performed using the triple equal (===) operator/method of
+  # the given _value_.
+  #
+  # The assertion succeeds if any tube exists that matches all of the given
+  # +options+. If no tube exists matching all of the given +options+, the assertion
+  # fails.
+  #
+  # See Strategy#tube_matches? and/or the #tube_matches? method of the strategy
+  # in use for more detailed information on how it is determined whether or not
+  # a tube matches the given +options+.
+  #
+  #   assert_tube
+  #
+  #   assert_tube(:name => /test/)
+  #
+  #   assert_tube('current-jobs-ready' => 1..10)
+  def assert_tube(options = {})
+    tube_expectation(:assert, :failure_message, options)
+  end
+
+
+  # :call-seq:
+  #   refute_enqueued(options = {Symbol,String => Numeric,Proc,Range,Regexp,String})
+  #
+  # Asserts that no jobs are enqueued that match the given Hash of +options+.
+  # If no +options+ are given, asserts that no jobs exist.
+  #
+  # Each _key_ in +options+ is a String or a Symbol that identifies an attribute
+  # of a job that the corresponding _value_ should be compared against. All attribute
+  # comparisons are performed using the triple equal (===) operator/method of
+  # the given _value_.
+  #
+  # The refutation succeeds if no jobs are found that match all of the +options+
+  # given. If any matching jobs are found, the refutation fails.
+  #
+  # See Strategy#job_matches? and/or the #job_matches? method of the strategy
+  # in use for more detailed information on how it is determined whether or not
+  # a job matches the given +options+.
+  #
+  #   refute_enqueued
+  #
+  #   refute_enqueued(:body => lambda {|body| body.length > 50})
+  #
+  #   refute_enqueued('state' => 'buried')
+  def refute_enqueued(options = {})
+    enqueue_expectation(:refute, options)
+  end
+
+
+  # :call-seq:
+  #   refute_enqueues(options = {Symbol,String => Numeric,Proc,Range,Regexp,String}) { block }
+  #
+  # Asserts that the given +block+ enqueues no jobs that match the given Hash
+  # of +options+. If no +options+ are given, asserts that no job are enqueued
+  # by the given +block+.
+  #
+  # Unlike #refute_enqueued, which will evaluate all jobs in the beanstalkd pool,
+  # this method will only evaluate jobs that were enqueued during the
+  # execution of the given +block+. This can be useful for performance and for
+  # making assertions that could return false positives if all jobs were
+  # evaluated.
+  #
+  # Each _key_ in +options+ is a String or a Symbol that identifies an attribute
+  # of a job that the corresponding _value_ should be compared against. All attribute
+  # comparisons are performed using the triple equal (===) operator/method of
+  # the given _value_.
+  #
+  # The refutation succeeds if no jobs are found that match all of the +options+
+  # given. If any matching jobs are found, the refutation fails.
+  #
+  # See Strategy#job_matches? and/or the #job_matches? method of the strategy
+  # in use for more detailed information on how it is determined whether or not
+  # a job matches the given +options+.
+  #
+  #   refute_enqueues do
+  #     do_some_work_that_should_not_enqueue_any_jobs
+  #   end
+  def refute_enqueues(options = {})
+    raise ArgumentError, 'Block required' unless block_given?
+
+    enqueue_expectation(:refute, options, &Proc.new)
+  end
+
+
+  # :call-seq:
+  #   refute_tube(options = {Symbol,String => Numeric,Proc,Range,Regexp,String})
+  #
+  # Asserts that no tube exist that matches the given Hash of +options+.
+  # If no options are given, asserts that no tubes exist which will always fail.
+  #
+  # Each _key_ in +options+ is a String or a Symbol that identifies an attribute
+  # of a tube that the corresponding _value_ should be compared against. All attribute
+  # comparisons are performed using the triple equal (===) operator/method of
+  # the given _value_.
+  #
+  # The refutation succeeds if no tube exists that matches all of the given
+  # +options+. If any tubes exist that match all of the given +options+, the
+  # refutation fails.
+  #
+  # See Strategy#tube_matches? and/or the #tube_matches? method of the strategy
+  # in use for more detailed information on how it is determined whether or not
+  # a tube matches the given +options+.
+  #
+  #   refute_tube
+  #     #=> always fails
+  #
+  #   refute_tube(:name => /production/)
+  #
+  #   refute_tube('current-jobs-ready' => 0)
+  def refute_tube(options = {})
+    tube_expectation(:refute, :negative_failure_message, options)
+  end
+
+  private
+
+
+  # Builds job expectation object, evaluates and makes appropriate assertion
+  # with appropriate failure message
+  def enqueue_expectation(assertion_method, options, &block)
+    message_type = assertion_method == :assert ? :failure_message : :negative_failure_message
+    expectation = BeanCounter::EnqueuedExpectation.new(options)
+    match = expectation.matches?(block_given? ? block : nil)
+    send(assertion_method, match, expectation.send(message_type))
+  end
+
+
+  # Builds tube expectation object, evaluates and makes appropriate assertion
+  # with appropriate failure message
+  def tube_expectation(assertion_method, message_type, options)
+    expectation = BeanCounter::TubeExpectation.new(options)
+    match = expectation.matches?
+    send(assertion_method, match, expectation.send(message_type))
+  end
+
+end

data/lib/bean_counter/test_unit.rb

@@ -0,0 +1,3 @@
+require 'bean_counter/mini_test'
+
+Test::Unit::TestCase.send(:include, BeanCounter::MiniTest)

data/lib/bean_counter/tube_expectation.rb

@@ -0,0 +1,66 @@
+class BeanCounter::TubeExpectation
+
+  extend Forwardable
+
+  def_delegators BeanCounter, :strategy
+
+  # The value that the expectation expects
+  attr_reader :expected
+
+  # The tube found by the expecation during matching
+  attr_reader :found
+
+
+  # Builds the failure message used in the event of a positive expectation
+  # failure
+  def failure_message
+    return '' unless found.nil?
+    return "expected tube matching #{expected.to_s}, found none."
+  end
+
+
+  # Create a new tube expectation. Uses the given +expected+ Hash to determine
+  # if any tubes exist that match the expected options.
+  #
+  # Each _key_ in the +expected+ Hash is a String or a Symbol that identifies
+  # an attribute of a tube that the corresponding _value_ should be compared
+  # against. All attribute comparisons are performed using the triple equal
+  # (===) operator/method of the given _value_.
+  #
+  # See BeanCounter::MiniTest and/or BeanCounter::SpecMatchers for more information.
+  def initialize(expected)
+    @expected = expected
+  end
+
+
+  # Checks all tubes in the beanstalkd pool for a tube matching the expected
+  # options hash given at instantiation. The expectation succeeds if any tube
+  # exists that matches all of the expected options. If no tube exists
+  # matching all of the given options, the expectation fails.
+  #
+  # See Strategy#tube_matches? and/or the #tube_matches? method of the strategy
+  # in use for more detailed information on how it is determined whether or not
+  # a tube matches the options expected.
+  #
+  # See also BeanCounter::MiniTest and/or BeanCounter::SpecMatchers for additional
+  # information.
+  def matches?(given = nil)
+    @found = strategy.tubes.detect do |tube|
+      strategy.tube_matches?(tube, expected)
+    end
+
+    return !found.nil?
+  end
+
+
+  # Builds the failure message used in the event of a negative expectation
+  # failure
+  def negative_failure_message
+    return '' if found.nil?
+    return [
+      "expected no tubes matching #{expected.to_s},",
+      "found #{strategy.pretty_print_tube(found)}",
+    ].join(' ')
+  end
+
+end

data/lib/bean_counter/version.rb

@@ -0,0 +1,4 @@
+module BeanCounter
+  # BeanCounter version number
+  VERSION = '0.0.1'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'coveralls'
+Coveralls.wear_merged!
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'rspec'
+require 'mocha/api'
+require 'bean_counter'
+require 'bean_counter/spec'
+
+BeanCounter.beanstalkd_url = 'beanstalk://localhost'
+
+def client
+  return @client ||= Beaneater::Connection.new('localhost:11300')
+end

data/spec/spec_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+require 'securerandom'
+
+# Fuller testing of matchers handled by strategy and matcher tests. Just make
+# sure matchers work as expected at high level
+describe BeanCounter::SpecMatchers do
+
+  before(:each) do
+    BeanCounter.reset!
+    @tube_name = SecureRandom.uuid
+    client.transmit("use #{@tube_name}")
+    @message = SecureRandom.uuid
+  end
+
+
+  describe 'enqueued job matcher' do
+
+    describe 'positive match' do
+
+      it 'should match any matching job when not given a count' do
+        should_not have_enqueued(:body => @message)
+        proc do
+          2.times do
+            client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+          end
+        end.should have_enqueued(:body => @message)
+        should have_enqueued(:body => @message)
+      end
+
+
+      it 'should match count exactly when given integer count' do
+        should_not have_enqueued(:body => @message)
+        proc do
+          client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        end.should have_enqueued(:body => @message, :count => 1)
+        should have_enqueued(:body => @message, :count => 1)
+      end
+
+
+      it 'should match count to range when given range' do
+        should_not have_enqueued(:body => @message)
+        proc do
+          2.times do
+            client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+          end
+        end.should have_enqueued(:body => @message, :count => 1..3)
+        should have_enqueued(:body => @message, :count => 1..3)
+      end
+
+
+      it 'should not match when no matching jobs are found' do
+        message = SecureRandom.uuid
+        ::RSpec::Expectations.expects(:fail_with)
+        proc do
+          client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        end.should have_enqueued(:body => message)
+        should have_enqueued(:body => @message)
+        should_not have_enqueued(:body => message)
+      end
+
+
+      it 'should not match with exact count when given integer count' do
+        should_not have_enqueued(:body => @message)
+        ::RSpec::Expectations.expects(:fail_with)
+        proc do
+          client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        end.should have_enqueued(:body => @message, :count => 2)
+        should have_enqueued(:body => @message, :count => 1)
+      end
+
+
+      it 'should not match when no matching jobs are enqueued during block' do
+        client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        ::RSpec::Expectations.expects(:fail_with)
+        (proc {}).should have_enqueued(:body => @message)
+        should have_enqueued(:body => @message)
+      end
+
+    end
+
+
+    describe 'negative match' do
+
+      it 'should match when no matching jobs are found' do
+        message = SecureRandom.uuid
+        proc do
+          client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        end.should_not have_enqueued(:body => message)
+        should have_enqueued(:body => @message)
+        should_not have_enqueued(:body => message)
+      end
+
+
+      it 'should match with exact count when given integer count' do
+        should_not have_enqueued(:body => @message)
+        proc do
+          client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        end.should_not have_enqueued(:body => @message, :count => 2)
+        should have_enqueued(:body => @message, :count => 1)
+      end
+
+
+      it 'should match when no matching jobs are enqueued during block' do
+        client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        (proc {}).should_not have_enqueued(:body => @message)
+        should have_enqueued(:body => @message)
+      end
+
+
+      it 'should not match when not given a count and job found' do
+        should_not have_enqueued(:body => @message)
+        ::RSpec::Expectations.expects(:fail_with)
+        proc do
+          2.times do
+            client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+          end
+        end.should_not have_enqueued(:body => @message)
+        should have_enqueued(:body => @message)
+      end
+
+
+      it 'should not match when found count matches expected count' do
+        should_not have_enqueued(:body => @message)
+        ::RSpec::Expectations.expects(:fail_with)
+        proc do
+          client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        end.should_not have_enqueued(:body => @message, :count => 1)
+        should have_enqueued(:body => @message, :count => 1)
+      end
+
+
+      it 'should not match when found count falls in expected range' do
+        should_not have_enqueued(:body => @message)
+        ::RSpec::Expectations.expects(:fail_with)
+        proc do
+          2.times do
+            client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+          end
+        end.should_not have_enqueued(:body => @message, :count => 1..3)
+        should have_enqueued(:body => @message, :count => 1..3)
+      end
+    end
+
+  end
+
+
+  describe 'tube matcher' do
+
+    describe 'positive match' do
+
+      it 'should match when matching tube found' do
+        client.transmit("put 0 0 120 2\r\nxx")
+        client.transmit("put 0 120 120 2\r\nxx")
+        client.transmit("pause-tube #{@tube_name} 0")
+
+        should have_tube({
+          'name' => @tube_name,
+          'cmd-pause' => 1..3,
+          'current-jobs-ready' => 1,
+          'current-jobs-delayed' => 1,
+          'current-using' => 1,
+        })
+      end
+
+
+      it 'should not match when no matching tubes are found' do
+        should_not have_tube(:name => SecureRandom.uuid)
+
+        default_stats = client.transmit('stats-tube default')[:body]
+        urgent = default_stats['current-jobs-urgent']
+        should_not have_tube({
+          'name' => 'default',
+          'current-jobs-urgent' => (urgent + 5)..(urgent + 10),
+        })
+        watching = default_stats['current-watching']
+        ::RSpec::Expectations.expects(:fail_with)
+        should have_tube({
+          'name' => 'default',
+          'current-watching' => watching + 10,
+        })
+      end
+
+    end
+
+
+    describe 'negative match' do
+
+      it 'should match when no matching tubes are found' do
+        should_not have_tube(:name => SecureRandom.uuid)
+
+        default_stats = client.transmit('stats-tube default')[:body]
+        urgent = default_stats['current-jobs-urgent']
+        should_not have_tube({
+          'name' => 'default',
+          'current-jobs-urgent' => (urgent + 5)..(urgent + 10),
+        })
+        watching = default_stats['current-watching']
+        should_not have_tube({
+          'name' => 'default',
+          'current-watching' => watching + 10,
+        })
+      end
+
+
+      it 'should not match when matching tube found' do
+        client.transmit("put 0 0 120 2\r\nxx")
+        client.transmit("put 0 120 120 2\r\nxx")
+        client.transmit("pause-tube #{@tube_name} 0")
+
+        ::RSpec::Expectations.expects(:fail_with)
+        should_not have_tube({
+          'name' => @tube_name,
+          'cmd-pause' => 1..3,
+          'current-jobs-ready' => 1,
+          'current-jobs-delayed' => 1,
+          'current-using' => 1,
+        })
+      end
+
+    end
+
+  end
+
+end