spec-unit 0.1.0 → 1.0.0

data/lib/spec-unit/assert_helper.rb

@@ -0,0 +1,66 @@
+module SpecUnit
+  module AssertHelper
+    def self.assert_helper(base)
+      base.module_eval do
+        class << self
+          for meth in methods
+            undef_method(meth) if meth.to_s =~ /^assert_/ || meth.to_s =~ /^assert$/
+          end
+
+          alias_method :spec_unit_method_missing, :method_missing 
+          def method_missing(sym, *args, &block)
+            if sym.to_s =~ /^assert_/
+              self.send(:define_method, :"test_#{args[0]}") do
+                if block
+                  send(sym, *(instance_eval(&block)))
+                else
+                  send(sym)
+                end
+              end
+            else
+              spec_unit_method_missing sym, *args, &block
+            end
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      assert_helper(base)
+    end
+  end
+end
+
+module SpecUnit
+  module ContextHelper
+    def self.assert_helper(base)
+      base.module_eval do
+        class << self
+          for meth in methods
+            undef_method(meth) if meth.to_s =~ /^assert_/ || meth.to_s =~ /^assert$/
+          end
+
+          alias_method :spec_unit_method_missing, :method_missing 
+          def method_missing(sym, *args, &block)
+            if sym.to_s =~ /^assert_/
+              self.send(:define_method, :"test_#{args[0]}") do
+                if block
+                  send(sym, *(instance_eval(&block)))
+                else
+                  send(sym)
+                end
+              end
+            else
+              spec_unit_method_missing sym, *args, &block
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+class Test::Unit::TestCase
+  include SpecUnit::AssertHelper
+end
+

data/lib/spec-unit/context_helper.rb

@@ -0,0 +1,68 @@
+module SpecUnit
+  module ContextHelper
+    def self.included(base)
+      base.extend(ClassMethods)
+      assert_helper(base) if self.respond_to?(:assert_helper)
+    end
+
+    module ClassMethods
+      def context(name, &block)
+        self.send :include, new_context(name, &block)
+      end
+
+      def new_context(name, &block)
+        context_module = new_context_module
+
+        context_module.module_eval(&block)
+        context_module.convert_specifications_to_tests(name.gsub(' ', '_'))
+        context_module
+      end
+
+      def new_context_module
+        Module.new do
+          include ContextHelper
+
+          def self.convert_specifications_to_tests(name)
+            teardown, setup = unbound_teardown, unbound_setup
+            specifications = self.instance_methods.select {|m| m.to_s =~ /^specify_/ || m.to_s =~ /^test_/}
+
+            specifications.each do |spec|
+              spec_method = unbound_method(spec)
+              spec_name = spec.to_s.split(/^\w+?_/)[1]
+
+              define_method("test_#{name}_#{spec_name}".to_sym) do
+                setup.bind(self).call if setup
+                spec_method.bind(self).call
+                teardown.bind(self).call if teardown
+              end
+            end
+          end
+
+          def self.unbound_setup
+            unbound_method(:setup)
+          end
+
+          def self.unbound_teardown
+            unbound_method(:teardown)
+          end
+
+          def self.unbound_method(meth)
+            if self.instance_methods.include? meth.to_s
+              unbound_meth = instance_method(meth)
+              remove_method(meth) rescue module_where_defined(meth).module_eval { remove_method meth }
+            end
+            unbound_meth
+          end
+
+          def self.module_where_defined(meth)
+            included_modules.detect { |mod| mod.method_defined?(meth) }
+          end
+        end
+      end
+    end
+  end
+end 
+
+class Test::Unit::TestCase
+  include SpecUnit::ContextHelper
+end

data/lib/spec-unit/should_helper.rb

@@ -0,0 +1,181 @@
+# Provide object.should testing functionality.
+
+module SpecUnit
+  class ShouldHelper
+    include Test::Unit::Assertions
+
+    def initialize(object, sym, *args, &block)
+      $spec_unit_test.send(:add_assertion)
+      @object = object
+      @not = !!(sym.to_s =~ /^should_not/)
+      sym = sym.to_s.sub(/_not/, '').to_sym if @not
+      self.send(sym, *args, &block)
+    end
+
+    def not_wrapper
+      @not ? !yield : yield
+    end
+
+    def should_with_predicate(meth, *args)
+      assert( not_wrapper { @object.send(meth.to_sym, *args) })
+    end
+
+    def should_with_method
+      self
+    end
+
+    %w( == < <= > >= ).each do |meth|
+      meth = meth.to_sym
+      self.send(:define_method, meth) do |another_object|
+        assert( not_wrapper { @object.send(meth, another_object) })
+      end
+    end
+
+    def should_be(another_object = nil)
+      if another_object.nil?
+        should_with_method
+      else
+        if @not
+          assert_not_same another_object, @object
+        else
+          assert_same another_object, @object
+        end
+      end
+    end
+
+    def should_be_a_kind_of(klass)
+      if @not
+        assert_block { !@object.kind_of?(klass) }
+      else
+        assert_kind_of klass, @object
+      end
+    end
+
+    def should_be_an_instance_of(klass)
+      if @not
+        assert_block { !@object.instance_of?(klass) }
+      else
+        assert_instance_of klass, @object
+      end
+    end
+
+    def should_be_close(another_object, delta)
+      if @not
+        assert_block { (another_object - delta > @object) || (another_object + delta < @object) }
+      else
+        assert_in_delta another_object, @object, delta
+      end
+    end
+
+    def should_equal(another_object)
+      if @not
+        assert_not_equal another_object, @object
+      else
+        assert_equal another_object, @object
+      end
+    end
+
+    def should_have(count)
+      if @not
+        assert_not_equal count, @object.size
+      else
+        assert_equal count, @object.size
+      end
+    end
+
+    def should_have_at_least(count)
+      assert( not_wrapper { @object.size >= count } )
+    end
+
+    def should_have_at_most(count)
+      assert( not_wrapper { @object.size <= count } )
+    end
+
+    def should_include(another_object)
+      assert( not_wrapper { @object.include?(another_object) } )
+    end
+
+    def should_raise(error=Exception)
+      assert_block do
+        not_wrapper do
+          begin
+            @object.call && false 
+          rescue error
+            true
+          rescue Exception
+            false
+          end
+        end
+      end
+    end
+
+    def should_respond_to(method)
+      if @not
+        assert_block { !@object.respond_to?(method) }
+      else
+        assert_respond_to @object, method
+      end
+    end
+
+    def should_satisfy(&block)
+      assert( not_wrapper { block.call(@object) } )
+    end
+
+    def should_throw(symbol=nil)
+      if @not
+        assert_block do
+          begin
+            caught = true
+            if symbol
+              catch(symbol) do
+                @object.call
+                caught = false
+              end
+            else
+              @object.call
+              caught = false
+            end
+          rescue NameError, ThreadError => error
+            if UncaughtThrow[error.class] !~ error.message
+              raise error
+            end
+            caught = symbol.nil? ? true : false
+          end
+          !caught
+        end
+      else
+        assert_throws(symbol, &@object)
+      end
+    end
+
+    def method_missing(sym, *args)
+      if sym.to_s =~ /^should_be_/ || sym.to_s =~ /^should_have_/ || sym.to_s =~ /^should_/
+        should_with_predicate($', *args)
+      else
+        self
+      end 
+    end
+  end
+end
+
+class Test::Unit::TestCase
+  alias_method :old_run, :run
+  def run(*args, &block)
+    $spec_unit_test = self
+    old_run(*args, &block)
+  end
+end
+
+Object.module_eval do
+  include Test::Unit::Assertions
+
+  alias_method :old_method_missing, :method_missing
+  def method_missing(sym, *args, &block)
+    if sym.to_s =~ /should/
+      SpecUnit::ShouldHelper.new(self, sym, *args, &block)
+    else
+      old_method_missing(sym, *args, &block)
+    end
+  end
+end
+

data/lib/spec-unit.rb

@@ -1,61 +1,3 @@
-module SpecUnit
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-
-  module ClassMethods
-    def context(name, &block)
-      self.send :include, new_context(name, &block)
-    end
-  
-    def new_context(name, &block)
-      context_module = new_context_module
-
-      context_module.module_eval(&block)
-      context_module.convert_specifications_to_tests(name.gsub(' ', '_'))
-      context_module
-    end
-
-    def new_context_module
-      Module.new do
-        include SpecUnit
-
-        def self.convert_specifications_to_tests(name)
-          teardown, setup = unbound_teardown, unbound_setup
-          specifications = self.instance_methods.select {|m| m.to_s =~ /^specify_/ || m.to_s =~ /^test_/}
-
-          specifications.each do |spec|
-            spec_method = unbound_method(spec)
-            spec_name = spec.to_s.split(/^\w+?_/)[1]
-
-            define_method("test_#{name}_#{spec_name}".to_sym) do
-              setup.bind(self).call if setup
-              spec_method.bind(self).call
-              teardown.bind(self).call if teardown
-            end
-          end
-        end
-
-        def self.unbound_setup
-          unbound_method(:setup)
-        end
-
-        def self.unbound_teardown
-          unbound_method(:teardown)
-        end
-
-        def self.unbound_method(meth)
-          if self.instance_methods.include? meth.to_s
-            unbound_meth = instance_method(meth)
-            remove_method(meth) rescue module_where_defined(meth).module_eval { remove_method meth }
-          end
-          unbound_meth
-        end
-
-        def self.module_where_defined(meth)
-          included_modules.detect { |mod| mod.method_defined?(meth) }
-        end
-      end
-    end
-  end
-end 
+require 'spec-unit/context_helper'
+require 'spec-unit/should_helper'
+require 'spec-unit/assert_helper'

data/test/helper.rb

@@ -0,0 +1,55 @@
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+
+class Test::Unit::TestCase
+  def assert_has_one_assertion(test)
+    assert_nothing_raised { @test_class.new(test.to_sym) }
+    assert_has_x_assertions(1, test)
+  end
+
+  def assert_has_x_assertions(number_of_assertions, test)
+    @result = Test::Unit::TestResult.new
+    @test_suite = @test_class.suite
+    @test_suite.run(@result) {|m, n|}
+    assert_equal number_of_assertions, @result.assertion_count
+  end
+
+  def assert_test_passes(test)
+    assert_test :passes, test
+  end
+
+  def assert_test_passes_with_setup(test, &block)
+    define_setup(&block) if block
+    assert_test_passes test
+  end
+
+  def assert_test_fails(test)
+    assert_test :fails, test
+  end
+
+  def assert_test_fails_with_setup(test, &block)
+    define_setup(&block) if block
+    assert_test_fails test
+  end
+
+  def assert_test(result, test)
+    @result = Test::Unit::TestResult.new
+    assert_nothing_raised { @object = @test_class.new(test.to_sym) }
+    @object.run(@result) {|m,n|}
+    assert_not_equal 0, @result.assertion_count
+    case result
+    when :passes
+      assert @result.passed?
+    when :fails
+      assert_equal 1, @result.failure_count
+    else
+      raise "'#{result}' is not a valid test condition."
+    end
+  end
+
+  def define_setup &block
+    @test_class.send :define_method, :setup, block
+  end
+
+end

data/test/test_assert_helper.rb

@@ -0,0 +1,147 @@
+$: << File.dirname(__FILE__)
+
+require 'helper'
+require 'spec-unit/context_helper'
+require 'spec-unit/should_helper'
+require 'spec-unit/assert_helper'
+
+class TestAssertHelper < Test::Unit::TestCase
+  def setup
+    @test_class = Class.new(Test::Unit::TestCase)
+  end
+
+  context 'assert_equal' do
+    def setup
+      @test_class.module_eval { assert_equal(:objects_are_equal) {[ @object, @another_object ]}}
+    end
+
+    def test_is_wrapped
+      assert_has_one_assertion(:test_objects_are_equal)
+    end
+
+    def test_passes
+      assert_test_passes_with_setup(:test_objects_are_equal) { @object, @another_object = 'this', 'this' }
+    end
+
+    def test_fails
+      assert_test_fails_with_setup(:test_objects_are_equal) { @object, @another_object = 'this', 'that' }
+    end
+  end
+
+  context 'assert_not_equal' do
+    def setup
+      @test_class.module_eval { assert_not_equal(:objects_are_not_equal) { next @object, @another_object }}
+    end
+
+    def test_is_wrapped
+      assert_has_one_assertion(:test_objects_are_not_equal)
+    end
+
+    def test_passes
+      assert_test_passes_with_setup(:test_objects_are_not_equal) { @object, @another_object = 'this', 'that' }
+    end
+
+    def test_fails
+      assert_test_fails_with_setup(:test_objects_are_not_equal) { @object, @another_object = 'this', 'this' }
+    end
+  end
+
+  context 'assert_equal in a context' do
+    def setup
+      @test_class.module_eval do
+        context 'in a context' do
+          assert_equal(:objects_are_equal) { next @object, @another_object }
+        end
+      end
+    end
+
+    def test_is_wrapped
+      assert_has_one_assertion(:test_in_a_context_objects_are_equal)
+    end
+
+    def test_passes
+      assert_test_passes_with_setup(:test_in_a_context_objects_are_equal) { @object, @another_object = 'this', 'this' }
+    end
+
+    def test_fails
+      assert_test_fails_with_setup(:test_in_a_context_objects_are_equal) { @object, @another_object = 'this', 'that' }
+    end
+  end
+
+  context 'a custom assertion' do
+    def setup
+      @test_class.module_eval do
+        def assert_my_own_things(object); object.should_equal 1; end
+        assert_my_own_things(:custom_assertion) { next @object }
+      end
+    end
+
+    def test_is_wrapped
+      assert_has_one_assertion(:test_custom_assertion)
+    end
+
+    def test_passes
+      assert_test_passes_with_setup(:test_custom_assertion) { @object = 1 }
+    end
+
+    def test_fails
+      assert_test_fails_with_setup(:test_custom_assertion) { @object = 2 }
+    end
+  end
+
+  context 'a custom assertion that takes no parameters' do
+    def setup
+      @test_class.module_eval do
+        def assert_custom; @object.should_equal 1; end
+        assert_custom(:custom)
+      end
+    end
+
+    def test_is_wrapped
+      assert_has_one_assertion(:test_custom)
+    end
+
+    def test_passes
+      assert_test_passes_with_setup(:test_custom) { @object = 1 }
+    end
+
+    def test_fails
+      assert_test_fails_with_setup(:test_custom) { @object = 2 }
+    end
+  end
+
+  context 'a custom assertion in a context that takes no parameters' do
+    def setup
+      @test_class.module_eval do
+        def assert_custom; @object.should_equal 1; end
+        context('a context') { assert_custom(:custom) }
+      end
+    end
+
+    def test_is_wrapped
+      assert_has_one_assertion(:test_a_context_custom)
+    end
+
+    def test_passes
+      assert_test_passes_with_setup(:test_a_context_custom) { @object = 1 }
+    end
+
+    def test_fails
+      assert_test_fails_with_setup(:test_a_context_custom) { @object = 2 }
+    end
+  end
+
+  context 'some_other_method' do
+    def test_throws_name_error
+      assert_raise(NameError) { @test_class.module_eval { some_other_method } }
+    end
+
+    def test_throws_name_error_in_context
+      assert_raise(NameError) do
+        @test_class.module_eval do
+          context('a context') { some_other_method }
+        end
+      end
+    end
+  end
+end