wrong 0.4.0 → 0.4.5

data/test/assert_advanced_test.rb

@@ -20,18 +20,18 @@ describe "advanced assert features" do
     end
   end
 
-  xit "can parse a here doc defined inside the block" do
+  it "can parse a here doc defined inside the block" do
     # todo: test in Chunk too
-    assert { "123\n456" == <<-TEXT
+    assert { "123\n456\n" == <<-TEXT
 123
 456
     TEXT
     }
   end
 
-  xit "can parse a here doc defined outside the block" do
+  it "can parse a here doc defined outside the block" do
     # todo: test in Chunk too
-    assert { "123\n456" == <<-TEXT }
+    assert { "123\n456\n" == <<-TEXT }
 123
 456
     TEXT

data/test/chunk_test.rb

@@ -175,6 +175,13 @@ z
       code_parts = chunk.parts
       assert !code_parts.include?("rescuing")
     end
+    
+    it "skips assignments" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        x = 7; x
+      CODE
+      assert !chunk.parts.include?("(x = 7)")
+    end    
   end
 
   describe "#details" do
@@ -247,6 +254,13 @@ z
       # this means it's a literal slash plus t inside double quotes -- i.e. it shows the escaped (inspected) string
       assert d == "\n" + '    x is "flavor:\tvanilla"' + "\n"
     end
+    
+    it "skips assignments" do
+      y = 14
+      d = details { x = 7; y }
+      assert d !~ /x = 7/
+      assert d =~ /y is 14/
+    end
 
     it "indents unescaped newlines inside the inspected value" do
       weirdo = Object.new

data/test/config_test.rb

@@ -10,80 +10,127 @@ describe Wrong::Config do
   include Wrong
 
   before do
-    Wrong.config.clear
+    @config = Wrong::Config.new
   end
 
-  it "singleton" do
-    c = Wrong.config
-    assert { c.is_a?(Wrong::Config) }
-    c2 = Wrong.config
-    assert { c.object_id == c2.object_id }
-  end
-
-#  it "reads from a .wrong file"
+  it "has magic setters" do
+    config = Wrong::Config.new
+    config.foo = "bar"
+    assert { config[:foo] == "bar" }
 
-  it "getting an undeclared setting" do
-    assert { Wrong.config[:foo].nil? }
+    config.baz
+    assert { config[:baz] }
   end
 
-  it "setting and getting" do
-    Wrong.config[:foo] = "bar"
-    assert { Wrong.config[:foo] == "bar" }
+  it "reads from a string" do
+    config = Wrong::Config.new <<-SETTINGS
+cold
+flavor = "chocolate"
+alias_assert :yum
+    SETTINGS
+    assert { config[:cold] }
+    assert { config[:flavor] == "chocolate" }
+    assert { config.assert_method_names.include? :yum }
   end
 
-  describe "adding aliases for assert" do
-    before do
-      Wrong.config.alias_assert(:is)
+  describe "Wrong.config" do
+    it "is a singleton" do
+      c = Wrong.config
+      assert { c.is_a?(Wrong::Config) }
+      c2 = Wrong.config
+      assert { c.object_id == c2.object_id }
     end
 
-    it "succeeds" do
-      is { 2 + 2 == 4 }
+    it "reads from a .wrong file in the current directory" do
+      wrong_settings = File.read(".wrong")
+      assert { wrong_settings != "" }
+      assert { Wrong.config[:test_setting] == "xyzzy" }
     end
 
-    it "fails" do
-      e = rescuing {
-        is("math is hard") { 2 + 2 == 5 }
-      }
-      expected = <<-FAIL
-math is hard: Expected ((2 + 2) == 5), but 4 is not equal to 5
-    (2 + 2) is 4
-      FAIL
-      assert { e.message == expected }
+    it "reads from a .wrong file in a parent directory" do
+      wrong_settings = File.read(".wrong")
+      Dir.chdir("test") do # move into a subdirectory
+        assert { Wrong.load_config[:test_setting] == "xyzzy" }
+      end
     end
 
-    it "doesn't keep aliasing the same word" do
-      Wrong.config.alias_assert(:is)
-      Wrong.config.alias_assert(:is)
-      assert { Wrong.config.assert_method_names == [:assert, :is] } 
+    it "uses defaults if there is no .wrong file" do
+      Dir.chdir("/tmp") do # hopefull there's no .wrong file here or in /
+        config = Wrong.load_config
+        assert { config[:test_setting] == nil }
+      end
     end
+
   end
 
-  describe "adding aliases for deny" do
-    before do
-      Wrong.config.alias_deny(:aint)
-    end
+  it "getting an undeclared setting" do
+    assert { @config[:foo].nil? }
+  end
+
+  it "setting and getting" do
+    @config[:foo] = "bar"
+    assert { @config[:foo] == "bar" }
+  end
 
-    it "succeeds" do
-      aint { 2 + 2 == 5 }
+  describe "adding aliases" do
+    after do
+      Wrong.config = Wrong::Config.new
     end
 
-    it "fails" do
-      e = rescuing {
-        aint("math is hard") { 2 + 2 == 4 }
-      }
-      expected = <<-FAIL
-math is hard: Didn't expect ((2 + 2) == 4), but 4 is equal to 4
+    describe "for assert" do
+      before do
+        Wrong.config.alias_assert(:is)
+      end
+
+      it "succeeds" do
+        is { 2 + 2 == 4 }
+      end
+
+      it "fails" do
+        e = rescuing {
+          is("math is hard") { 2 + 2 == 5 }
+        }
+        expected = <<-FAIL
+math is hard: Expected ((2 + 2) == 5), but
     (2 + 2) is 4
-      FAIL
-      assert { e.message == expected }
+        FAIL
+        assert { e.message == expected }
+      end
+
+      it "doesn't keep aliasing the same word" do
+        @config.alias_assert(:is)
+        @config.alias_assert(:is)
+        assert { @config.assert_method_names == [:assert, :is] }
+      end
     end
 
-    it "doesn't keep aliasing the same word" do
-      Wrong.config.alias_deny(:aint)
-      Wrong.config.alias_deny(:aint)
-      assert { Wrong.config.deny_method_names == [:deny, :aint] }
+    describe "for deny" do
+      before do
+        Wrong.config.alias_deny(:aint)
+      end
+
+      it "succeeds" do
+        aint { 2 + 2 == 5 }
+      end
+
+      it "fails" do
+        e = rescuing {
+          aint("math is hard") { 2 + 2 == 4 }
+        }
+        expected = <<-FAIL
+math is hard: Didn't expect ((2 + 2) == 4), but
+    (2 + 2) is 4
+        FAIL
+        assert { e.message == expected }
+      end
+
+      it "doesn't keep aliasing the same word" do
+        @config.alias_deny(:aint)
+        @config.alias_deny(:aint)
+        assert { @config.deny_method_names == [:deny, :aint] }
+      end
+
     end
 
   end
-
 end

data/test/failure_message_test.rb

@@ -2,22 +2,22 @@ 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
+class BogusFormatter < Wrong::FailureMessage::Formatter
+  def match?
+    predicate.is_a? BogusPredicate
   end
 
-  class BogusPredicate < Predicated::Predicate
+  def describe
+    "bogus #{predicate.object_id}"
   end
+end
+
+class BogusPredicate < Predicated::Predicate
+end
+
+module Wrong
 
-  describe FailureMessage::Formatter do
+  describe Wrong::FailureMessage::Formatter do
     include Wrong::Assert
 
     it "describes a predicate" do
@@ -27,13 +27,63 @@ module Wrong
     end
   end
 
-  describe FailureMessage do
+  describe Wrong::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)}
+      Wrong::FailureMessage.register_formatter(::BogusFormatter)
+      assert { Wrong::FailureMessage.formatter_for(::BogusPredicate.new).is_a? ::BogusFormatter }
+      assert { Wrong::FailureMessage.formatters.include?(::BogusFormatter)}
+    end
+
+    before do
+      @chunk = Wrong::Chunk.new(__FILE__, __LINE__ + 1) do
+        2 + 2 == 5
+      end
+    end
+
+    def message(options = {}, &block)
+      valence = options[:valence] || :assert 
+      explanation = options[:explanation]
+      Wrong::FailureMessage.new(@chunk, valence, explanation)
+    end
+
+
+    describe "#basic" do      
+      it "shows the code" do
+        assert { message.basic == "Expected ((2 + 2) == 5)" }
+      end
+      
+      it "reverses the message for :deny valence" do
+        assert { message(:valence => :deny).basic == "Didn't expect ((2 + 2) == 5)" }
+      end
+    end
+    
+    describe '#full' do
+      it "contains the basic message" do
+        assert { message.full.include? message.basic }
+      end
+
+      it "contains the explanation if there is one" do
+        msg = message(:explanation => "the sky is falling")
+        assert { msg.full.include? "the sky is falling" }
+      end
+      
+      it "doesn't say 'but' if there are no details" do
+        @chunk = Wrong::Chunk.new(__FILE__, __LINE__ + 1) do
+          2
+        end
+        assert { @chunk.details.empty? }
+        deny { message.full.include? ", but"}
+      end
+      
+      it "says 'but' if there are details" do
+        @chunk = Wrong::Chunk.new(__FILE__, __LINE__ + 1) do
+          2 + 2 == 5
+        end
+        assert { message.full.include? ", but\n    (2 + 2) is 4"}
+      end
+      
     end
 
   end

data/test/failures_test.rb

@@ -1,6 +1,7 @@
 require "./test/test_helper"
 
 require "wrong/assert"
+require "wrong/sexp_ext"
 
 describe "failures" do
 
@@ -25,51 +26,17 @@ describe "failures" do
     end
 
     it "equality failure" do
-      assert_match "1 is not equal to 2", get_error {
+      assert_match "Expected (1 == 2)", get_error {
         @m.assert { 1==2 }
       }.message
-      assert_match "1 is equal to 1", get_error {
+      assert_match "Didn't expect (1 == 1)", get_error {
         @m.deny { 1==1 }
       }.message
     end
 
-    it "failure of basic operations" do
-      assert_match "1 is not greater than 2", get_error {
-        @m.assert { 1>2 }
-      }.message
-      assert_match "2 is not less than 1", get_error {
-        @m.assert { 2<1 }
-      }.message
-      assert_match "1 is not greater than or equal to 2", get_error {
-        @m.assert { 1>=2 }
-      }.message
-      assert_match "2 is not less than or equal to 1", get_error {
-        @m.assert { 2<=1 }
-      }.message
-
-      assert_match "2 is greater than 1", get_error {
-        @m.deny { 2>1 }
-      }.message
-      assert_match "1 is less than 2", get_error {
-        @m.deny { 1<2 }
-      }.message
-      assert_match "2 is greater than or equal to 1", get_error {
-        @m.deny { 2>=1 }
-      }.message
-      assert_match "1 is less than or equal to 2", get_error {
-        @m.deny { 1<=2 }
-      }.message
-    end
-
-    it "object failure" do
-      assert_match "Color:red is not equal to 2", get_error {
-        @m.assert { Color.new("red")==2 }
-      }.message
-    end
-
     it %{multiline assert block shouldn't look any different
            than when there everything is on one line} do
-      assert_match("1 is not equal to 2", get_error {
+      assert_match("Expected (1 == 2)", get_error {
         @m.assert {
           1==
                   2
@@ -82,52 +49,44 @@ describe "failures" do
   describe "accessing and printing values set outside of the assert" do
     it "use a value in the assert defined outside of it" do
       a = 1
-      assert_match "1 is not equal to 2", get_error {
+      assert_match "Expected (a == 2), but", get_error {
         @m.assert { a==2 }
       }.message
-      assert_match "1 is equal to 1", get_error {
+      assert_match "Didn't expect (a == 1)", get_error {
         @m.deny { a==1 }
       }.message
     end
   end
 
-  describe "conjunctions (and and or)" 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 }
-      }.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
-  end
-
-  describe "the assert block has many statements" do
-    it "only pay attention to the final statement" do
-      assert_match("1 is not equal to 2", get_error {
-        @m.assert {
-          a = "aaa"
-          b = 1 + 2
-          c = ["foo", "bar"].length / 3
-          if a=="aaa"
-            b = 4
-          end; 1==2
-        }
-      }.message)
-    end
-
-    it "works even if the assertion is based on stuff set previously in the block" do
-      assert_match("\"aaa\" is not equal to \"bbb\"", get_error {
-        @m.assert {
-          a = "aaa"
-          a=="bbb"
-        }
-      }.message)
-    end
-  end
+  # describe "the assert block has many statements" do
+    # this is not true anymore -- should it be?
+    # it "only pay attention to the final statement" do
+    #   assert_match("Expected (1 == 2)", get_error {
+    #     @m.assert {
+    #       a = "aaa"
+    #       b = 1 + 2
+    #       c = ["foo", "bar"].length / 3
+    #       if a=="aaa"
+    #         b = 4
+    #       end; 1==2
+    #     }
+    #   }.message)
+    # end
+
+    # this raises an error trying to evaluate 'a'
+    it "works even if the assertion is based on stuff set previously in the block"
+     # do
+     #      assert_match(/Expected.*\(a == "bbb"\)/, get_error {
+     #        @m.assert {
+     #          a = "aaa"
+     #          a=="bbb"
+     #        }
+     #      }.message)
+     #    end
 
   describe "array comparisons" do
     it "basic" do
-      assert_match %{[1, 2] is not equal to ["a", "b"]}, get_error {
+      assert_match 'Expected ([1, 2] == ["a", "b"])', get_error {
         @m.assert { [1, 2]==%w{a b} }
       }.message
     end
@@ -138,19 +97,14 @@ describe "failures" do
       e = get_error {
         @m.assert { {1=>2}=={"a"=>"b"} }
       }
-      assert_match '{1=>2} is not equal to {"a"=>"b"}',
-                   e.message
-    end
-  end
-
-  describe "methods that result in a boolean.  this might be hard." do
-    it "string include" do
-      assert_match "\"abc\" does not include \"cd\"", get_error {
-        @m.assert { "abc".include?("cd") }
-      }.message
-      assert_match "\"abc\" includes \"bc\"", get_error {
-        @m.deny { "abc".include?("bc") }
-      }.message
+      # this is weird; it should realize those details are truisms  -- must be a whitespace thing
+      expected =<<-TEXT
+Expected ({ 1 => 2 } == { "a" => "b" }), but
+    { 1 => 2 } is {1=>2}
+    { "a" => "b" } is {"a"=>"b"}
+      TEXT
+
+      assert_equal expected, e.message
     end
   end
 

data/test/message/array_diff_test.rb

@@ -2,14 +2,13 @@ require "./test/test_helper"
 require "wrong/assert"
 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 { first_array == second_array }
     }
     assert {
       e.message.include?(expected_error_message.strip)
@@ -27,6 +26,11 @@ describe "when you're comparing strings and they don't match, show me the diff m
         assert { nil==[1] }
       }.message.include?("^")
     }
+    deny {
+      rescuing {
+        assert { {:a=>1}==[1] }
+      }.message.include?("^")
+    }
   end
 
   it "simple" do

data/test/string_comparison_test.rb

@@ -5,6 +5,8 @@ require "wrong/message/string_comparison"
 module Wrong
 describe StringComparison do
 
+  StringComparison = Wrong::StringComparison # so Ruby 1.9.1 can find it
+  
   before do
     # crank the window and prelude down for these tests
     @old_window = StringComparison.window
@@ -153,7 +155,7 @@ second: ..."kl*nopqrstuvwxyz"
       error = rescuing do
         assert { "xyz" == "abc" }
       end
-      assert { error.message =~ /Strings differ/ }
+      assert { error.message =~ /Strings differ at position 0:/ }
     end
   end
 end

data/test/test_helper.rb

@@ -1,4 +1,8 @@
-puts "RUBY_VERSION=#{RUBY_VERSION}#{" (JRuby)" if Object.const_defined?(:JRuby)}"
+puts(if Object.const_defined? :RUBY_DESCRIPTION
+  RUBY_DESCRIPTION
+else
+  "ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE} patchlevel #{RUBY_PATCHLEVEL}) [#{RUBY_PLATFORM}]"
+end)
 
 dir = File.dirname(__FILE__)
 $LOAD_PATH.unshift "#{dir}/../lib"
@@ -26,7 +30,26 @@ def get_error
   error
 end
 
-class MiniTest::Unit::TestCase
+def sys(cmd, expected_status = 0)
+  start_time = Time.now
+  $stderr.print cmd
+  Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thread|
+    # in Ruby 1.8, wait_thread is nil :-( so just pretend the process was successful (status 0)
+    exit_status = (wait_thread.value.exitstatus if wait_thread) || 0
+    output = stdout.read + stderr.read
+    unless expected_status.nil?
+      assert { output and exit_status == expected_status }
+    end
+    yield output if block_given?
+    output
+  end
+ensure
+  $stderr.puts " (#{"%.2f" % (Time.now - start_time)} sec)"
+end
+
+def clear_bundler_env
+  # Bundler inherits its environment by default, so clear it here
+  %w{BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE}.each { |var| ENV.delete(var) }
 end
 
 module Kernel
@@ -37,7 +60,7 @@ end
 
 class MiniTest::Spec
   include MiniTest::Assertions
-  
+
   class << self
     def xit(str)
       puts "x'd out test \"#{str}\""