bean_counter 0.0.1

data/test/unit/strategy_test.rb

@@ -0,0 +1,98 @@
+require 'test_helper'
+
+class StrategyTest < BeanCounter::TestCase
+
+  context 'Strategy' do
+
+    context 'inherited' do
+
+      should 'maintain a dict of defined strategies' do
+        initial_strategies = BeanCounter::Strategy.strategies.keys
+        BeanCounter::DummyStrategy = Class.new(BeanCounter::Strategy)
+        new_strategy = BeanCounter::Strategy.strategies.keys - initial_strategies
+        assert_equal 1, new_strategy.length
+        assert_equal BeanCounter::DummyStrategy, BeanCounter::Strategy.strategies[new_strategy.first]
+      end
+
+    end
+
+
+    context 'known_strategy?' do
+
+      should 'return true for items that subclasses of BeanCounter::Strategy' do
+        assert BeanCounter::Strategy.known_strategy?(BeanCounter::KnownStrategy)
+      end
+
+
+      should 'try to lookup sym version of identifier if respond to to_sym' do
+        assert BeanCounter::Strategy.known_strategy?(:'BeanCounter::KnownStrategy')
+        refute BeanCounter::Strategy.known_strategy?('BeanCounter::UnknownStrategy')
+      end
+
+    end
+
+
+    context 'materialize_strategy' do
+
+      should 'raise ArgumentError if unknown strategy' do
+        original_strategy = BeanCounter.strategy
+        [
+          'BeanCounter::UnknownStrategy',
+          :'BeanCounter::UnknownStrategy',
+          String
+        ].each do |bad_strategy|
+          assert_raises(ArgumentError) do
+            BeanCounter.strategy = bad_strategy
+          end
+          assert_equal original_strategy, BeanCounter.strategy
+        end
+      end
+
+
+      should 'return class form of strategy when given valid strategy' do
+        [
+          'BeanCounter::KnownStrategy',
+          :'BeanCounter::KnownStrategy',
+          BeanCounter::KnownStrategy
+        ].each do |good_strategy|
+          assert_equal(
+            BeanCounter::KnownStrategy,
+            BeanCounter::Strategy.materialize_strategy(good_strategy)
+          )
+        end
+      end
+
+    end
+
+
+    context 'strategies' do
+
+      should 'return an immutable dict of strategies' do
+        strategies = BeanCounter::Strategy.strategies
+        strategies[:Foo] = :Foo
+        refute_equal BeanCounter::Strategy.strategies, strategies
+      end
+
+    end
+
+
+    context 'interface methods' do
+
+      setup do
+        @strategy = BeanCounter::Strategy.new
+      end
+
+
+      should 'return NotImplementedError for interface methods' do
+        %w[collect_new_jobs delete_job jobs job_matches? pretty_print_job pretty_print_tube tube_matches? tubes].each do |method|
+          assert_raises(NotImplementedError, "Expected strategy to raise NotImplementedError for #{method}") do
+            @strategy.send(method)
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/unit/test_assertions_test.rb

@@ -0,0 +1,270 @@
+require 'test_helper'
+
+class TestAssertionsTest < BeanCounter::TestCase
+
+  setup do
+    BeanCounter.reset!
+    @tube_name = SecureRandom.uuid
+    client.transmit("use #{@tube_name}")
+    @message = SecureRandom.uuid
+  end
+
+
+  # Fuller testing of assertions handled by matcher and strategy tests.
+  # Just make sure assertions work as expected at high level
+  context 'simple job assertions' do
+
+    should 'match any matching job when not given a count' do
+      refute_enqueued(:body => @message)
+      assert_enqueues(:body => @message) do
+        2.times do
+          client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        end
+      end
+      assert_enqueued(:body => @message)
+    end
+
+
+    should 'match count exactly when given integer count' do
+      refute_enqueued(:body => @message)
+      assert_enqueues(:body => @message, :count => 1) do
+        client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+      end
+      assert_enqueued(:body => @message, :count => 1)
+    end
+
+
+    should 'match count to range when given range' do
+      refute_enqueued(:body => @message)
+      assert_enqueues(:body => @message, :count => 1..3) do
+        2.times do
+          client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        end
+      end
+      assert_enqueued(:body => @message, :count => 1..3)
+    end
+
+
+    context 'failed assertion expectations' do
+
+      setup do
+        # Setting expectation for call count behaves strangely probably because
+        # of expectation on assert. So count assertions manually
+        @assert_calls = 0
+        self.expects(:assert).at_least_once.with do |truth, message|
+          @assert_calls += 1
+          !truth
+        end
+      end
+
+
+      should 'fail assertion when no matching jobs enqueued' do
+        assert_enqueues(:body => /.*/) { }
+        assert_enqueued(:body => /.*/)
+
+        reset_expectations
+        assert_equal 2, @assert_calls
+      end
+
+
+      should 'fail assertion when no matching jobs enqueued during block' do
+        client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        assert_enqueues(:body => @message) {}
+        refute_enqueued(:body => %r[(?!#{@message})])
+
+        reset_expectations
+        # Refute calls assert, so assert_calls is incremented
+        assert_equal 2, @assert_calls
+      end
+
+
+      should 'fail assertion when too few matching jobs enqueued' do
+        assert_enqueues(:body => @message, :count => 2) do
+          client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+        end
+        assert_enqueued(:body => @message, :count => 2)
+
+        reset_expectations
+        assert_equal 2, @assert_calls
+      end
+
+
+      should 'fail assertion when too many matching jobs enqueued' do
+        assert_enqueues(:body => @message, :count => 1) do
+          2.times do
+            client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+          end
+        end
+        assert_enqueued(:body => @message, :count => 1)
+
+        reset_expectations
+        assert_equal 2, @assert_calls
+      end
+
+
+      should 'fail assertion when number of matching jobs outside given range' do
+        assert_enqueues(:body => @message, :count => 1..2) do
+          3.times do
+            client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+          end
+        end
+        assert_enqueued(:body => @message, :count => 1..2)
+
+        reset_expectations
+        assert_equal 2, @assert_calls
+      end
+
+    end
+
+  end
+
+
+  context 'tube assertions' do
+
+    should 'pass assertion 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")
+
+      assert_tube({
+        'name' => @tube_name,
+        'cmd-pause' => 1..3,
+        'current-jobs-ready' => 1,
+        'current-jobs-delayed' => 1,
+        'current-using' => 1,
+      })
+    end
+
+
+    context 'failed assertion expectations' do
+
+      setup do
+        # Setting expectation for call count behaves strangely probably because
+        # of expectation on assert. So count assertions manually
+        @assert_calls = 0
+        self.expects(:assert).at_least_once.with do |truth, message|
+          @assert_calls += 1
+          !truth
+        end
+      end
+
+
+      should 'fail assertion when no matching tubes found' do
+        assert_tube(:name => /#{SecureRandom.uuid}/)
+
+        reset_expectations
+        assert_equal 1, @assert_calls
+      end
+
+    end
+
+  end
+
+
+  context 'job refutations' do
+
+    should 'pass refutation when no matching jobs are found' do
+      message = SecureRandom.uuid
+      refute_enqueues(:body => message) do
+        client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+      end
+      assert_enqueued(:body => @message)
+      refute_enqueued(:body => message)
+    end
+
+
+    should 'pass refutation when if no matching jobs are enqueued during block' do
+      client.transmit("put 0 0 120 #{@message.bytesize}\r\n#{@message}")
+      refute_enqueues(:body => @message) {}
+      assert_enqueued(:body => @message)
+    end
+
+
+    context 'failed refutation expectations' do
+
+      should 'fail refutation when any matching jobs are enqueued' do
+        # Setting expectation for call count behaves strangely probably because
+        # of expectation on refute. So count refutaions manually
+        @refute_calls = 0
+        self.expects(:assert).at_least_once.with do |truth, message|
+          @refute_calls += 1
+          !truth
+        end
+        uuid = SecureRandom.uuid
+        client.transmit("use #{uuid}")
+        refute_enqueues(:body => /.*/) do
+          client.transmit("put 0 0 120 #{uuid.bytesize}\r\n#{uuid}")
+        end
+        refute_enqueued(:body => /.*/)
+
+        reset_expectations
+        assert_equal 2, @refute_calls
+      end
+
+    end
+
+  end
+
+
+  context 'tube refutations' do
+
+    should 'pass refutation when no matching tubes are found' do
+      refute_tube(:name => SecureRandom.uuid)
+
+      default_stats = client.transmit('stats-tube default')[:body]
+      urgent = default_stats['current-jobs-urgent']
+      refute_tube({
+        'name' => 'default',
+        'current-jobs-urgent' => (urgent + 5)..(urgent + 10),
+      })
+      watching = default_stats['current-watching']
+      refute_tube({
+        'name' => 'default',
+        'current-watching' => watching + 10,
+      })
+    end
+
+
+    context 'failed refutation expectations' do
+
+      setup do
+        # Setting expectation for call count behaves strangely probably because
+        # of expectation on assert. So count assertions manually
+        @assert_calls = 0
+        self.expects(:assert).at_least_once.with do |truth, message|
+          @assert_calls += 1
+          !truth
+        end
+      end
+
+
+      should 'fail assertion 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")
+
+        refute_tube({
+          'name' => @tube_name,
+          'cmd-pause' => 1..3,
+          'current-jobs-ready' => 1,
+          'current-jobs-delayed' => 1,
+          'current-using' => 1,
+        })
+
+        reset_expectations
+        assert_equal 1, @assert_calls
+      end
+
+    end
+
+  end
+
+
+  def reset_expectations
+    # Must manually call mocha_teardown inside test body or expectation
+    # when setting expectation on assert or refute, otherwise expectation
+    # survives to the next test
+    mocha_teardown
+  end
+
+end

data/test/unit/tube_expectation_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+class TubeExpectationTest < BeanCounter::TestCase
+
+  TubeExpectation = BeanCounter::TubeExpectation
+
+  context 'failure message' do
+
+    setup do
+      @expectation = TubeExpectation.new({})
+    end
+
+
+    should 'return expected message if no tube found' do
+      @expectation.strategy.tubes.expects(:detect).returns(nil)
+      @expectation.expected.expects(:to_s).returns('expected')
+      refute @expectation.matches?
+      expected = 'expected tube matching expected, found none.'
+      assert_equal expected, @expectation.failure_message
+    end
+
+
+    should 'return empty string if tube found' do
+      @expectation.strategy.tubes.expects(:detect).returns(:tube)
+      assert @expectation.matches?
+      assert_equal '', @expectation.failure_message
+    end
+
+  end
+
+
+  context '#new' do
+
+    should 'set expected correctly' do
+      expected = {:name => 'some_tube'}
+      expectation = TubeExpectation.new(expected)
+      assert_equal expected, expectation.expected
+    end
+
+  end
+
+
+  context '#matches?' do
+
+    setup do
+      @expectation = TubeExpectation.new({})
+    end
+
+
+    should 'return true and set found if strategy.tubes includes match' do
+      @expectation.strategy.expects(:tubes).returns([:wrong_tube, :right_tube, :wrong_tube])
+      @expectation.strategy.expects(:tube_matches?).twice.returns(false, true)
+      assert @expectation.matches?
+      assert_equal :right_tube, @expectation.found
+    end
+
+
+    should 'return false and set found if strategy does not include match' do
+      @expectation.strategy.expects(:tubes).returns([:wrong_tube])
+      @expectation.strategy.expects(:tube_matches?).returns(false)
+      refute @expectation.matches?({})
+      assert_nil @expectation.found
+    end
+
+  end
+
+
+  context '#negative_failure_message' do
+
+    setup do
+      @expectation = TubeExpectation.new({})
+    end
+
+
+    should 'return empty string if nothing found' do
+      @expectation.strategy.expects(:tubes).returns([])
+      refute @expectation.matches?
+      assert_equal '', @expectation.negative_failure_message
+    end
+
+
+    should 'return expected message if a tube found' do
+      @expectation.strategy.tubes.expects(:detect).returns(:tube)
+      @expectation.strategy.expects(:pretty_print_tube).returns('tube')
+      @expectation.expected.expects(:to_s).returns('expected')
+      assert @expectation.matches?
+      expected = 'expected no tubes matching expected, found tube'
+      assert_equal expected, @expectation.negative_failure_message
+    end
+
+  end
+
+end