wrong 0.3.3 → 0.4.0

data/test/d_test.rb

@@ -0,0 +1,64 @@
+require "./test/test_helper"
+require "wrong"
+require "wrong/d"
+require "wrong/adapters/minitest"
+
+describe "d" do
+  include Wrong::D
+
+  it "prints its argument's name and its value" do
+    x = 5
+    output = capturing do
+      d { x }
+    end
+    assert { output == "x is 5\n" }
+  end
+
+  it "inspects the value" do
+    x = "one\ttwo"
+    output = capturing do
+      d { x }
+    end
+    assert { output == "x is \"one\\ttwo\"\n" }
+  end
+
+  it "works on an expression" do
+    x = 5
+    output = capturing do
+      d { x + 2 }
+    end
+    assert { output == "(x + 2) is 7\n" }
+  end
+
+  it "works even if it's not the only thing on the line" do
+    x = 8
+    output = capturing do
+      x; d { x }
+    end
+    assert { output == "x is 8\n" }
+  end
+
+  it "works even if it's nested in another block on the same line" do
+    x = 8
+    output = capturing do
+      assert { d { x }; true }
+    end
+    assert { output == "x is 8\n" }
+  end
+
+  it "works when called on an extending module" do
+    module Something
+      extend Wrong::D
+    end
+    x = 99
+    output = capturing { Something.d { x }}
+    assert { output == "x is 99\n" }
+  end
+
+  it "works when called on the D module" do
+    x = 9
+    output = capturing { Wrong::D.d { x }}
+    assert { output == "x is 9\n" }
+  end
+
+end

data/test/failure_message_test.rb

@@ -0,0 +1,40 @@
+require "./test/test_helper"
+require "wrong/assert"
+require "wrong/failure_message"
+
+module Wrong
+
+  class BogusFormatter < FailureMessage::Formatter
+    def match?
+      predicate.is_a? BogusPredicate
+    end
+
+    def describe
+      "bogus #{predicate.object_id}"
+    end
+  end
+
+  class BogusPredicate < Predicated::Predicate
+  end
+
+  describe FailureMessage::Formatter do
+    include Wrong::Assert
+
+    it "describes a predicate" do
+      predicate = BogusPredicate.new
+      formatter = BogusFormatter.new(predicate)
+      assert { formatter.describe == "bogus #{predicate.object_id}" }
+    end
+  end
+
+  describe FailureMessage do
+    include Wrong::Assert
+
+    it "can register a formatter class for a predicate pattern" do
+      FailureMessage.register_formatter(BogusFormatter)
+      assert { FailureMessage.formatter_for(BogusPredicate.new).is_a? BogusFormatter }
+      assert { FailureMessage.formatters.include?(BogusFormatter)}
+    end
+
+  end
+end

data/test/failures_test.rb

@@ -14,7 +14,6 @@ describe "failures" do
 
     it "raw boolean assert failure" do
       error = get_error { @m.assert { false } }
-#      puts error.message
       assert_match "false", error.message
     end
 
@@ -22,7 +21,6 @@ describe "failures" do
       error = get_error {
         @m.deny { true }
       }
-#      puts error.message
       assert_match "true", error.message
     end
 
@@ -74,7 +72,7 @@ describe "failures" do
       assert_match("1 is not equal to 2", get_error {
         @m.assert {
           1==
-            2
+                  2
         }
       }.message)
     end
@@ -97,7 +95,7 @@ describe "failures" do
     it "omit a primary failure message since 'This is not true etc.' is more obscuring than clarifying" do
       m = get_error {
         x = 5
-        @m.assert { x == 5 && x != 5}
+        @m.assert { x == 5 && x != 5 }
       }.message
       assert m == "Expected ((x == 5) and (not (x == 5))), but \n    (x == 5) is true\n    x is 5\n    (not (x == 5)) is false\n"
     end
@@ -137,10 +135,11 @@ describe "failures" do
 
   describe "hash comparisons" do
     it "basic" do
+      e = get_error {
+        @m.assert { {1=>2}=={"a"=>"b"} }
+      }
       assert_match '{1=>2} is not equal to {"a"=>"b"}',
-                   get_error {
-                     @m.assert { {1=>2}=={"a"=>"b"} }
-                   }.message
+                   e.message
     end
   end
 

data/test/message/array_diff_test.rb

@@ -1,15 +1,18 @@
 require "./test/test_helper"
 require "wrong/assert"
-require "wrong/message/array_diff"
+require "wrong/helpers"
 require "wrong/adapters/minitest"
 
+require "wrong/message/array_diff"
+
 describe "when you're comparing strings and they don't match, show me the diff message" do
 
   def assert_string_diff_message(first_array, second_array, expected_error_message)
+    e = rescuing {
+      Wrong.assert { first_array == second_array }
+    }
     assert {
-      rescuing {
-        assert { first_array == second_array }
-      }.message.include?(expected_error_message)
+      e.message.include?(expected_error_message.strip)
     }
   end
 
@@ -17,26 +20,27 @@ describe "when you're comparing strings and they don't match, show me the diff m
     deny {
       rescuing {
         assert { [1]==2 }
-      }.message.include?("diff")
+      }.message.include?("^")
     }
     deny {
       rescuing {
         assert { nil==[1] }
-      }.message.include?("diff")
+      }.message.include?("^")
     }
   end
 
   it "simple" do
+    e = rescuing {
+      assert { ["a"]==["b"] }
+    }
     assert {
-      rescuing {
-        assert { ["a"]==["b"] }
-      }.message.include?("diff")
+      e.message.include?("^")
     }
 
     assert_string_diff_message(["a", "b"], ["a", "c", "c"], %{
 ["a", "b"]
 ["a", "c", "c"]
-      ^    ^   
+      ^    ^
 })
   end
 
@@ -44,13 +48,13 @@ describe "when you're comparing strings and they don't match, show me the diff m
     assert_string_diff_message(["a", "b", "c"], ["a", "cccc", "c"], %{
 ["a", "b"   , "c"]
 ["a", "cccc", "c"]
-      ^           
+      ^
 })
 
     assert_string_diff_message(["a", "b", "c", "d"], ["a", "cccc", "xxx", "d"], %{
 ["a", "b"   , "c"  , "d"]
 ["a", "cccc", "xxx", "d"]
-      ^       ^          
+      ^       ^
 })
   end
 
@@ -58,7 +62,7 @@ describe "when you're comparing strings and they don't match, show me the diff m
     assert_string_diff_message([1, true], [2, true, nil], %{
 [1, true]
 [2, true, nil]
- ^        ^   
+ ^        ^
 })
   end
 
@@ -67,7 +71,7 @@ describe "when you're comparing strings and they don't match, show me the diff m
     assert_string_diff_message([1, [2]], [1, [2, 3]], %{
 [1, [2]   ]
 [1, [2, 3]]
-    ^      
+    ^
 })
 
   end

data/test/message/{test_context_text.rb → test_context_test.rb}

@@ -2,7 +2,7 @@ require "./test/test_helper"
 require "wrong/assert"
 require "wrong/message/test_context"
 
-describe "showing the lines just above where the failure occurs, so you have some context" do
+xdescribe "showing the lines just above where the failure occurs, so you have some context" do
 
   include Wrong::Assert
   
@@ -14,6 +14,7 @@ describe "showing the lines just above where the failure occurs, so you have som
     begin
       assert{ a == b }
     rescue Wrong::Assert::AssertionFailedError => e
+      puts e
       assert do
         e.message.include?(
 %{  it "you can see test method all the way back to the start of the test, plus an indication of where the failure was" do

data/test/rescuing_test.rb

@@ -1,15 +1,16 @@
 require "./test/test_helper"
-
-require "wrong/assert"
 require "wrong/adapters/minitest"
 
-describe "a tool for rescuing errors" do
+describe "a helper for rescuing errors" do
   
   class RedError < StandardError; end
   class BlueError < StandardError; end
   
-  it "catch the error and assert on it" do
+  it "returns the error that was raised" do
     assert{ rescuing{raise RedError.new}.is_a?(RedError) }
+  end
+
+  it "returns nil if nothing was raised" do
     assert{ rescuing{"x"}.nil? }
   end
   

data/test/separate.rb

@@ -0,0 +1,4 @@
+#simple (but slow) way to make sure requires are isolated
+result = Dir["test/**/*_test.rb"].collect{|test_file| system("bundle exec ruby #{test_file}") }.uniq == [true]
+puts "suite " + (result ? "passed" : "FAILED")
+exit(result ? 0 : 1)

data/test/sexp_ext_test.rb

@@ -2,10 +2,10 @@ require "./test/test_helper"
 require "wrong/sexp_ext"
 
 describe Sexp do
-  describe "#doop" do
+  describe "#deep_clone" do
     it "deeply duplicates the sexp" do
       original = RubyParser.new.parse("x == 5")
-      duplicate = original.doop
+      duplicate = original.deep_clone
       assert(original.object_id != duplicate.object_id)
       assert(original[1].object_id != duplicate[1].object_id)
       assert(original[1][3].object_id != duplicate[1][3].object_id)

data/test/string_comparison_test.rb

@@ -0,0 +1,159 @@
+require "./test/test_helper"
+require "wrong/adapters/minitest"
+require "wrong/message/string_comparison"
+
+module Wrong
+describe StringComparison do
+
+  before do
+    # crank the window and prelude down for these tests
+    @old_window = StringComparison.window
+    @old_prelude = StringComparison.prelude
+    StringComparison.window = 16
+    StringComparison.prelude = 8
+  end
+
+  after do
+    StringComparison.window = @old_window
+    StringComparison.prelude = @old_prelude
+  end
+
+  describe '#same?' do
+    it "says identical empty strings are the same" do
+      comparison = StringComparison.new("", "")
+      assert { comparison.same? }
+    end
+
+    it "says identical non-empty strings are the same" do
+      comparison = StringComparison.new("abc", "abc")
+      assert { comparison.same? }
+    end
+
+    it "says two nils are the same" do
+      comparison = StringComparison.new(nil, nil)
+      assert { comparison.same? }
+    end
+
+    it "says a string is different from a different string" do
+      comparison = StringComparison.new("abc", "xyz")
+      deny { comparison.same? }
+    end
+
+    it "says a string is different from nil" do
+      comparison = StringComparison.new("abc", nil)
+      deny { comparison.same? }
+    end
+
+    it "says nil is different from a string" do
+      comparison = StringComparison.new(nil, "abc")
+      deny { comparison.same? }
+    end
+  end
+
+  describe '#different_at' do
+    describe "returns the location where two strings differ" do
+
+      it "at the beginning of the strings" do
+        assert { StringComparison.new("abc", "xyz").different_at == 0 }
+      end
+
+      it "at the middle of the strings" do
+        assert { StringComparison.new("abc", "ayz").different_at == 1 }
+      end
+
+      it "when the first string is longer" do
+        assert { StringComparison.new("abcd", "abc").different_at == 3 }
+      end
+
+      it "when the second string is longer" do
+        assert { StringComparison.new("abc", "abcd").different_at == 3 }
+      end
+
+      it "with nil as the first string" do
+        assert { StringComparison.new(nil, "abc").different_at == 0 }
+      end
+
+      it "with nil as the second string" do
+        assert { StringComparison.new("abc", nil).different_at == 0 }
+      end
+
+    end
+  end
+
+  describe '#message' do
+    def compare(first, second, expected_message)
+      expected_message.strip!
+      assert { StringComparison.new(first, second).message == expected_message }
+    end
+
+    it 'shows the whole of both strings when the difference is near the start' do
+compare "abc", "xyz", <<-MESSAGE
+Strings differ at position 0:
+ first: "abc"
+second: "xyz"
+      MESSAGE
+    end
+
+    it 'shows ellipses when the difference is in the middle of a long string' do
+      compare "abcdefghijklmnopqrstuvwxyz", "abcdefghijkl*nopqrstuvwxyz", <<-MESSAGE
+Strings differ at position 12:
+ first: ..."efghijklmnopqrst"...
+second: ..."efghijkl*nopqrst"...
+      MESSAGE
+    end
+
+    it 'shows ellipses when the difference is near the beginning of a long string' do
+      compare "abcdefghijklmnopqrstuvwxyz", "a*cdefghijklmnopqrstuvwxyz", <<-MESSAGE
+Strings differ at position 1:
+ first: "abcdefghijklmnop"...
+second: "a*cdefghijklmnop"...
+      MESSAGE
+    end
+
+    it 'shows ellipses when the difference is near the end of a long string' do
+      compare "abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvw*yz", <<-MESSAGE
+Strings differ at position 23:
+ first: ..."pqrstuvwxyz"
+second: ..."pqrstuvw*yz"
+      MESSAGE
+    end
+
+    it 'allows user to override the default window size' do
+      original = StringComparison.window
+      begin
+        StringComparison.window = 10
+        compare "abcdefghijklmnopqrstuvwxyz", "a*cdefghijklmnopqrstuvwxyz", <<-MESSAGE
+Strings differ at position 1:
+ first: "abcdefghij"...
+second: "a*cdefghij"...
+        MESSAGE
+      ensure
+        StringComparison.window = original
+      end
+    end
+
+    it 'allows user to override the prelude size' do
+      original = StringComparison.prelude
+      begin
+        StringComparison.prelude = 2
+        compare "abcdefghijklmnopqrstuvwxyz", "abcdefghijkl*nopqrstuvwxyz", <<-MESSAGE
+Strings differ at position 12:
+ first: ..."klmnopqrstuvwxyz"
+second: ..."kl*nopqrstuvwxyz"
+        MESSAGE
+      ensure
+        StringComparison.prelude = original
+      end
+    end
+  end
+  end
+
+  describe "Wrong integration" do
+    it "works" do
+      error = rescuing do
+        assert { "xyz" == "abc" }
+      end
+      assert { error.message =~ /Strings differ/ }
+    end
+  end
+end