assert_same 0.3 → 0.5

data/README

@@ -1,10 +1,101 @@
 assert_same
 ===========
 
-Please read the API docs in lib/assert_same.rb
+Checks that two strings are same and "magically" replace expected value 
+with the actual in case the new behavior (and new actual value) is correct.
+Support two kind of arguments: string and code block.
+
+String Example:
+---------------
+
+It is better to start with no expected value
+
+    assert_same "foo"
+
+Then run tests as usual with "rake test". As a result you will see
+diff between expected and actual values:
+
+    Failure:
+    @@ -1,0, +1,1 @@
+    +foo
+    Accept the new value: yes to all, no to all, yes, no? [Y/N/y/n] (y):
+
+If you accept the new value your test will be automatically modified to
+
+    assert_same "foo", <<-END
+        foo
+    END
+
+Block Example:
+--------------
+
+assert_same supports code block as argument. If executed block raise exception
+exception message is returned as actual value:
+
+    assert_same do
+        nil+1
+    end
+
+Run tests
+
+    Failure:
+    @@ -1,0, +1,1 @@
+    +Exception NoMethodError: undefined method `+' for nil:NilClass
+    Accept the new value: yes to all, no to all, yes, no? [Y/N/y/n] (y): 
+
+After new value is accepted
+
+    assert_same(<<-END) do
+        Exception NoMethodError: undefined method `+' for nil:NilClass
+    END
+        nil + 1
+    end
+
+Options:
+--------
+
+    --no-interactive skips all questions and just reports failures
+    --autoaccept prints diffs and automatically accepts all new actual values
+    --no-canonicalize turns off expected and actual value canonicalization (see below for details)
+
+Additional options can be passed during both single test file run and rake test run:
+
+In Ruby 1.8:
+
+    ruby test/unit/foo_test.rb -- --autoaccept
+    rake test TESTOPTS="-- --autoaccept"
+
+In Ruby 1.9:
+
+    ruby test/unit/foo_test.rb --autoaccept
+    rake test TESTOPTS="--autoaccept"
+
+Canonicalization:
+-----------------
+
+Before comparing expected and actual strings, assert_same canonicalizes both using these rules:
+
+- indentation is ignored (except for indentation  relative to the first line of the expected/actual string)
+- ruby-style comments after "#" are ignored
+- empty lines are ignored
+- trailing whitespaces are ignored
+
+You can turn canonicalization off with --no-canonicalize option. This is useful
+when you need to regenerate expected test strings.
+To regenerate the whole test suite, run:
+
+In Ruby 1.8:
+
+    rake test TESTOPTS="-- --no-canonicalize --autoaccept"
+
+In Ruby 1.9:
+
+    rake test TESTOPTS="--no-canonicalize --autoaccept"
 
 
 Changelog
+---------
+- 0.4: Added support for code blocks as argument
 - 0.3: Ruby 1.9 is supported
 - 0.2: Make assert_same useful as a standalone gem. Bugfixes
 - 0.1: Initial release

data/assert_same.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 SPEC = Gem::Specification.new do |s|
     s.name        = "assert_same"
-    s.version     = "0.3"
+    s.version     = "0.5"
     s.author      = "Pluron, Inc."
     s.email       = "support@pluron.com"
     s.homepage    = "http://github.com/acunote/assert_same"

data/lib/assert_same.rb

@@ -49,6 +49,15 @@ else
 end
 
 
+#Use this to raise internal error with a given message
+#You can define your own method for your application
+unless defined? internal_error
+    def internal_error(message = 'internal error')
+        raise message
+    end
+end
+
+
 module Test::Unit::Assertions
 
     #Hash[filename][line_number] = offset
@@ -68,6 +77,14 @@ module Test::Unit::Assertions
     #         bar
     #         zee
     #     END
+    #
+    # You can also use assert_same for blocks. Then you can assert block result or raised exception
+    #    assert_same(<<-END) do
+    #        Exception NoMethodError: undefined method `+' for nil:NilClass
+    #    END
+    #        # Code block starts here
+    #        c = nil + 1
+    #    end
     # 
     # Then run tests as usual:
     #    rake test:units
@@ -150,16 +167,29 @@ module Test::Unit::Assertions
     #       assert_same something
     #   in fact, this is the preferred way to create assert_same tests - you write empty
     #   assert_same, run tests and they will fill expected values for you automatically
-    def assert_same(actual, expected = :autofill_expected_value)
-        if expected.class == String
-            expected ||= ""
-            mode = :expecting_string
-        elsif expected == :autofill_expected_value
+    def assert_same(*args)
+        if block_given?
+            mode = :block
+            expected = args[0]
+            actual = ""
+            begin
+                actual = yield.to_s
+            rescue Exception => e
+                actual = "Exception #{e.class}: #{e.message}"
+            end
+        else
+            mode = :scalar
+            expected = args[1]
+            actual = args[0]
+        end
+
+        if expected.nil?
             expected = ""
-            mode = :autofill_expected_value
+            change = :create_expected_string
+        elsif expected.class == String
+            change = :update_expected_string
         elsif expected.class == Hash
             raise ":log key is missing" unless expected.has_key? :log
-            mode = :expecting_file
             log_file = expected[:log]
             if defined? RAILS_ROOT
                 log_file = File.expand_path(log_file, RAILS_ROOT)
@@ -167,8 +197,9 @@ module Test::Unit::Assertions
                 log_file = File.expand_path(log_file, Dir.pwd)
             end
             expected = File.exists?(log_file) ? File.read(log_file) : ""
+            change = :update_file_with_expected_string
         else
-            internal_error("Incorrect expected argument for assert_same. It must be either String or Hash.")
+            internal_error("Invalid expected class #{excepted.class}")
         end
 
         # interactive mode is turned on by default, except when
@@ -198,10 +229,12 @@ module Test::Unit::Assertions
                 end
 
                 if accept
-                    if [:expecting_string, :autofill_expected_value].include? mode
-                        accept_string(actual, mode)
-                    elsif mode == :expecting_file
+                    if [:create_expected_string, :update_expected_string].include? change
+                        accept_string(actual, change, mode)
+                    elsif change == :update_file_with_expected_string
                         accept_file(actual, log_file)
+                    else
+                        internal_error("Invalid change #{change}")
                     end
                 end
             end
@@ -246,7 +279,10 @@ private
         end
     end
 
-    def accept_string(actual, mode)
+    # actual - actual value of the scalar or result of the executed block
+    # change - what to do with expected value (:create_expected_string or :update_expected_string)
+    # mode   - describes signature of assert_same call by type of main argument (:block or :scalar)
+    def accept_string(actual, change, mode)
         file, method, line = get_caller_location(:depth => 3)
 
         # read source file, construct the new source, replacing everything
@@ -262,11 +298,13 @@ private
         end
 
         expected_text_end_line = expected_text_start_line = line.to_i + offset
-        unless mode == :autofill_expected_value
-            #if we're autofilling the value, END/EOS marker will not exist
-            #(second arg to assert_same is omitted)
-            #else we search for it
+        if change == :update_expected_string
+            #search for the end of expected value in code
             expected_text_end_line += 1 while !["END", "EOS"].include?(source[expected_text_end_line].strip)
+        elsif change == :create_expected_string
+            # The is no expected value yet. expected_text_end_line is unknown
+        else
+            internal_error("Invalid change #{change}")
         end
 
         expected_length = expected_text_end_line - expected_text_start_line
@@ -275,18 +313,25 @@ private
         indentation = source[expected_text_start_line-1] =~ /^(\s+)/ ? $1.length : 0
         indentation += 4
 
-        if mode == :autofill_expected_value
-            # add second argument to assert_same if it's omitted
-            source[expected_text_start_line-1] = "#{source[expected_text_start_line-1].chop}, <<-END\n"
+        if change == :create_expected_string 
+            if mode == :scalar
+                # add second argument to assert_same if it's omitted
+                source[expected_text_start_line-1] = "#{source[expected_text_start_line-1].chop}, <<-END\n"
+            elsif mode == :block
+                # add expected value as argument to assert_same before block call
+                source[expected_text_start_line-1] = source[expected_text_start_line-1].sub(/assert_same(\(.*?\))*/, "assert_same(<<-END)")
+            else
+                internal_error("Invalid mode #{mode}")
+            end
         end
         source = source[0, expected_text_start_line] +
             actual.split("\n").map { |l| "#{" "*(indentation)}#{l}\n"} +
-            (mode == :autofill_expected_value ? ["#{" "*(indentation-4)}END\n"] : [])+
+            (change == :create_expected_string ? ["#{" "*(indentation-4)}END\n"] : [])+
             source[expected_text_end_line, source.length]
 
         # recalculate line number adjustments
         actual_length = actual.split("\n").length
-        actual_length += 1 if mode == :autofill_expected_value  # END marker after actual value
+        actual_length += 1 if change == :create_expected_string # END marker after expected value
         @@file_offsets[file][line.to_i] = actual_length - expected_length
 
         source_file = File.open(file, "w+")

data/test/assert_same_test.rb

@@ -15,4 +15,73 @@ class AssertSameTest < Test::Unit::TestCase
         assert_same "foo", :log => 'test/logs/assert_same_with_files.log.ref'
     end
 
+    def test_assert_same_empty_string
+        # These two calls are the same
+        assert_same ""
+        assert_same "", <<-END
+        END
+    end
+
+    def test_assert_same_exception
+        assert_same(<<-END) do
+            Exception NoMethodError: undefined method `+' for nil:NilClass
+        END
+            nil + 1
+        end
+    end
+
+    def test_assert_same_for_block_value
+        assert_same(<<-END) do
+            All Ok!
+        END
+            a = "All Ok!"
+        end
+    end
+
+    def test_assert_same_exception_with_files
+        assert_same(:log => 'test/logs/assert_same_exception_with_files.log.ref') do
+            nil + 1
+        end
+    end
+
+    def test_assert_same_block_alternative_syntax
+        assert_same(<<-END) {
+            Exception NoMethodError: undefined method `+' for nil:NilClass
+        END
+            nil + 1
+        }
+    end
+
+    def test_assert_same_block_alternative_syntax_one_liner
+        assert_same(<<-END) { nil + 1 }
+            Exception NoMethodError: undefined method `+' for nil:NilClass
+        END
+    end
+
+    def test_assert_same_for_empty_block
+        # These calls are the same
+        assert_same { }
+
+        assert_same do end
+
+        assert_same(<<-END) { }
+        END
+
+        assert_same(<<-END) do end
+        END
+    end
+
+    def test_assert_same_for_nil_block_result
+        # These calls are the same
+        assert_same { nil }
+
+        assert_same do nil end
+
+        assert_same(<<-END) { nil }
+        END
+
+        assert_same(<<-END) do nil end
+        END
+    end
+
 end

data/test/logs/assert_same_exception_with_files.log.ref

@@ -0,0 +1 @@
+Exception NoMethodError: undefined method `+' for nil:NilClass

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: assert_same
 version: !ruby/object:Gem::Version
-  version: '0.3'
+  version: '0.5'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-14 00:00:00.000000000 Z
+date: 2013-08-07 00:00:00.000000000 Z
 dependencies: []
 description: assert_same assertion
 email: support@pluron.com
@@ -28,6 +28,7 @@ files:
 - lib/assert_same.rb
 - lib/text_diff.rb
 - test/assert_same_test.rb
+- test/logs/assert_same_exception_with_files.log.ref
 - test/logs/assert_same_with_files.log.ref
 homepage: http://github.com/acunote/assert_same
 licenses: []
@@ -57,4 +58,6 @@ summary: Assert which checks that two strings (expected and actual) are same and
   new actual value) is correct
 test_files:
 - test/assert_same_test.rb
+- test/logs/assert_same_exception_with_files.log.ref
 - test/logs/assert_same_with_files.log.ref
+has_rdoc: true