wrong 0.6.3 → 0.7.0

data/test/adapters/railsapp/spec/wrong_spec.rb

@@ -0,0 +1,8 @@
+
+require './spec/spec_helper.rb'
+describe 'wrong in rspec in rails' do
+  it 'calls the wrong assert' do
+    assert { 1 + 1 == 3}
+  end
+end
+

data/test/adapters/rspec_rails_test.rb

@@ -12,11 +12,11 @@ include Wrong
 # called rspec-rails-generate.sh -- if you dare
 
 
-if RUBY_VERSION == "1.9.2" # too many issues with other versions
+if RUBY_VERSION >= "1.9.2" # too many issues with other versions
 describe "testing rspec-rails" do
 
   [2].each do |rspec_version|
-    it "in version #{rspec_version}" do
+    it "in rspec version #{rspec_version}" do
       railsapp_dir = "#{here}/railsapp"
 
       unless File.exist?(railsapp_dir)
@@ -32,7 +32,7 @@ describe "testing rspec-rails" do
         FileUtils.rm "#{railsapp_dir}/Gemfile.lock", :force => true
 
         # todo: extract into common function
-        sys "bundle check" do |output|
+        sys "bundle check", :ignore do |output|
           unless output == "The Gemfile's dependencies are satisfied\n"
             sys "bundle install --gemfile=#{railsapp_dir}/Gemfile"
           end
@@ -47,7 +47,7 @@ describe "testing rspec-rails" do
         end
 
         spec_output = sys "rspec spec/wrong_spec.rb",
-                          (rspec_version == 1 || RUBY_VERSION =~ /^1\.8\./ || RUBY_VERSION == '1.9.1' ? nil : 1) # RSpec v1 exits with 0 on failure :-(
+                          (rspec_version == 1 || RUBY_VERSION =~ /^1\.8\./ || RUBY_VERSION == '1.9.1' ? :ignore : 1) # RSpec v1 exits with 0 on failure :-(
       end
 
       assert { spec_output.include? "1 example, 1 failure" }

data/test/adapters/rspec_test.rb

@@ -20,7 +20,7 @@ describe "testing rspec" do
         clear_bundler_env
         FileUtils.rm "#{dir}/Gemfile.lock", :force => true
 
-        sys "bundle check", nil do |output|
+        sys "bundle check", :ignore do |output|
           unless output == "The Gemfile's dependencies are satisfied\n"
             sys "bundle install --gemfile=#{dir}/Gemfile --local"
           end
@@ -35,7 +35,7 @@ describe "testing rspec" do
 
         Bundler.with_clean_env do
           # RSpec v1 exits with 0 on failure :-( (as do older rubies)
-          expected_status = (rspec_version == 1 || RUBY_VERSION =~ /^1\.8\./ || RUBY_VERSION == '1.9.1' ? nil : 1)
+          expected_status = (rspec_version == 1 || RUBY_VERSION =~ /^1\.8\./ || RUBY_VERSION == '1.9.1' ? :ignore : 1)
           spec_output = sys "ruby #{dir}/failing_spec.rb", expected_status
         end
       end

data/test/assert_advanced_test.rb

@@ -16,7 +16,7 @@ describe "advanced assert features" do
         assert_later { x > 10 }
       end
 
-      assert(e.message =~ /Expected \(x > 10\), but.*x is 10/m, e.message)
+      assert(e.message =~ /Expected assert_later { \(x > 10\) }, but.*x is 10/m, e.message)
     end
   end
 
@@ -48,4 +48,12 @@ describe "advanced assert features" do
 
   # todo: test for finding it if you'd changed dirs into a parent or sibling or cousin dir
 
+  it "can compare two hashes" do
+    assert { {1=>2} == {1=>2} }
+    unless RUBY_VERSION < "1.9"
+      assert do
+        {a:2} == {a:2}
+      end
+    end
+  end
 end

data/test/chunk_test.rb

@@ -10,11 +10,6 @@ end
 
 describe Chunk do
 
-  # normalize yaml
-  def y(s)
-    s.gsub(/--- $/, "---").chomp
-  end
-
   describe "#from_block" do
     it "reads the source location" do
       file, line = __FILE__, __LINE__
@@ -193,199 +188,4 @@ z
     end
   end
 
-  describe "#details" do
-    def details(&block)
-      chunk = Chunk.from_block(block, 1)
-      chunk.details
-    end
-
-    it "returns an empty string if there are no parts" do
-      d = details { assert { true } }
-      assert d == ""
-    end
-
-    it "returns an string beginning with a newline if there are parts" do
-      x = 10
-      d = details { assert { x == 10 } }
-      assert d == "\n    x is 10\n"
-    end
-
-    it "skips literals" do
-      d = details { assert { 10 == 11 } }
-      assert d == ""
-    end
-
-    it "shows lots of details" do
-      x = 10
-      d = details { assert { (x * (x - 10)) == (x / (x + 10)) } }
-      assert d == <<-DETAILS
-
-    (x * (x - 10)) is 0
-    x is 10
-    (x - 10) is 0
-    (x / (x + 10)) is 0
-    (x + 10) is 20
-      DETAILS
-    end
-
-    it "skips duplicates" do
-      x = 10
-      d = details { assert { (x + 5) == 1 + (x + 5) } }
-      assert d == <<-DETAILS
-
-    (x + 5) is 15
-    x is 10
-    (1 + (x + 5)) is 16
-      DETAILS
-    end
-
-    it "shows exceptions" do
-      d = details { assert { (raise "hi") == 1 } }
-      assert d == "\n    raise(\"hi\") raises RuntimeError: hi\n"
-    end
-
-    it "indents newlines inside the exception message" do
-      d = details { assert { (raise "hello\nsailor") == 1 } }
-      assert d == "\n    raise(\"hello\\nsailor\") raises RuntimeError: hello\n      sailor\n"
-    end
-
-    it "abridges exceptions with no message" do
-      d = details { assert { (raise Exception.new) == 1 } }
-      assert d == "\n    raise(Exception.new) raises Exception\n" +
-              "    Exception.new is #<Exception: Exception>\n"
-    end
-
-    it "inspects values" do
-      x = "flavor:\tvanilla"
-      d = details { assert { x == "flavor:\tchocolate" } }
-      # 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 "splits lower-down details correctly (bug)" do
-      hash = {:flavor => "vanilla"}
-      exception_with_newlines = Exception.new(hash.to_yaml.chomp)
-      d = details {
-        rescuing { raise exception_with_newlines }.message.include?(":flavor: chocolate")
-      }
-      assert (y(d).include? "exception_with_newlines is #<Exception: ---\n      :flavor: vanilla>"), d.inspect
-    end
-
-    it "skips assignments" do
-      y = 14
-      d = details { x = 7; y }
-      assert d !~ /x = 7/
-      assert d =~ /y is 14/
-    end
-
-    class Weirdo
-      def initialize(inspected_value)
-        @inspected_value = inspected_value
-      end
-
-      def inspect
-        @inspected_value
-      end
-    end
-
-
-    it "indents unescaped newlines inside the inspected value" do
-      x = Weirdo.new("first\nsecond\nthird")
-      d = details { assert { x == "foo" } }
-      assert d == "\n    x is first\n      second\n      third\n"
-    end
-
-    describe '#pretty_value' do
-      before do
-        @chunk = chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
-          true
-        CODE
-      end
-
-      after do
-        Chunk.terminal_width = 80
-      end
-
-      it 'inspects its value' do
-        assert @chunk.pretty_value(12) == "12"
-        assert @chunk.pretty_value("foo") == "\"foo\""
-      end
-
-      it 'escapes newlines in strings' do
-        assert @chunk.pretty_value("foo\nbar\nbaz") == "\"foo\\nbar\\nbaz\""
-      end
-
-      it 'indents newlines in raw inspect values (e.g. exceptions or YAML or whatever)' do
-        w = Weirdo.new("foo\nbar\nbaz")
-        assert @chunk.pretty_value(w) == "foo\n      bar\n      baz"
-      end
-
-      it "returns the terminal width" do
-        assert Chunk.terminal_width.is_a? Fixnum
-        assert Chunk.terminal_width > 0
-      end
-
-      it "can fake the terminal width" do
-        Chunk.terminal_width = 66
-        assert Chunk.terminal_width == 66
-      end
-
-      # def pretty_value(value, starting_col = 0, indent_wrapped_lines = 3, size = Chunk.terminal_size)
-
-      it 'inserts newlines in really long values, wrapped at the given width' do
-        abc = Weirdo.new("abcdefghijklmnopqrstuvwxyz")
-        pretty = @chunk.pretty_value(abc, 0, 0, 10)
-        assert pretty == <<-DONE.chomp
-abcdefghij
-klmnopqrst
-uvwxyz
-DONE
-      end
-
-      it 'inserts newlines in really long values, wrapped at the terminal width' do
-        Chunk.terminal_width = 10
-        abc = Weirdo.new("abcdefghijklmnopqrstuvwxyz")
-        pretty = @chunk.pretty_value(abc, 0, 0)
-        assert pretty == <<-DONE.chomp
-abcdefghij
-klmnopqrst
-uvwxyz
-DONE
-      end
-
-      it 'subtracts the starting column from the wrapped width of the first line' do
-        abc = Weirdo.new("abcdefghijklmnopqrstuvwxyz")
-        pretty = @chunk.pretty_value(abc, 2, 0, 10)
-        assert pretty == <<-DONE.chomp
-abcdefgh
-ijklmnopqr
-stuvwxyz
-        DONE
-      end
-
-      it "indents wrapped lines" do
-        abc = Weirdo.new("abcdefghijklmnopqrstuvwxyz")
-        pretty = @chunk.pretty_value(abc, 2, 3, 10)
-        assert pretty == <<-DONE.chomp
-abcdefgh
-   ijklmno
-   pqrstuv
-   wxyz
-        DONE
-      end
-
-      it "wraps correctly" do
-        hash = {:flavor => "vanilla"}
-        object = Weirdo.new(hash.to_yaml.chomp)
-        pretty = @chunk.pretty_value(object, 2, 3, 80)
-        assert y(pretty) == y(<<-DONE), pretty.inspect
----
-      :flavor: vanilla
-        DONE
-      end
-
-
-    end
-
-  end
 end

data/test/close_to_test.rb

@@ -2,6 +2,7 @@ require "./test/test_helper"
 require "wrong/close_to"
 require "wrong"
 require "bigdecimal"
+require 'time'
 
 describe "#close_to? (monkey patch for float comparison)" do
   include Wrong
@@ -36,11 +37,42 @@ describe "#close_to? (monkey patch for float comparison)" do
     deny   { 5.close_to? 5.1 }
     assert { 5.close_to? 5.1, 0.5 }
   end
-  
-  it "also works for bigdecimals" do    
+
+  it "also works for bigdecimals" do
     assert { BigDecimal.new("5.0").close_to? 5 }
     assert { BigDecimal.new("5.0").close_to? 5.0001 }
     deny   { BigDecimal.new("5.0").close_to? 5.1 }
   end
 
+  one_hour = 60 * 60
+  one_day = one_hour * 24
+
+  it "works for dates" do
+    monday = Date.parse("2000-01-02")
+    tuesday = Date.parse("2000-01-03")
+    assert { monday.close_to? monday }
+    deny { monday.close_to? tuesday }
+    assert { monday.close_to? tuesday, one_day + 1 }
+  end
+
+  it "works for times" do
+    noon = Time.parse("12:00:00")
+    one_pm = Time.parse("13:00:00")
+    one_pm_and_one_second = Time.parse("13:00:01")
+    assert { one_pm.close_to? one_pm }
+    assert { one_pm.close_to? one_pm_and_one_second, 2 }
+    deny { noon.close_to? one_pm }
+    assert { noon.close_to? one_pm, one_hour + 1 }
+  end
+
+  it "works for datetimes" do
+    noon = DateTime.parse("2000-01-01 12:00:00")
+    one_pm = DateTime.parse("2000-01-01 13:00:00")
+    one_pm_and_one_second = DateTime.parse("2000-01-01 13:00:01")
+    assert { one_pm.close_to? one_pm }
+    assert { one_pm.close_to? one_pm_and_one_second, 2 }
+    deny { noon.close_to? one_pm }
+    assert { noon.close_to? one_pm, one_hour + 1 }
+  end
+
 end

data/test/d_test.rb

@@ -24,7 +24,7 @@ describe "d" do
 
   it "pretty-prints the value" do
     begin
-      Wrong::Chunk.terminal_width = 20
+      Wrong::Terminal.width = 20
       x = ["a" * 10, "b" * 10]
       output = capturing do
         d { x }
@@ -33,7 +33,7 @@ describe "d" do
         "x is [\"aaaaaaaaaa\",\n \"bbbbbbbbbb\"]\n"
       }
     ensure
-      Wrong::Chunk.terminal_width = nil
+      Wrong::Terminal.width = nil
     end
   end
 

data/test/eventually_test.rb

@@ -1,4 +1,4 @@
-# based on 
+# based on
 # * https://gist.github.com/1228927
 # * https://github.com/pivotal/selenium/blob/master/lib/selenium/wait_for.rb
 # see
@@ -30,7 +30,7 @@ describe "eventually" do
   include Wrong::Helpers
   include Wrong::D
 
-  # rolling our own mock clock and stubbing framework since we want these 
+  # rolling our own mock clock and stubbing framework since we want these
   # tests to run in MiniTest or in any version of RSpec
 
   class ::Time
@@ -43,27 +43,27 @@ describe "eventually" do
       def now= new_now
         @now = new_now
       end
-    end    
+    end
   end
 
   def stub_it(receiver, method_name, &block)
     receiver.singleton_class.send(:define_method, method_name, &block)
   end
-  
+
   def unstub_it(receiver, method_name)
     receiver.singleton_class.send(:remove_method, method_name)
   end
 
   before do
-    stub_it(self, :sleep) do |secs| 
+    stub_it(self, :sleep) do |secs|
       Time.now += secs
     end
   end
-  
+
   after do
     unstub_it(self, :sleep)
   end
-    
+
   it "requires a block" do
     e = rescuing {
       eventually
@@ -86,29 +86,25 @@ describe "eventually" do
     deny { e.nil? }
     assert { Time.now == original_now + 5}
   end
-  
+
   it "calls the block every 0.25 seconds" do
-    original_now = Time.now            
+    original_now = Time.now
     called_at = []
     rescuing {
-      eventually { 
+      eventually {
         called_at << (Time.now - original_now)
         false
       }
     }
     assert { called_at.uniq == [
-      0.0, 0.25, 0.5, 0.75, 
-      1.0, 1.25, 1.5, 1.75, 
-      2.0, 2.25, 2.5, 2.75, 
-      3.0, 3.25, 3.5, 3.75, 
-      4.0, 4.25, 4.5, 4.75, 
+      0.0, 0.25, 0.5, 0.75,
+      1.0, 1.25, 1.5, 1.75,
+      2.0, 2.25, 2.5, 2.75,
+      3.0, 3.25, 3.5, 3.75,
+      4.0, 4.25, 4.5, 4.75,
     ] }
   end
-  
-  it "puts the elapsed time in the exception message"
-  # assert { e.message =~ /\(after 5 sec\)$/}
-  
-  
+
   it "returns after the condition is false for a while then true" do
     original_now = Time.now
     eventually {
@@ -121,19 +117,20 @@ describe "eventually" do
   end
 
   it "raises a detailed Wrong exception if the result keeps being false" do
-    original_now = Time.now
     e = rescuing do
       eventually { false }
     end
     assert { e.message == "Expected false" }
-    
+
     x = 1
     e = rescuing do
-      eventually { x + 2 == 4 }
+      eventually do
+        x + 2 == 4
+      end
     end
     assert { e.message == "Expected ((x + 2) == 4), but\n    (x + 2) is 3\n    x is 1\n" }
   end
-  
+
   describe "if the block raises an exception" do
     it "for 5 seconds, it raises that exception" do
       original_now = Time.now
@@ -160,27 +157,23 @@ describe "eventually" do
       }
     end
   end
-  
-  describe "passes a context hash to the block" do
-    it "that influences the error message"
-  end
-  
+
   describe "takes an options hash" do
     it "that can change the timeout" do
-      original_now = Time.now      
+      original_now = Time.now
       rescuing {
         eventually(:timeout => 2) { false }
       }
       assert {
-        Time.now == original_now + 2        
+        Time.now == original_now + 2
       }
     end
-    
+
     it "that can change the delay" do
-      original_now = Time.now            
+      original_now = Time.now
       called_at = []
       rescuing {
-        eventually(:delay => 1.5) { 
+        eventually(:delay => 1.5) {
           called_at << (Time.now - original_now)
           false
         }