fun_with_testing 0.0.4 → 0.0.7

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ODI5NWNmNjZkYzVmMTJhMTU0NjY0M2IxOGU5ZTJlMjE2OTQxODkyYQ==
-  data.tar.gz: !binary |-
-    MmI0Nzg3YzUzYmRjMGE5MzUzN2ZkNmVhODMyZWJmOTM2ZGJjYmI0Mw==
+SHA1:
+  metadata.gz: eb64dd009618bda745cdfab2c2aec0a6b211bb8b
+  data.tar.gz: 9bd5755ded13b000d9d8f0eb456cd991f9c09eba
 SHA512:
-  metadata.gz: !binary |-
-    NTAyMzUwYTMyOWI0MDQzY2E1OTM4NWE1ZTFlOGYxOTA4NzY3NGIzYmRmNTMw
-    ZGQ5ODJhMzc0NTZiYjZhNTI1NGExYzk4NDJjODkwZjQ3M2QzYzFlNDRiYTBh
-    NjM0YTA5NzVmMDE5YTc3ZGQ3YmQ0ZGJhMTQyMGIwM2QxY2FlNGE=
-  data.tar.gz: !binary |-
-    MzIyZDJiMWIxNmU3MWM5NjM4Njk5NmEyYTJkOTVlZDYyMjU2NWM4Y2NhM2Nk
-    OWZkYTRkZjA0NGM0YzQ3MWEyMTI5NTExYzMzMGYzZTNhODc1NDkxYTIyZjk5
-    NmI1MTA3YjczNDJlZjAwNDc3YzBiYzg4MDVjMmFlODlkYTNkZGQ=
+  metadata.gz: d0cfca949bcf3c2c20f4b60bd406ac6b7fc50697c8ecf059190d5840b5e0a499c1398cc3cec78e16aa32c5a747202ba28adaa4a410d9099350fd7440c3978cb9
+  data.tar.gz: b8c7fc8602da5dfd3632134384beb29243bd873dc65af3b2662a2bb798b1159fae691ea7259236cf70095b9c2dd44219c9cebc78d7ba7b7a55938d364ee427ba

data/CHANGELOG.markdown

@@ -1,6 +1,33 @@
 CHANGELOG
 =========
 
+v0.0.?+
+------
+
+
+v0.0.8
+-------
+
+* Moving TestMode and Verbosity stuff into FunWith::Gems?  Can be used to install "test mode" and "verbosity" on any object/module/class?
+
+v0.0.7  (current)
+-----------------
+
+* Moving everything related to FunWith::Files into that gem.
+* Removing ActiveRecord stuff in preparation for Glorious FunWith::Rails Future!
+
+v0.0.6
+------
+
+* Adding meat to the testing section
+* (Temporarily?) dropping the illusion of Ruby < 2.0 support
+
+
+v0.0.5
+------
+
+?????  - not inspiring confidence here
+
 v0.0.4
 ------
 

data/Gemfile

@@ -1,4 +1,5 @@
 source "http://rubygems.org"
+
 # Add dependencies required to use your gem here.
 # Example:
 #   gem "activesupport", ">= 2.3.5"
@@ -9,17 +10,27 @@ group :development do
   # gem "shoulda", "~> 3", ">= 3.5"
   # gem "rdoc", "~> 3.12"
   # gem "bundler", "~> 1.0"
-  # gem "jeweler", "~> 2.0"
-  # # gem "rcov", ">= 0"
+  # gem "rcov", ">= 0"
   # gem 'debugger', "~> 1.6"
   # gem 'minitest'
+  # gem "fun_with_testing", "~> 0.0", ">= 0.0.4"
+end
+
+# Bundler keeps trying to install rack 2,
+# failing because it requires Ruby 2.2 or higher
+
+ruby_major, ruby_minor, ruby_patch = RUBY_VERSION.split(".").map(&:to_i)
+
+if ruby_major < 2 || ruby_minor < 2 || ruby_minor == 2 && ruby_patch <= 1
+  gem "rack", "~> 1"
+else
+  gem "rack", "~> 2"
 end
 
-gem "shoulda", "~> 3", ">= 3.5"
-gem "rdoc", "~> 3.12"
-gem "bundler", "~> 1.0"
-gem "jeweler", "~> 2.0"
-# gem "rcov", ">= 0"
-gem "simplecov", "~> 0", ">= 0.8"
-gem 'debugger', "~> 1.6"
-gem 'minitest', "~> 5"
+gem "shoulda",   "~> 3", ">= 3.5"
+gem "rdoc",      "~> 4", ">= 4.2.2"
+gem "bundler",   "~> 1", ">= 1.10"
+gem "juwelier",  "~> 2", ">= 2.1"
+gem "simplecov", "~> 0", ">= 0.11"
+gem 'byebug',    "~> 9", ">= 9.0"
+gem 'minitest',  "~> 5", ">= 5.9"

data/Rakefile

@@ -11,24 +11,32 @@ rescue Bundler::BundlerError => e
 end
 require 'rake'
 
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
+require 'juwelier'
+Juwelier::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
   gem.name = "fun_with_testing"
+  
+  # TODO: Not holding up rake-install, as best I can tell.  Delete line?
+  # gem.version = (File.exist?('VERSION') ? File.read('VERSION') : "0.0.0")
+  
+  
   gem.homepage = "http://github.com/darthschmoo/fun_with_testing"
-  gem.license = "MIT"
+  gem.licenses = ["MIT"]
   gem.summary = "A place to stash Test::Unit assertions I've found handy."
   gem.description = "A place to stash Test::Unit assertions I've found handy. Use at your own risk"
   gem.email = "keeputahweird@gmail.com"
   gem.authors = ["Bryce Anderson"]
   
-  gem.files = Dir.glob( File.join( ".", "lib", "**", "*.rb" ) ) + 
+  # Tried getting rid of this to see if it was blocking rake-install.
+  # No surch lurx.
+  gem.files = Dir.glob( File.join( ".", "lib", "**", "*.rb" ) ) +
               Dir.glob( File.join( ".", "test", "**", "*" ) ) +
               %w( Gemfile Rakefile LICENSE.txt README.rdoc VERSION CHANGELOG.markdown )
-  
+
   # dependencies defined in Gemfile
 end
-Jeweler::RubygemsDotOrgTasks.new
+
+Juwelier::RubygemsDotOrgTasks.new
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
@@ -45,6 +53,14 @@ end
 #   test.rcov_opts << '--exclude "gems/*"'
 # end
 
+# Adding this to see if it's making any difference
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['test'].execute
+end
+
+
 task :default => :test
 
 require 'rdoc/task'

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.7

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

@@ -2,197 +2,274 @@ module FunWith
   module Testing
     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 )
+          
+          no_response_msg = message(nil){ "<#{mu_pp(actual)}> doesn't respond to .length()" }
           
-          safe_assert_block message do
-            expected.length == actual.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, message = "object #{object} should respond to #{instance_method.inspect}" )
-          safe_assert_block( message ) do
-            object.instance_methods.include?( instance_method )
-          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_nothing_raised( message = "", &block )
-          safe_assert_block( message ) do
-            result = true
-            result
+        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
       end