fun_with_testing 0.0.4 → 0.0.10

data/lib/fun_with/testing/assertions/basics.rb

@@ -1,200 +1,312 @@
+# A namespace module that acts as an umbrella for a 
+# collection of gems I'm maintaining. (rdoc)
+#
+# I seem to be trying to write an entire ecosystem
+# single-handed.  It's not going well.
 module FunWith
+  
+  # A gem that adds a collection of custom assertions to a test suite.
+  #
+  # Also includes some infrastructure for testing the assertions themselves.
+  #
+  # Other FunWith- gems will contain extensions with their own custom assertions.
+  # For example, FunWith::Files adds in things like `assert_directory()`, etc.
   module Testing
+    
+    # Modules full of custom assertions should go under this namespace.
     module Assertions
       module Basics
-        def assert_not_zero( actual, message = "" )
-          message = build_message(message, "should not be zero")
-
-          safe_assert_block message do
-            actual != 0
-          end
+        # Interesting thing about message() : returns a proc that, when called, returns
+        # the message string.  I don't quite understand why it's done that way, but
+        # to add a line to an existing msg proc, do `msg = message(msg){"line to add..."}`
+        
+        def assert_not_zero( actual, msg = nil )
+          msg = message(msg) { "Expected #{mu_pp(actual)} to not be zero" }
+          assert actual != 0, msg
+        end
+        
+        alias :refute_zero :assert_not_zero
+        
+        def assert_zero( actual, msg = nil )
+          msg = message(msg) { "should be zero, not <#{mu_pp(actual)}>" }
+          assert actual == 0, msg
         end
 
-        def assert_zero( actual, message = "" )
-          message = build_message(message, "should be zero, not <#{actual}>")
+        def assert_one( actual, msg = nil )
+          msg = message(msg) { "should be 1, not <#{mu_pp(actual)}>" }
+          assert actual == 1, msg
+        end
+        
+        def assert_not_one( actual, msg = nil )
+          msg = message(msg) { "should be 1, not <#{mu_pp(actual)}>" }
+          assert actual != 1, msg
+        end
+        
+        alias :refute_one :assert_not_one
+        
+        def assert_negative( actual, msg = nil )
+          msg = message(msg) { "should be negative, not <#{mu_pp(actual)}>" }
+          assert actual < 0, msg
+        end
 
-          safe_assert_block message do
-            actual == 0
-          end
+        def assert_not_negative( actual, msg = nil )
+          msg = message(msg) { "should NOT be negative, (actual) <#{mu_pp(actual)}>" }
+          assert actual >= 0, msg
         end
+        
+        alias :refute_negative :assert_not_negative
 
-        def assert_one( actual, message = "" )
-          message = build_message(message, "should be 1, not <#{actual}>")
+        def assert_positive( actual, msg = nil )
+          msg = message(msg) { "should be positive, not <#{mu_pp(actual)}>" }
+          assert actual > 0, msg
+        end
 
-          safe_assert_block message do
-            actual == 1
-          end
+        def assert_not_positive( actual, msg = nil )
+          msg = message(msg) { "should NOT be positive, (actual) <#{mu_pp(actual)}>" }
+          assert actual <= 0, msg
         end
         
-        def assert_negative( actual, message = "" )
-          message = build_message(message, "should be negative, not <#{actual}>")
+        alias :refute_positive :assert_not_positive
 
-          safe_assert_block message do
-            actual < 0
-          end
+        def assert_true( actual, msg = nil )
+          msg = message(msg) { "should be true (TrueClass), not <#{mu_pp(actual)}>" }
+          assert actual == true, msg
         end
 
-        def assert_true( actual, message = "" )
-          message = build_message(message, "should be true, not <#{actual}>")
-          safe_assert_block message do
-            actual == true
-          end
+        def refute_true( actual, msg = nil )
+          msg = message(msg) { "shouldn't be true (TrueClass)" }
+          assert actual != true, msg
+        end
+        
+        # rejects anything but an actual false, instance of the FalseClass
+        def assert_false( actual, msg = nil )
+          msg = message(msg) { "should be false (instance of FalseClass), not <#{mu_pp(actual)}>" }
+          assert actual == false, msg
         end
 
-        def assert_false( actual, message = "" )
-          message = build_message(message, "should be false, not <#{actual}>")
-          safe_assert_block message do
-            actual == false
-          end
+        def refute_false( actual, msg = nil )
+          msg = message(msg) { "shouldn't be false" }
+          assert actual != false, msg
         end
         
-        
-        def assert_nil( actual, message = "" )
-          message = build_message(message, "should be nil, not <#{actual}>")
-          safe_assert_block message do
-            actual == nil
-          end
+        def assert_nil( actual, msg = nil )
+          msg = message(msg) { "should be nil, not <#{mu_pp(actual)}>" }
+          assert actual == nil, msg
         end
         
-        def assert_not_nil( actual, message = "" )
-          message = build_message(message, "should not be nil")
-          safe_assert_block message do
-            actual != nil
-          end
+        def assert_not_nil( actual, msg = nil )
+          msg = message(msg) { "should not be nil" }
+          assert actual != nil, msg
         end
         
         alias :refute_nil :assert_not_nil
         
-        def assert_blank( obj, message = "" )
-          if obj.respond_to?(:blank?)
-            full_message = build_message(message, "<?> should be blank.", obj)
-          else
-            full_message = build_message(message, "<?> does not respond to :blank? method.", obj)
-          end 
+        def assert_responds_to_blank( obj, message = nil )
+          msg = message(msg){
+            "<#{mu_pp(obj)}> does not respond to :blank? or :fwf_blank? methods."
+          }
           
-          safe_assert_block full_message do
-            obj.respond_to?(:blank?) && obj.blank?
-          end
+          assert obj.respond_to?(:blank?) || obj.respond_to?( :fwf_blank? ), msg
         end
-
-        def assert_matches( string, regexp_or_string, message = "")
-          full_message = build_message(message, "<?> should match regex <?>", string, regexp_or_string)
-          safe_assert_block full_message do
-            if regexp_or_string.is_a?(Regexp)
-              string.match(regexp_or_string) ? true : false
-            elsif regexp_or_string.is_a?(String)
-              string.include?(regexp_or_string)
-            end
-          end
+        
+        def assert_blank( obj, msg = nil )
+          assert_responds_to_blank( obj )
+          
+          msg = message(msg) { "#{mu_pp(obj)} should be blank." }
+          
+          assert( (obj.respond_to?(:blank?) && obj.blank?) || (obj.respond_to?(:fwf_blank?) && obj.fwf_blank?), msg )
         end
 
-        def assert_doesnt_match( string, regexp, message = "")
-          full_message = build_message(message, "<?> should not match regex <?>", string, regexp)
-          safe_assert_block full_message do
-            string.match(regexp) ? false : true
+        def assert_matches( string, regexp_or_string, msg = nil)
+          msg = message(msg) { "<#{mu_pp(string)}> should match regex <#{mu_pp(regexp_or_string)}>" }
+        
+          if regexp_or_string.is_a?(Regexp)
+            assert string.match(regexp_or_string), msg
+          elsif regexp_or_string.is_a?(String)
+            assert string.include?(regexp_or_string), msg
+          else
+            raise ArgumentError.new( "assert_matches takes a regular expression or string as second argument, not #{regexp_or_string}(#{regexp_or_string.class})")
           end
+          
+          true   
         end
 
-
-        # check that the given variables were assigned non-nil values
-        # by the controller
-
-        # If successful, returns an array of assigned objects.
-        # You can do:
-        # account, phone_number = assert_assigns(:account, :phone_number)
-        # or
-        # order = assert_assigns(:order)
-        def assert_assigns(*args)
-          symbols_assigned = []
-          symbols_not_assigned = []
-
-          for sym in args
-            ((assigns(sym) != nil)? symbols_assigned : symbols_not_assigned) << sym
-          end
-
-          message = build_message("", "The following variables should have been assigned values by the controller: <?>", symbols_not_assigned.map{|s| "@#{s.to_s}"}.join(", "))
-
-          safe_assert_block message do
-            symbols_not_assigned.length == 0
-          end
-
-          if symbols_assigned.length == 1
-            assigns(symbols_assigned.first)
+        def assert_doesnt_match( string, regexp_or_string, msg = nil)
+          msg = message(msg) { "<#{mu_pp(string)}> should NOT match string/regex <#{mu_pp(regexp_or_string)}>" }
+          
+          if regexp_or_string.is_a?(Regexp)
+            assert_nil string.match(regexp_or_string), msg
+          elsif regexp_or_string.is_a?(String)
+            refute string.include?(regexp_or_string), msg
           else
-            symbols_assigned.map{|s| assigns(s)}
+            raise ArgumentError.new( "assert_doesnt_match takes a regular expression or string as second argument, not #{regexp_or_string}(#{regexp_or_string.class})")
           end
+          
+          true
         end
+        
+        alias :refute_matches :assert_doesnt_match
 
-        # Ick
-        # read as "assert greater than 5, <test_value>"
-        def assert_greater_than( reference_value, amount, message = "" )
-          message = build_message("", "second argument <?> should be greater than reference value <?>", amount, reference_value)
+        
+        def assert_greater_than( reference_value, amount, msg = nil )
+          msg = message(msg){
+            "second argument <#{mu_pp(amount)}> should be greater than reference value <#{mu_pp(reference_value)}>"
+          }
 
-          safe_assert_block message do
-            amount > reference_value
-          end
+          assert amount > reference_value, msg
         end
 
         # read as "assert less than 5, <test value>"
-        def assert_less_than( reference_value, amount, message = "" )
-          message = build_message("", "second argument <?> should be less than reference value <?>", amount, reference_value)
+        def assert_less_than( reference_value, amount, msg = nil )
+          msg = message(msg){ 
+            "second argument <#{mu_pp(amount)} should be less than reference value <#{mu_pp(reference_value)}>" 
+          }
 
-          safe_assert_block message do
-            amount < reference_value
-          end
+          assert amount < reference_value, msg
         end
 
-        # I think "assert_delta_in_range" already does this
-        def assert_times_are_close( t1, t2, window = 1, message = "")
-          message = build_message(message, "times should be within ? second of each other.", window)
-
-          safe_assert_block message do
-            (t1 - t2).abs < window
-          end
+        def assert_at_least( reference_value, amount, msg = nil )
+          msg = message(msg) { "Value must be at least #{reference_value}. #{mu_pp(amount)} is too small." }
+          
+          assert( amount >= reference_value, msg )
+        end
+        
+        def assert_at_most( reference_value, amount, msg = nil )
+          msg = message(msg) { "Value can be at most #{reference_value}. #{mu_pp(amount)} is too large." }
+          
+          assert( amount <= reference_value, msg )
+        end
+        
+        # I think "assert_delta_in_range" already does this for floats
+        def assert_times_are_close( t1, t2, window = 1, msg = nil)
+          msg = message(msg) { "times should be within #{mu_pp(window)} second of each other." }
+          assert (t1 - t2).abs <= window
         end
 
-        def assert_equal_length( expected, actual, message = "" )
-          message = build_message( message, "items should be of equal length: expected: <?>, actual: <?>", expected.length, actual.length )
+        def assert_equal_length( expected, actual, msg = nil )
+          assert_respond_to expected, :length, message(nil){ "#{mu_pp(expected)} (expected value) doesn't respond to length()." }
+          assert_respond_to actual, :length, message(nil){ "#{mu_pp(actual)} (actual value) doesn't respond to length()." }
+          
+          msg = message(msg){ 
+            "items should be of equal length: expected length: <#{mu_pp(expected.length)}>, actual length: <#{mu_pp(actual.length)}>"
+          }
+          
+          assert_equal expected.length, actual.length, msg
+        end
+        
+        def assert_unequal_length( expected, actual, msg = nil )
+          msg = message(msg){ 
+            "items should be of equal length: expected: <#{mu_pp(expected.length)}>, actual: <#{mu_pp(actual.length)}>"
+          }
+          
+          assert_respond_to expected, :length, message(nil){ "#{mu_pp(expected)} (expected value) doesn't respond to length()." }
+          assert_respond_to actual, :length, message(nil){ "#{mu_pp(actual)} (actual value) doesn't respond to length()." }
+          
+          assert_equal expected.length, actual.length, message
+        end
+        
+        alias :refute_equal_length :assert_unequal_length
+        
+        
+        # `expected` can be a numeric range 
+        def assert_length( expected, actual, msg = nil )
           
-          safe_assert_block message do
-            expected.length == actual.length
+          no_response_msg = message(nil){ "<#{mu_pp(actual)}> doesn't respond to .length()" }
+          
+          assert_respond_to actual, :length, no_response_msg
+          
+          case expected
+          when Range
+            msg = message(msg){ 
+              "<#{mu_pp(actual)}> has a length of #{mu_pp(actual.length)}. Length must be between <#{mu_pp(expected.min)}> and <#{mu_pp(expected.max)}>"
+            }
+            
+            assert_at_least expected.min, actual.length, msg
+            assert_at_most  expected.max, actual.length, msg
+          when Integer
+            msg = message(msg){ "<#{mu_pp(actual)}> has a length of <#{mu_pp(actual.length)}>. Expected length was <#{mu_pp(expected)}>" }
+            assert_equal( expected, actual.length, msg )
+          else
+            flunk( "Bad reference value (first argument: #{expected.inspect}) to assert_length" )
           end
         end
+        
+        # Tries the given methods on both objects, reports on differing results
+        # Doesn't take a custom message.  Methods given must take zero arguments.
+        def assert_equality_of_methods( expected, actual, *methods )
+          failed = false
+          
+          results_msg = {}
+          results_msg[:expected] = "The following methods were not equal: \nExpected: #{mu_pp(expected)}"
+          results_msg[:actual]   = "\n--------------------\nActual: #{mu_pp(actual)}"
+          
           
-        def assert_equality_of_methods(*args)
-          expected = args[0]
-          actual = args[1]
-          methods = args[2..-1].flatten
-          message = "The following methods were not equal: "
-
-          unequal = []
-
           for method in methods
-            exp = expected.send(method.to_sym)
-            act = actual.send(method.to_sym)
-            unless exp == act
-              unequal << method
-              message += "\n\t#{method} (#{exp.inspect},#{act.inspect})"
+            no_error_on_method = true
+            responses = {}
+            
+            for obj, response_sym in [[expected, :expected], [actual, :actual]]
+              responses[response_sym] = begin
+                                          obj.send( method )
+                                        rescue StandardError => e
+                                          e
+                                        end
+                                        
+              if responses[response_sym].is_a?( StandardError )
+                failed = true
+                no_error_on_method = false
+                results_msg[response_sym] << "\n\t#{method}(): ERROR: #{responses[response_sym].class} #{responses[response_sym].message}"
+              end
+            end
+            
+            if responses[:expected] != responses[:actual] && no_error_on_method
+              failed = true
+              
+              for response_sym in [:expected, :actual]
+                results_msg[response_sym] << "\n\t#{method}(): #{responses[response_sym].inspect}"
+              end
             end
           end
-
-          safe_assert_block message do
-            unequal.blank?
-          end
+            
+          
+          assert !failed, results_msg[:expected] + results_msg[:actual]
+        end
+        
+        def assert_has_instance_method( object, instance_method, msg = nil )
+          msg = message(msg){ "object #{mu_pp(object)} should respond to #{instance_method.inspect}" }
+          assert object.instance_methods.include?( instance_method ), msg
         end
         
-        def assert_has_instance_method( object, instance_method, message = "object #{object} should respond to #{instance_method.inspect}" )
-          safe_assert_block( message ) do
-            object.instance_methods.include?( instance_method )
+        def assert_nothing_raised( msg = nil, &block )
+          begin 
+            yield if block_given?
+            assert true
+          rescue Exception => e
+            msg = message(msg){ "block should not raise a #{mu_pp(e.class)} (message: #{e.message})"}
+            assert false, msg
           end
         end
         
-        def assert_nothing_raised( message = "", &block )
-          safe_assert_block( message ) do
-            result = true
-            result
+        def assert_constant_defined( const, msg = nil )
+          begin
+            Object.const_get( const )
+            assert true
+          rescue NameError
+            assert false, message(msg){ "expected constant is not defined: #{const}" }
           end
         end
+        
+        # Which order makes more sense for the arguments
+        # Assert that the first argument includes the module specified in the second argument
+        def assert_includes_module( mod_or_class, mod, msg = nil )
+          # Make sure we've been passed the proper sort of objects
+          assert mod_or_class.respond_to?( :included_modules, "#{mod_or_class} doesn't respond to included_modules()" )
+          raise ArgumentError.new( "#{mod} is not a module" ) unless mod.kind_of?( Module )
+
+          msg = message(msg){ "#{mod_or_class} should have included module #{mod}" }
+          
+          assert mod_or_class.included_modules.include?(mod), msg
+        end
       end
     end
   end

data/lib/fun_with/testing/assertions_test_case.rb

@@ -0,0 +1,67 @@
+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
+      def self.fwt_install_mock_safe_assert_block
+        include AssertionTestMocker
+      end
+      
+      # After @case_class is created, you can include the methods you want to test
+      # 
+      def extended_test_case( &block )
+        @case_class = Class.new( FunWith::Testing::AssertionsTestCase )
+        
+        # Unhook from some of the test harness stuff to
+        # make it possible to run the assertion methods 
+        # without causing the test suite to topple over.
+        @case_class.fwt_install_mock_safe_assert_block
+        
+        @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/assertions_test_mocker.rb

@@ -0,0 +1,15 @@
+module FunWith
+  module Testing
+    module AssertionTestMocker
+      # 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
+    end
+  end
+end

data/lib/fun_with/testing/test_case.rb

@@ -1,77 +1,7 @@
 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?
-      end
-      
-      def self.set_verbose( mode = true )
-        self.const_set( :FWT_TEST_VERBOSITY, mode )
-      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?
-      end
-      
-      # Convenience methods for disappearing a set of tests.  Useful for focusing on one or two tests.  
-      def self._context(*args, &block)
-        puts "<<< WARNING >>> IGNORING TEST SET #{args.inspect}. Remove leading _ from '_context()' to reactivate."
-      end
-
-      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
+      extend TestCaseExtensions
     end
   end
 end

data/lib/fun_with/testing/test_case_extensions.rb

@@ -0,0 +1,47 @@
+module FunWith
+  module Testing
+    module TestCaseExtensions
+      def install_verbosity
+        include VerbosityMethods
+      end
+
+      def install_test_mode
+        include TestModeMethods
+      end
+      
+      def install_basic_assertions
+        include Assertions::Basics
+      end
+      
+      # assumes the gem has a test/factories folder, just requir's everything
+      # from that directory.  
+      def add_factorybot_support
+        unless defined?( FactoryBot )
+          begin
+            require 'factory_bot'
+          rescue LoadError
+            puts "Error: FactoryBot support requested, but FactoryBot could not be loaded.  make sure the factory_bot gem is listed in your Gemfile, then run `bundle install`."
+          end
+        end
+        
+        FactoryBot.find_definitions if defined?( FactoryBot )   # loads factories, test/factories, and spec/factories if they exist (directory or .rb file) 
+      end
+
+      # Convenience methods for disappearing a set of tests.  Useful for focusing on one or two tests.  
+      def _context(*args, &block)
+        puts "<<< WARNING >>> IGNORING TEST SET #{args.inspect}. Remove leading _ from '_context()' to reactivate."
+      end
+
+      def _should(*args, &block)
+        puts "<<< WARNING >>> IGNORING TEST #{args.inspect}. Remove leading _ from '_should()' to reactivate."
+      end
+      
+      def _test(*args, &block)
+        puts "<<< WARNING >>> IGNORING TEST #{args.inspect}. Remove leading _ from '_test()' to reactivate."
+      end
+      # def build_message( *args )
+      #   args.map(&:inspect).join("  ")
+      # end
+    end
+  end
+end