spec-unit 0.1.0 → 1.0.0

data/test/test_should_helper.rb

@@ -0,0 +1,575 @@
+$: << File.dirname(__FILE__)
+
+require 'helper'
+require 'spec-unit/context_helper'
+require 'spec-unit/should_helper'
+
+module SpecUnit
+  module ContextHelper
+    module ClassMethods
+      def assert_has_one_assertion(test)
+        self.send :define_method, :specify_has_one_assertion do
+          assert_has_one_assertion(test)
+        end
+      end
+
+      def assert_has_x_assertions(number_of_assertions, test)
+        self.send :define_method, :specify_has_x_assertions do
+          assert_has_x_assertions(number_of_assertions, test)
+        end
+      end
+
+      def assert_test_passes_with_setup(test, &block)
+        self.send :define_method, :specify_passes_test_with_setup do
+          assert_test_passes_with_setup(test, &block)
+        end
+      end
+
+      def assert_test_fails_with_setup(test, &block)
+        self.send :define_method, :specify_fails_test_with_setup do
+          assert_test_fails_with_setup(test, &block)
+        end
+      end
+    end
+  end
+end
+
+class TestShouldHelper < Test::Unit::TestCase
+  def self.tests_for( test, opts = {} )
+    test_name = (opts[:name] || test.to_s).sub(/should_/, '')
+    context "a test with should #{test_name}" do
+      define_method(:setup) { define_test(:test_test, &opts[:test].call(test)) }
+      assert_has_one_assertion(:test_test)
+      assert_test_passes_with_setup(:test_test, &opts[:pass])
+      assert_test_fails_with_setup(:test_test, &opts[:fail])
+    end
+
+    context "a test with should_not #{test_name}" do
+      negative_test = opts[:negative_test] ? opts[:negative_test][test] : opts[:test][('should_not' + test.to_s[6..-1]).to_sym]
+      define_method(:setup) { define_test(:test_test, &negative_test) }
+      assert_has_one_assertion(:test_test)
+      assert_test_passes_with_setup(:test_test, &opts[:fail])
+      assert_test_fails_with_setup(:test_test, &opts[:pass])
+    end
+  end
+
+  def setup
+    @test_class = Class.new(Test::Unit::TestCase)
+  end
+
+  context 'a test with two shoulds' do
+    def setup
+      define_test(:test_two_shoulds) do
+        @object ||= 'test'
+        @object.should_be_a_kind_of(String)
+        @object.should_equal 'test' 
+      end
+    end
+
+    assert_has_x_assertions(2, :test_two_shoulds)
+    assert_test_passes_with_setup(:test_two_shoulds) { @object = 'test' }
+    assert_test_fails_with_setup(:test_two_shoulds) { @object = 'game' }
+  end
+
+  context 'a test case with two tests' do
+    def setup
+      define_test(:test_one) { @object.should_be_a_kind_of(String) }
+      define_test(:test_two) { @object.should_equal 'test' }
+    end
+
+    def specify_has_two_assertions
+      assert_test_suite_has :assertions => 2
+    end
+
+    def specify_has_two_assertions_with_setup_defined
+      define_setup { @object = 'test' }
+      assert_test_suite_has :assertions => 2
+    end
+
+    def specify_works_when_both_test_pass
+      define_setup { @object = 'test' }
+      assert_test_suite_has :passes => true
+    end
+
+    def specify_works_when_first_test_passes
+      define_setup { @object = 'test_other_string' }
+      assert_test_suite_has :failures => 1, :errors => 0
+    end
+
+    def specify_works_when_both_tests_fail
+      define_setup { @object = 1 }
+      assert_test_suite_has :failures => 2, :errors => 0
+    end
+  end
+
+  tests_for :should_be_nil?,
+            :test => lambda { |test| lambda { @object.send(test) } },
+            :pass => lambda { @object = nil },
+            :fail => lambda { @object = 1 }
+
+  tests_for :should_be_empty?,
+            :test => lambda { |test| lambda { @object.send(test) } },
+            :pass => lambda { @object = '' },
+            :fail => lambda { @object = 'not empty' }
+
+  tests_for :should_have_empty?,
+            :test => lambda { |test| lambda { @object.send(test) } },
+            :pass => lambda { @object = '' },
+            :fail => lambda { @object = 'not empty' }
+
+  tests_for :should_equal?,
+            :test => lambda { |test| lambda { @object.send(test, @another_object) } },
+            :pass => lambda { @object = @another_object = 'this' },
+            :fail => lambda { @object = 'this'; @another_object = 'this' }
+
+  tests_for :==,
+            :test => lambda { |test| lambda { @object.should.send(test, @another_object) } },
+            :negative_test => lambda { |test| lambda { @object.should_not.send(test, @another_object) }},
+            :pass => lambda { @object, @another_object = 'this', 'this' },
+            :fail => lambda { @object, @another_object = 'this', 'that' }
+
+  tests_for :==,
+            :name => 'should_be_==',
+            :test => lambda { |test| lambda { @object.should_be.send(test, @another_object) } },
+            :negative_test => lambda { |test| lambda { @object.should_not_be.send(test, @another_object) } },
+            :pass => lambda { @object, @another_object = 'this', 'this' },
+            :fail => lambda { @object, @another_object = 'this', 'that' }
+
+  context 'a test with should_be <' do
+    def setup
+      define_test(:test_should_be_less_than) { @object.should_be < @another_object }
+    end
+
+    assert_has_one_assertion(:test_should_be_less_than)
+
+    def specify_passes_test_when_less_than
+      define_setup { @object, @another_object = 1, 2 }
+      assert_test_passes :test_should_be_less_than
+    end
+
+    def specify_fails_test_when_equal
+      define_setup { @object, @another_object = 1, 1 }
+      assert_test_fails :test_should_be_less_than
+    end
+
+    def specify_fails_test_when_greater_than
+      define_setup { @object, @another_object = 1, 0 }
+      assert_test_fails :test_should_be_less_than
+    end
+  end
+
+  context 'a test with should_not_be <' do
+    def setup
+      define_test(:test_should_not_be_less_than) { @object.should_not_be < @another_object }
+    end
+
+    assert_has_one_assertion(:test_should_not_be_less_than)
+
+    def specify_fails_test_when_less_than
+      define_setup { @object, @another_object = 1, 2 }
+      assert_test_fails :test_should_not_be_less_than
+    end
+
+    def specify_passes_test_when_equal
+      define_setup { @object, @another_object = 1, 1 }
+      assert_test_passes :test_should_not_be_less_than
+    end
+
+    def specify_passes_test_when_greater_than
+      define_setup { @object, @another_object = 1, 0 }
+      assert_test_passes :test_should_not_be_less_than
+    end
+  end
+
+  context 'a test with should_be <=' do
+    def setup
+      define_test(:test_should_be_less_than) { @object.should_be <= @another_object }
+    end
+
+    assert_has_one_assertion(:test_should_be_less_than)
+
+    def specify_passes_test_when_less_than
+      define_setup { @object, @another_object = 1, 2 }
+      assert_test_passes :test_should_be_less_than
+    end
+
+    def specify_passes_test_when_equal
+      define_setup { @object, @another_object = 1, 1 }
+      assert_test_passes :test_should_be_less_than
+    end
+
+    def specify_fails_test_when_greater_than
+      define_setup { @object, @another_object = 1, 0 }
+      assert_test_fails :test_should_be_less_than
+    end
+  end
+
+  context 'a test with should_not_be <=' do
+    def setup
+      define_test(:test_should_not_be_less_than) { @object.should_not_be <= @another_object }
+    end
+
+    assert_has_one_assertion(:test_should_not_be_less_than)
+
+    def specify_fails_test_when_less_than
+      define_setup { @object, @another_object = 1, 2 }
+      assert_test_fails :test_should_not_be_less_than
+    end
+
+    def specify_fails_test_when_equal
+      define_setup { @object, @another_object = 1, 1 }
+      assert_test_fails :test_should_not_be_less_than
+    end
+
+    def specify_passes_test_when_greater_than
+      define_setup { @object, @another_object = 1, 0 }
+      assert_test_passes :test_should_not_be_less_than
+    end
+  end
+
+  context 'a test with should_be >' do
+    def setup
+      define_test(:test_should_be_greater_than) { @object.should_be > @another_object }
+    end
+
+    assert_has_one_assertion(:test_should_be_greater_than)
+    assert_test_passes_with_setup(:test_should_be_greater_than) { @object, @another_object = 1, 0 }
+
+    def specify_fails_test_when_less_than
+      define_setup { @object, @another_object = 1, 2 }
+      assert_test_fails :test_should_be_greater_than
+    end
+
+    def specify_fails_test_when_equal
+      define_setup { @object, @another_object = 1, 1 }
+      assert_test_fails :test_should_be_greater_than
+    end
+  end
+
+  context 'a test with should_not_be >' do
+    def setup
+      define_test(:test_should_not_be_greater_than) { @object.should_not_be > @another_object }
+    end
+
+    assert_has_one_assertion(:test_should_not_be_greater_than)
+    assert_test_fails_with_setup(:test_should_not_be_greater_than) { @object, @another_object = 1, 0 }
+
+    def specify_fails_test_when_less_than
+      define_setup { @object, @another_object = 1, 2 }
+      assert_test_passes :test_should_not_be_greater_than
+    end
+
+    def specify_fails_test_when_equal
+      define_setup { @object, @another_object = 1, 1 }
+      assert_test_passes :test_should_not_be_greater_than
+    end
+  end
+
+  context 'a test with should_be >=' do
+    def setup
+      define_test(:test_should_be_greater_than) { @object.should_be >= @another_object }
+    end
+
+    assert_has_one_assertion(:test_should_be_greater_than)
+    assert_test_fails_with_setup(:test_should_be_greater_than) { @object, @another_object = 1, 2 }
+
+    def specify_passes_test_when_greater_than
+      define_setup { @object, @another_object = 3, 2 }
+      assert_test_passes :test_should_be_greater_than
+    end
+
+    def specify_passes_test_when_equal
+      define_setup { @object, @another_object = 1, 1 }
+      assert_test_passes :test_should_be_greater_than
+    end
+  end
+
+  context 'a test with should_not_be >=' do
+    def setup
+      define_test(:test_should_not_be_greater_than) { @object.should_not_be >= @another_object }
+    end
+
+    assert_has_one_assertion(:test_should_not_be_greater_than)
+    assert_test_passes_with_setup(:test_should_not_be_greater_than) { @object, @another_object = 1, 2 }
+
+    def specify_passes_test_when_greater_than
+      define_setup { @object, @another_object = 3, 2 }
+      assert_test_fails :test_should_not_be_greater_than
+    end
+
+    def specify_passes_test_when_equal
+      define_setup { @object, @another_object = 1, 1 }
+      assert_test_fails :test_should_not_be_greater_than
+    end
+  end
+
+  tests_for :should_equal,
+            :test => lambda { |test| lambda { @object.send(test, @another_object) } },
+            :pass => lambda { @object, @another_object = 'this', 'this' },
+            :fail => lambda { @object, @another_object = 'this', 'that' }
+
+  tests_for :should_satisfy,
+            :test => lambda { |test| lambda { @object.should_satisfy { |obj| obj == @another_object } } },
+            :negative_test => lambda { |test| lambda { @object.should_not_satisfy { |obj| obj == @another_object } } },
+            :pass => lambda { @object, @another_object = 'this', 'this' },
+            :fail => lambda { @object, @another_object = 'this', 'that' }
+
+  context 'a test with should_be_close' do
+    def setup
+      define_test(:test_should_be_close) { @object.should_be_close @another_object, 0.05 }
+    end
+
+    assert_has_one_assertion(:test_should_be_close)
+
+    def specify_passes_test_when_close
+      define_setup { @object, @another_object = 1, 1.01 }
+      assert_test_passes :test_should_be_close
+    end
+
+    def specify_passes_test_on_edge
+      define_setup { @object, @another_object = 1, 1.049 }
+      assert_test_passes :test_should_be_close
+    end
+
+    def specify_passes_test_when_equal
+      define_setup { @object, @another_object = 1, 1 }
+      assert_test_passes :test_should_be_close
+    end
+
+    def specify_fails_test_when_not_close
+      define_setup { @object, @another_object = 1, 1.06 }
+      assert_test_fails :test_should_be_close
+    end
+  end
+
+  context 'a test with should_not_be_close' do
+    def setup
+      define_test(:test_should_not_be_close) { @object.should_not_be_close @another_object, 0.05 }
+    end
+
+    assert_has_one_assertion(:test_should_not_be_close)
+
+    def specify_fails_test_when_close
+      define_setup { @object, @another_object = 1, 1.01 }
+      assert_test_fails :test_should_not_be_close
+    end
+
+    def specify_fails_test_on_edge
+      define_setup { @object, @another_object = 1, 1.049 }
+      assert_test_fails :test_should_not_be_close
+    end
+
+    def specify_fails_test_when_equal
+      define_setup { @object, @another_object = 1, 1 }
+      assert_test_fails :test_should_not_be_close
+    end
+
+    def specify_passes_test_when_not_close
+      define_setup { @object, @another_object = 1, 1.06 }
+      assert_test_passes :test_should_not_be_close
+    end
+  end
+
+  tests_for :should_be,
+            :test => lambda { |test| lambda { @object.send(test, @another_object) } },
+            :pass => lambda { @object = @another_object = 'this' },
+            :fail => lambda { @object, @another_object = 'this', 'this' }
+
+  tests_for :should_match,
+            :test => lambda { |test| lambda { @object.send(test, /is/) } },
+            :pass => lambda { @object = 'this' },
+            :fail => lambda { @object = 'that' }
+
+  tests_for :should_be_an_instance_of,
+            :test => lambda { |test| lambda { @object.send(test, String) } },
+            :pass => lambda { @object = 'this' },
+            :fail => lambda { @object = 1 }
+
+  tests_for :should_be_a_kind_of,
+            :test => lambda { |test| lambda { @object.send(test, Numeric) } },
+            :pass => lambda { @object = 1 },
+            :fail => lambda { @object = '1' }
+
+  tests_for :should_respond_to,
+            :test => lambda { |test| lambda { @object.send(test, :length) } },
+            :pass => lambda { @object = 'this' },
+            :fail => lambda { @object = 1 }
+
+  context 'a test with should_raise and exception' do
+    def setup
+      define_test(:test_should_raise) { @object.should_raise RuntimeError }
+    end
+
+    assert_has_one_assertion :test_should_raise
+    assert_test_passes_with_setup(:test_should_raise) { @object = lambda { raise } }
+    assert_test_fails_with_setup(:test_should_raise) { @object = lambda {} }
+
+    def specify_test_fails_with_other_error
+      assert_test_fails_with_setup(:test_should_raise) { @object = lambda { raise Exception } }
+    end
+  end
+
+  context 'a test with should_not_raise and exception' do
+    def setup
+      define_test(:test_should_not_raise) { @object.should_not_raise RuntimeError }
+    end
+
+    assert_has_one_assertion :test_should_not_raise
+    assert_test_fails_with_setup(:test_should_not_raise) { @object = lambda { raise } }
+    assert_test_passes_with_setup(:test_should_not_raise) { @object = lambda {} }
+
+    def specify_test_passes_with_other_error
+      assert_test_passes_with_setup(:test_should_not_raise) { @object = lambda { raise Exception } }
+    end
+  end
+
+  tests_for :should_raise,
+            :test => lambda { |test| lambda { @object.send(test) } },
+            :pass => lambda { @object = lambda { raise } },
+            :fail => lambda { @object = lambda {} }
+
+  context 'a test with should_throw' do
+    def setup
+      define_test(:test_should_throw) { @object.should_throw :thrown }
+    end
+
+    assert_has_one_assertion :test_should_throw
+    assert_test_passes_with_setup(:test_should_throw) { @object = lambda { throw :thrown } }
+    assert_test_fails_with_setup(:test_should_throw) { @object = lambda {} }
+
+    def specify_test_fails_with_other_symbol_thrown
+      assert_test_fails_with_setup(:test_should_throw) { @object = lambda { throw :other } }
+    end
+  end
+
+  context 'a test with should_not_throw' do
+    def setup
+      define_test(:test_should_not_throw) { @object.should_not_throw :thrown }
+    end
+
+    assert_has_one_assertion :test_should_not_throw
+    assert_test_fails_with_setup(:test_should_not_throw) { @object = lambda { throw :thrown } }
+    assert_test_passes_with_setup(:test_should_not_throw) { @object = lambda {} }
+
+    def specify_test_passes_with_other_symbol_thrown
+      assert_test_passes_with_setup(:test_should_not_throw) { @object = lambda { throw :other } }
+    end
+  end
+
+  context 'a test with should_not_throw and no symbol' do
+    def setup
+      define_test(:test_should_not_throw) { @object.should_not_throw }
+    end
+
+    assert_has_one_assertion :test_should_not_throw
+    assert_test_fails_with_setup(:test_should_not_throw) { @object = lambda { throw :thrown } }
+    assert_test_passes_with_setup(:test_should_not_throw) { @object = lambda {} }
+  end
+
+  tests_for :should_include,
+            :test => lambda { |test| lambda { @object.send(test, 'a') } },
+            :pass => lambda { @object = %w( a b c ) },
+            :fail => lambda { @object = [1, 2, 3] }
+
+  context 'a test with should_have_things' do
+    def setup
+      define_test(:test_should_have_things) { @object.should_have(2).things }
+    end
+
+    assert_has_one_assertion :test_should_have_things
+    assert_test_passes_with_setup(:test_should_have_things) { @object = %w( a b ) }
+    assert_test_fails_with_setup(:test_should_have_things) { @object = %w( a ) }
+    
+    def specify_fails_with_too_many_items
+      assert_test_fails_with_setup(:test_should_have_things) { @object = %w( a b c ) }
+    end
+  end
+
+  context 'a test with should_not_have_things' do
+    def setup
+      define_test(:test_should_not_have_things) { @object.should_not_have(2).things }
+    end
+
+    assert_has_one_assertion :test_should_not_have_things
+    assert_test_fails_with_setup(:test_should_not_have_things) { @object = %w( a b ) }
+    assert_test_passes_with_setup(:test_should_not_have_things) { @object = %w( a ) }
+    
+    def specify_passes_with_too_many_items
+      assert_test_passes_with_setup(:test_should_not_have_things) { @object = %w( a b c ) }
+    end
+  end
+
+  context 'a test with should_have_at_least' do
+    def setup
+      define_test(:test_should_have_at_least) { @object.should_have_at_least(2).things }
+    end
+
+    assert_has_one_assertion :test_should_have_at_least
+    assert_test_passes_with_setup(:test_should_have_at_least) { @object = %w( a b ) }
+    assert_test_fails_with_setup(:test_should_have_at_least) { @object = %w( a ) }
+
+    def specify_passes_with_more_items
+      assert_test_passes_with_setup(:test_should_have_at_least) { @object = %w( a b c ) }
+    end
+  end
+
+  context 'a test with should_not_have_at_least' do
+    def setup
+      define_test(:test_should_not_have_at_least) { @object.should_not_have_at_least(2).things }
+    end
+
+    assert_has_one_assertion :test_should_not_have_at_least
+    assert_test_fails_with_setup(:test_should_not_have_at_least) { @object = %w( a b ) }
+    assert_test_passes_with_setup(:test_should_not_have_at_least) { @object = %w( a ) }
+
+    def specify_fails_with_more_items
+      assert_test_fails_with_setup(:test_should_not_have_at_least) { @object = %w( a b c ) }
+    end
+  end
+
+  context 'a test with should_have_at_most' do
+    def setup
+      define_test(:test_should_have_at_most) { @object.should_have_at_most(2).things }
+    end
+
+    assert_has_one_assertion :test_should_have_at_most
+    assert_test_passes_with_setup(:test_should_have_at_most) { @object = %w( a b ) }
+    assert_test_fails_with_setup(:test_should_have_at_most) { @object = %w( a b c) }
+
+    def specify_passes_with_more_items
+      assert_test_passes_with_setup(:test_should_have_at_most) { @object = %w( a ) }
+    end
+  end
+
+  context 'a test with should_not_have_at_most' do
+    def setup
+      define_test(:test_should_not_have_at_most) { @object.should_not_have_at_most(2).things }
+    end
+
+    assert_has_one_assertion :test_should_not_have_at_most
+    assert_test_fails_with_setup(:test_should_not_have_at_most) { @object = %w( a b ) }
+    assert_test_passes_with_setup(:test_should_not_have_at_most) { @object = %w( a b c) }
+
+    def specify_fails_with_more_items
+      assert_test_fails_with_setup(:test_should_not_have_at_most) { @object = %w( a ) }
+    end
+  end
+
+  def define_test test, &block
+    @test_class.send :define_method, test, block
+  end
+
+  def run_test_suite
+    @result = Test::Unit::TestResult.new
+    @test_suite = @test_class.suite
+    @test_suite.run(@result) {|m,n|}
+  end
+
+  def assert_test_suite_has(opts)
+    run_test_suite
+    assert @result.passed? if opts[:passes]
+    assert_equal(opts[:assertions], @result.assertion_count) if opts[:assertions]
+    assert_equal(opts[:failures], @result.failure_count) if opts[:failures]
+    assert_equal(opts[:errors], @result.error_count) if opts[:errors]
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: spec-unit
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2006-10-11 00:00:00 -04:00
+  version: 1.0.0
+date: 2006-12-21 00:00:00 -05:00
 summary: A library for separating Test::Unit tests into contexts.
 require_paths: 
 - lib
@@ -30,9 +30,18 @@ authors:
 - Trotter Cashion
 files: 
 - lib/spec-unit.rb
-- test/test_spec_unit.rb
+- lib/spec-unit/assert_helper.rb
+- lib/spec-unit/context_helper.rb
+- lib/spec-unit/should_helper.rb
+- test/helper.rb
+- test/test_assert_helper.rb
+- test/test_context_helper.rb
+- test/test_should_helper.rb
 test_files: 
-- test/test_spec_unit.rb
+- test/helper.rb
+- test/test_assert_helper.rb
+- test/test_context_helper.rb
+- test/test_should_helper.rb
 rdoc_options: []
 
 extra_rdoc_files: []