fun_with_testing 0.0.4 → 0.0.7

data/lib/fun_with/testing/assertions_test_case.rb

@@ -0,0 +1,65 @@
+module FunWith
+  module Testing
+    # Class is designed specifically for testing custom assertions.
+    # See test/test_assertions.rb for how it's supposed to work.
+    class AssertionsTestCase < FunWith::Testing::TestCase
+      # Any subclass of Test::Unit::TestCase seems to automatically hook into the test suite.
+      # Therefore, calling a test to see if it returns false makes the suite fail.  Including
+      # to this class instead prevents that.  
+      #
+      # I may need to more closely mimic Test::Unit::TestCase
+      # in order to test messages properly.
+      def safe_assert_block( *args, &block )
+        yield
+      end
+
+      def extended_test_case( &block )
+        @case_class = Class.new( FunWith::Testing::AssertionsTestCase )
+
+        @case = @case_class.new( "MockUnitTest" )        # what does name arg do?
+    
+        assert @case_class.methods.include?( :_should )
+        assert @case_class.methods.include?( :_context )
+        # assert @case.methods.include?( :in_test_mode? )
+    
+        yield if block_given?
+      end
+  
+      def must_flunk( &block )
+        assert_raises( Minitest::Assertion ) do
+          if block_given?
+            yield
+          end
+        end
+      end
+  
+      def yep( *args, &block )
+        assert @case.send( @current_method_sym, *args, &block )
+      end
+
+      def nope( *args, &block )
+        must_flunk do
+          @case.send( @current_method_sym, *args, &block )
+      
+          # shouldn't get here
+          puts "should fail: #{@current_method_sym}( #{ args.map(&:inspect).join(", ")})"
+        end
+      end
+  
+      def oops( *args )
+        assert_raises( StandardError ) do
+          @case.send( @current_method_sym, *args, &block )
+      
+          # should not get here
+          puts "should cause error: #{@current_method_sym}( #{ args.map(&:inspect).join(", ")})"
+        end
+      end
+  
+      def testing_method( m, &block )
+        @current_method_sym = m
+        yield
+      end
+    end
+  end
+end
+    

data/lib/fun_with/testing/test_case.rb

@@ -1,57 +1,16 @@
 module FunWith
   module Testing
     class TestCase < Minitest::Test
-      # I may eventually decide that there's a reason to specify which
-      # gem is being tested, but this really wasn't it.
-      # 
-      # Okay, that was stupid.  The point was to allow verbosity to be specified in the gem's code,
-      # not just in the test suite.  What would that be... MyGem.test_mode?  MyGem.verbose_gem?  MyGem.say
-      def self.gem_to_test( gem_const = nil, test_mode = true )
-        if @fwt_gem_to_test
-          return @fwt_gem_to_test
-        elsif self.superclass.respond_to?( :gem_to_test )
-          self.superclass.gem_to_test
-        else
-          nil
-        end
-      end
-
-      def self.gem_to_test=( gem_const )
-        @fwt_gem_to_test = gem_const
-      end
-      
-      def self.set_test_mode( mode = true )
-        self.const_set( :FWT_TEST_MODE, mode )
-      end
-
-      # Originally named test_mode?(), but Test::Unit::TestCase picked up on the fact that it started with "test"
-      # and tried to run it as a test in its own right
-      def self.in_test_mode?
-        return self::FWT_TEST_MODE if self.constants.include?( :FWT_TEST_MODE )
-        return self.superclass.in_test_mode? if self.superclass.respond_to?(:in_test_mode?)
-        return false
-      end
-
-      def in_test_mode?
-        self.class.in_test_mode?
+      def self.install_verbosity
+        include VerbosityMethods
       end
       
-      def self.set_verbose( mode = true )
-        self.const_set( :FWT_TEST_VERBOSITY, mode )
+      def self.install_test_mode
+        include TestModeMethods
       end
       
-      def self.verbose?
-        return self::FWT_TEST_VERBOSITY if self.constants.include?( :FWT_TEST_VERBOSITY )
-        return self.superclass.verbose? if self.superclass.respond_to?(:verbose)
-        return false
-      end
-
-      def verbose?
-        self.class.verbose?
-      end
-      
-      def puts_if_verbose( msg, stream = $stdout )
-        stream.puts( msg ) if self.verbose?
+      def self.install_basic_assertions
+        include Assertions::Basics
       end
       
       # Convenience methods for disappearing a set of tests.  Useful for focusing on one or two tests.  
@@ -62,16 +21,9 @@ module FunWith
       def self._should(*args, &block)
         puts "<<< WARNING >>> IGNORING TEST #{args.inspect}. Remove leading _ from '_should()' to reactivate."
       end
-      
-      def test_gem_validity
-        if jem = self.class.gem_to_test
-          assert_equal [], jem.validate_gem
-        end
-      end
-      
-      def build_message( *args )
-        args.map(&:inspect).join("  ")
-      end
+      # def build_message( *args )
+      #   args.map(&:inspect).join("  ")
+      # end
     end
   end
 end

data/lib/fun_with/testing/test_mode_methods.rb

@@ -0,0 +1,32 @@
+module FunWith
+  module Testing
+    # For adding to a TestCase class
+    module TestModeMethods
+      def self.included( base )
+        base.extend( TestModeMethods::ClassMethods )
+        base.send( :include, TestModeMethods::InstanceMethods)
+      end
+      
+      def ClassMethods
+        def set_test_mode( mode = true )
+          self.const_set( :FWT_TEST_MODE, mode )
+        end
+
+        # Originally named test_mode?(), but Test::Unit::TestCase picked up on the fact that it started with "test"
+        # and tried to run it as a test in its own right
+        def in_test_mode?
+          return self::FWT_TEST_MODE if self.constants.include?( :FWT_TEST_MODE )
+          return self.superclass.in_test_mode? if self.superclass.respond_to?(:in_test_mode?)
+          return false
+        end
+      end
+      
+      def InstanceMethods
+        def in_test_mode?
+          self.class.in_test_mode?
+        end
+      end
+    end
+  end
+end
+      

data/lib/fun_with/testing/verbosity_methods.rb

@@ -0,0 +1,43 @@
+module FunWith
+  module Testing
+    # For adding to a TestCase class
+    module VerbosityMethods
+      def self.included( base )
+        base.extend( ClassMethods )
+        base.send( :include, InstanceMethods)
+      end
+      
+      module ClassMethods
+        def set_verbose( mode = true )
+          self.const_set( :FWT_TEST_VERBOSITY, mode )
+        end
+      
+        def verbose?
+          return self::FWT_TEST_VERBOSITY if self.constants.include?( :FWT_TEST_VERBOSITY )
+          return self.superclass.verbose? if self.superclass.respond_to?(:verbose)
+          return false
+        end
+      end
+      
+      module InstanceMethods
+        def verbose?
+          self.class.verbose?
+        end
+      
+        def puts_if_verbose( msg, stream = $stdout )
+          stream.puts( msg ) if self.verbose?
+        end
+      end
+    end
+  end
+end
+      
+
+
+module FunWith
+  module Testing
+    module VerbosityMethods
+      
+    end
+  end
+end

data/lib/fun_with_testing.rb

@@ -1,9 +1,9 @@
 require 'bundler'
-require 'debugger'
+require 'byebug'
 require 'minitest'
 require 'minitest/autorun'
 require 'shoulda'
-require 'jeweler'
+require 'juwelier'
 
 begin
   Bundler.setup(:default, :development)
@@ -15,15 +15,21 @@ end
 
 
 files = Dir.glob( File.join( File.dirname(__FILE__), "fun_with", "testing", "**", "*.rb" ) )
+files.map!{ |f| f.gsub( /\.rb$/, '' ) }
 
-for file in files.map{ |f| f.gsub(/\.rb$/, '') }
-  require file
-end
+# TODO: I don't think this is an ideal way to prevent infinite loops
+error_messages = []
 
+while files.length > 0
+  begin
+    file = files.shift
+    require file
+  rescue NameError => e   # if the class/module depends on a not-yet-defined class/module
+    warn "#{e.class}: #{e.message}"
+    files << file
+    raise "Too many errors!\n\t" + error_messages.join( "\n\t" ) if error_messages.length >= 100 
+  end
+end
 
-# FunWith::Testing.extend( FunWith::Testing::FwtExtensions )
-# FunWith::Testing.assertion_modules << FunWith::Testing::Assertions::ActiveRecord
-# FunWith::Testing.assertion_modules << FunWith::Testing::Assertions::Basics
 
 FunWith::Testing.send( :include, FunWith::Testing::Assertions::Basics )
-FunWith::Testing.send( :include, FunWith::Testing::Assertions::ActiveRecord )

data/test/helper.rb

@@ -1,6 +1,4 @@
-# require 'rubygems'
 require 'bundler'
-require 'debugger'
 
 begin
   Bundler.setup(:default, :development)
@@ -20,35 +18,8 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 
 require 'fun_with_testing'
-
-# class Minitest::Test
-# end
-
-# Any subclass of Test::Unit::TestCase seems to automatically hook into the test suite.
-# Therefore, calling a test to see if it returns false makes the suite fail.  Including
-# to this class instead prevents that.  I may need to more closely mimic Test::Unit::TestCase
-# in order to test messages properly.
-class MockUnitTest < FunWith::Testing::TestCase
-  def build_message( m, m2, obj = nil)
-    "#{m} #{m2} #{obj}"
-  end
-  
-  def safe_assert_block( *args, &block )
-    yield
-  end
-end
+# require_relative File.join( "classes", "mock_unit_test" )
 
 class FunWith::Testing::MyTestCase < FunWith::Testing::TestCase
-  def extended_test_case( &block )
-    @case_class = Class.new( MockUnitTest )
-    @case_class.send( :include, FunWith::Testing )
-    @case = @case_class.new( "MockUnitTest" )
-    
-    assert @case_class.methods.include?( :_should )
-    assert @case_class.methods.include?( :_context )
-    assert @case.methods.include?( :in_test_mode? )
-    
-    yield if block_given?
-  end
 end
 

data/test/test_assertions.rb

@@ -2,31 +2,595 @@ require 'helper'
 
 module FunWith
   module Testing
-    class TestAssertions < FunWith::Testing::MyTestCase
-      context "testing :assert_zero()" do
+    class TestAssertions < FunWith::Testing::AssertionsTestCase
+      def modded_object( &block )
+        m = Module.new(&block)
+        o = Object.new
+        o.extend( m )
+        o
+      end
+      
+      context "testing assertions" do
         setup do
-          extended_test_case
+          extended_test_case  # sets @case, which is used to access to assertions
+          @case_class.install_basic_assertions # send( :include, FunWith::Testing::Assertions::Basics )
+        end
+        
+        context "testing :assert_zero()" do
+          should "accept only zeroes, reject all others" do
+            testing_method :assert_zero do
+              yep  0
+              yep  0.0
+              
+              nope 1
+              nope :potato
+            end
+            
+            testing_method :refute_zero do
+              yep  1
+              yep  0.4
+              yep( -1 )
+              yep  :zero
+              yep  "0"
+              yep  "zero"
+              yep  ""
+              
+              nope 0
+              nope "0".to_i
+              nope "0".to_f
+            end
+          end
+        end
+        
+        
+        context "testing :assert_not_zero()" do
+          should "look for non-zeros everywhere" do
+            testing_method :assert_not_zero do
+              yep  1
+              yep( -1 )
+              yep  0.01
+              yep( -0.01 )
+              yep  :zero
+              yep  []
+              yep( {} )
+              yep  ""
+              yep  nil
+              nope 0
+            end
+          end
+        end
+        
+        context "testing :assert_one()" do
+          should "pass all tests" do
+            testing_method :assert_one do
+              yep  1
+              yep  1.0
+              yep  1.to_c   # comparison as a complex number
+              nope 2
+              nope( -3 )
+              nope []
+              nope( {} )
+            end
+          end
+        end
+
+        context "testing :refute_one()" do
+          should "pass all tests" do
+            testing_method :refute_one do
+              yep  2
+              yep( -3 )
+              yep  []
+              yep( {} )
+              nope 1
+              nope 1.0
+              nope 1.to_c   # comparison as a complex number
+            end
+          end
+        end
+
+        context "testing :assert_positive()" do
+          should "pass all tests" do
+            testing_method :assert_positive do
+              yep  1
+              yep  1000
+              yep  1000.0
+              yep  0.0000000000001
+              yep  5
+              yep  4
+              yep  0.00001
+              yep  Math::PI
+              yep  1337
+              yep  91
+
+              nope 0
+              nope( -0.00001 )
+              nope( -50 )
+              nope( -5000 )
+              nope( -50000 )
+              nope 0
+              nope( -0.000000000001 )
+              nope( -1 )
+              nope( -1000 )
+              nope( -1000000 )
+            
+              oops true
+              oops false
+              oops 10000.to_c
+              oops "3"
+              oops( {} )
+              oops []
+              oops :symbol           
+            end 
+          end
+        end
+
+        context "testing :refute_positive()" do
+          should "pass all tests" do
+            testing_method :refute_positive do
+              yep  0
+              yep  0.0
+              yep( -1 )
+              yep( -100 )
+              yep(  -0.000000000001 )
+              yep( -1 )
+              yep( -1000 )
+              yep( -1000000 )
+            
+              nope 1
+              nope 1000
+              nope 1000.0
+              nope 0.0000000000001
+              nope 0.0001
+              nope 1
+              nope 5
+              nope 99999999999999
+            
+              oops []
+              oops nil
+              oops 5.to_c
+              oops 10000.to_c
+              oops true
+              oops false
+            end
+          end
+        end
+        
+        context "testing :assert_true()" do
+          should "pass all tests" do
+            testing_method :assert_true do
+              yep  true
+            
+              nope false
+              nope nil
+              nope 5
+              nope "string"
+              nope :symbol
+              nope []
+              nope Hash.new
+            end
+          end
+        end
+
+        context "testing :assert_false()" do
+          should "pass all tests" do
+            testing_method :assert_false do
+              yep  false
+            
+              nope true
+              nope nil
+              nope 5
+              nope "string"
+              nope :symbol
+              nope []
+              nope Hash.new
+            end
+          end
+        end
+
+        context "testing :refute_true()" do
+          should "pass all tests" do
+            testing_method :refute_true do
+              yep  false
+              yep  nil
+              yep  5
+              yep  "string"
+              yep  :symbol
+              yep  []
+              yep  Hash.new
+          
+              nope true
+            end
+          end
+        end
+
+        context "testing :refute_false()" do
+          should "pass all tests" do
+            testing_method :refute_false do
+              yep  true
+              yep  nil
+              yep  5
+              yep  "string"
+              yep  :symbol
+              yep  []
+              yep  Hash.new
+
+              nope false
+            end
+          end
+        end
+        
+        context "testing :assert_nil()" do
+          should "pass all tests" do
+            testing_method :assert_nil do
+              yep  nil
+            
+              nope true
+              nope false
+              nope 5
+              nope "string"
+              nope :symbol
+              nope []
+              nope Hash.new
+            end
+          end
+        end
+        
+        context "testing :refute_nil()" do
+          should "pass all tests" do
+            testing_method :refute_nil do
+              yep  true
+              yep  false
+              yep  5
+              yep  "string"
+              yep  :symbol
+              yep  []
+              yep  Hash.new  # if not given parentheses, seen as a block not a hash.
+
+              nope nil
+            end
+          end
+        end
+        
+        context "testing :assert_blank()" do
+          should "pass all tests" do
+            
+            blank_obj = modded_object do
+              def blank?
+                true
+              end
+            end
+
+            fwfblank_obj = modded_object do
+              def fwf_blank?
+                true
+              end
+            end
+            
+            not_blank_obj = modded_object do
+              def blank?
+                false
+              end
+            end
+            
+            blank_error_obj = modded_object do
+              def fwf_blank?
+                raise StandardError.new("Raises error!")
+              end
+            end
+            
+            blank_returns_5_obj = modded_object do
+              def fwf_blank?
+                5
+              end
+            end
+            
+            testing_method :assert_responds_to_blank do
+              nope []
+              nope( {} )
+              nope ""
+              nope Object.new
+              nope Set.new
+
+              yep  blank_obj
+              yep  fwfblank_obj
+              yep  not_blank_obj
+              yep  blank_error_obj
+              yep  blank_returns_5_obj
+            end
+            
+            testing_method :assert_blank do
+              # As implemented, assert_blank first asserts the item responds to blank, causing its own error
+              nope []
+              nope( {} )
+              nope Set.new
+              nope ""
+
+              yep  blank_obj
+              yep  fwfblank_obj
+            
+              nope not_blank_obj
+            
+              oops blank_error_obj
+            end
+          end
+        end
+
+        context "testing :assert_matches()" do
+          should "pass all tests" do
+            testing_method :assert_matches do
+              yep  "Why hello there!", /hello/
+              nope "Why HELLO there!", /hello/
+              yep  "Why HELLO there!", /hello/i
+            
+              yep  "Why HELLO there!", "HELLO"
+              nope "Why HELLO there!", "hello"
+            
+              oops 5, /oopsie/
+              oops "oops", :symbol
+            end
+          end
+        end
+        
+        context "testing :refute_matches()" do
+          should "pass all tests" do
+            testing_method :refute_matches do
+              nope "Why hello there!", /hello/
+              yep  "Why HELLO there!", /hello/
+              nope "Why HELLO there!", /hello/i
+            
+              nope "Why HELLO there!", "HELLO"
+              yep  "Why HELLO there!", "hello"
+            
+              oops 5, /oopsie/
+              oops "oops", :symbol
+            end
+          end
+        end
+        
+        context "testing :assert_greater_than()" do
+          should "pass all tests" do
+            testing_method :assert_greater_than do
+              yep  5, 5.1
+              yep( -4, -3 )
+              yep  "a", "b"
+              nope 0, 0
+              nope 0, 0.0
+              nope 5.1, 5.0
+              nope( -4, -5 )
+            
+              oops 5, nil
+              oops 6, []
+            end
+          end
+        end
+        
+        context "testing :assert_less_than()" do
+          should "pass all tests" do
+            testing_method( :assert_less_than ) do
+              yep  5, 4
+              yep  "b", "a"
+              yep  100, 7.1
+              yep  0.0, -1
+              yep  0.999, 0.998
+            
+              nope 0, 0
+              nope 0.0, 0
+              nope "a", "a"
+              nope( -1000, -100 )
+              nope 5, 6
+            
+              oops 1000, "a"
+              oops "a", nil
+            end
+          end
         end
         
-        should "proclaim zero is zero" do
-          assert_equal true, @case.assert_zero( 0 )
+        context "testing :assert_at_most()" do
+          should "pass all tests" do
+            testing_method :assert_at_most do
+              yep  0, 0
+              yep  0, 0.0
+              yep  0.0, 0.0
+              yep  5, 3
+              yep  5, 1.4
+              
+              nope 2, 6
+              nope( -12, -4 )
+              
+              oops 5, []
+            end
+          end
+        end
+
+        context "testing :assert_at_least()" do
+          should "pass all tests" do
+            testing_method :assert_at_least do
+              yep  0, 0
+              yep  0, 0.0
+              yep  0.0, 0.0
+              yep  3, 5
+              yep  1.4, 5
+              
+              nope 6, 2
+              nope( -4, -14 )
+              
+              oops 5, []
+            end
+          end
+        end
+
+        context "testing :assert_times_are_close()" do
+          should "pass all tests" do
+            @ref_time = Time.now
+            
+            testing_method( :assert_times_are_close ) do
+              yep  @ref_time, @ref_time + 1
+              yep  @ref_time, @ref_time + 0.3
+              yep  @ref_time, @ref_time
+              yep  @ref_time, @ref_time - 5, 20    # 20-second window given
+            
+              nope @ref_time, @ref_time + 0.1, 0.01
+              nope @ref_time, @ref_time + 1.1
+              nope @ref_time, @ref_time - 1.1
+              nope @ref_time, @ref_time - 100
+              nope @ref_time, @ref_time - 100, 99
+            
+              oops @ref_time, nil
+              oops @ref_time, []
+            end
+          end
         end
         
-        should "refute the notion that zero is one" do
-          assert_equal false, @case.assert_zero( 1 )
+        context "testing :assert_equal_length()" do
+          should "pass all tests" do
+            testing_method( :assert_equal_length ) do
+              yep  [], []
+              yep  [], {}
+              yep  [1,2,3,4,5], { 1 => :one, 2 => :two, 3 => :three, 4 => :four, 5 => :five}
+              yep  Set.new, {}
+              yep  [1,2,3,4,5], :hello
+            
+              nope :hello, "goodbye"
+              nope [], { 1 => :one }
+              nope Set.new( [1,2,3] ), Set.new( [4,5,6,7] )
+            end
+          end
         end
         
-        should "demonstrate zero is not a potato" do
-          assert_equal false, @case.assert_zero( :potato )
+        context "testing :assert_length()" do
+          should "pass all tests" do
+            testing_method :assert_length do
+              yep 0, ""
+              yep 0, :""
+              yep 1, [ :one ]
+              yep 0..5, { 1 => :one, 2 => :two, 3 => :three }
+              yep 0..140, "This string is tweetable!"
+              yep 1..3, "two" 
+              yep 4, "four"
+            
+              nope 0, "hi"
+              nope 0, [ 1 ]
+              nope 5, "five"
+              nope 1..3, [1, 2, 3, 4]
+              nope 3..5, nil
+            end
+          end
         end
 
-        should "prove beyond a shadow of a doubt that zero is not a grue" do
-          assert_equal false, @case.assert_zero( "grue" )
+        context "testing :assert_equality_of_methods()" do
+          should "pass all tests" do
+            testing_method :assert_equality_of_methods do
+              yep  7, 7, :to_s, :hash, :to_f
+              nope 3, 4, :to_s, :hash, :to_f
+              nope [], {}, :last    # hash doesn't respond to last
+              nope 3, 4, :times
+              nope 3, 4, :respond_to?  # ArgumentError for both
+            end
+          end
         end
         
-        # curious why it doesn't have :to_f
-        should "acknowledge that Integer has instance_variable to :to_s" do
-          assert_equal( true, @case.assert_has_instance_method( Integer, :to_s ) )
+        context "testing :assert_nothing_raised()" do
+          should "pass all tests" do
+            testing_method :assert_nothing_raised do
+              yep do
+                5 + 6
+              end
+              
+              yep do
+                nil
+              end
+              
+              nope do
+                raise StandardError.new( "whoops" )
+              end
+            end
+          end
+        end
+        
+        # context "testing :555()" do
+        #   should "pass all tests" do
+        #     testing_method : do
+        #     yep
+        #     yep
+        #     yep
+        #     yep
+        #     yep
+        #     yep
+        
+        #     nope
+        #     nope
+        #     nope
+        #     nope
+        #     nope
+        #     nope
+        
+        #     oops
+        #   end
+        # end
+        # context "testing :555()" do
+        #   should "pass all tests" do
+        #     testing_method : do
+        #     yep
+        #     yep
+        #     yep
+        #     yep
+        #     yep
+        #     yep
+        
+        #     nope
+        #     nope
+        #     nope
+        #     nope
+        #     nope
+        #     nope
+        
+        #     oops
+        #   end
+        # end
+
+        
+        context "testing instance assertions" do
+          should "assure us that classes have methods" do
+            instance_methods = {
+              Integer => [:to_s, :odd?, :even?, :times, :ceil],
+              Fixnum  => [:to_f],
+              Array   => [:length, :each, :sort, :map],
+              Object  => [:hash, :tap, :is_a?, :to_s]
+            }
+            
+            testing_method :assert_has_instance_method do
+              for klass, methods in instance_methods
+                for method in methods
+                  yep klass, method
+                end
+              end
+            end
+          end
+          
+          should "assure us that classes don't have hinkey instance methods" do
+            instance_methods = {
+              Integer => [:to_p, :old?, :seven?, :timey, :seal],
+              Fixnum  => [:to_g],
+              Array   => [:lanth, :eech, :sorta, :nap, :way_too_long?],
+              Object  => [:hashbrown, :tarp, :is_also_a?, :to_sting]
+            }
+            
+            testing_method :assert_has_instance_method do
+              for klass, methods in instance_methods
+                for method in methods
+                  nope klass, method
+                end
+              end
+            end
+          end
+        end
+
+        context "testing length assertions" do
+          should "acknowledge the zerolengthiness of the empty array" do
+            @case.assert_length 0, []
+            @case.assert_length 17, %w(my mother told me to pick the very best one and the very best one is you)
+            @case.assert_equal_length [], []
+          end
         end
       end
     end