wrong 0.1.0 → 0.2.0

data/test/catch_raise_test.rb

@@ -1,9 +1,9 @@
-require "test/test_helper"
+require "./test/test_helper"
 
 require "wrong/assert"
 require "wrong/adapters/minitest"
 
-apropos "a tool for rescuing errors" do
+regarding "a tool for rescuing errors" do
   
   class RedError < StandardError; end
   class BlueError < StandardError; end

data/test/chunk_test.rb

@@ -0,0 +1,236 @@
+require "./test/test_helper"
+require "wrong/chunk"
+
+unless Object.const_defined?(:Chunk)
+  Chunk = Wrong::Chunk
+end
+
+regarding Chunk do
+  regarding "#from_block" do
+    test "reads the source location" do
+      file, line = __FILE__, __LINE__
+      chunk = Chunk.from_block(proc { "hi" })
+      assert(chunk.file == file)
+      assert(chunk.line_number == line+1)
+    end
+  end
+
+  regarding "line numbers" do
+    before do
+      @chunk = Wrong::Chunk.new("foo.rb", 10)
+    end
+    test "#line_index is zero-based" do
+      assert(@chunk.line_index == 9)
+    end
+    test "#location is one-based" do
+      assert(@chunk.location == "foo.rb:10")
+    end
+  end
+
+  regarding "#parse" do
+    test "reads a statement on a line by itself" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        "hi"
+      CODE
+      code = chunk.parse.to_ruby
+      assert(code == '"hi"')
+    end
+
+    test "reads a statement on multiple lines" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        proc do
+          "hi"
+        end
+      CODE
+      code = chunk.parse.to_ruby
+      assert(code == "proc { \"hi\" }")
+    end
+
+    test "fails if there's a stray close-paren symbol on the last line (sorry)" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        "hi" )
+      CODE
+      assert(chunk.parse.nil?)
+    end
+
+    test "fails if there's a stray close-block symbol on the last line (sorry)" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        "hi" }
+      CODE
+      assert(chunk.parse.nil?)
+    end
+
+    test "fails if it can't parse the code" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        }
+      CODE
+      assert(chunk.parse.nil?)
+    end
+
+    test "fails if it can't find the file" do
+      chunk = Chunk.new("nonexistent_file.rb", 0)
+      error = get_error { chunk.parse }
+      assert error.is_a? Errno::ENOENT
+    end
+
+  end
+
+  regarding "#claim" do
+    test "returns the part of the assertion statement inside the curly braces" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        assert { x == 5 }
+      CODE
+      full_code = chunk.parse.to_ruby
+      assert(full_code == "assert { (x == 5) }")
+      claim_code = chunk.claim.to_ruby
+      assert claim_code == "(x == 5)"
+    end
+
+
+    test "reads an assert statement on a line by itself" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        assert { x == 5 }
+      CODE
+      claim_code = chunk.claim.to_ruby
+      assert claim_code == "(x == 5)"
+    end
+
+    test "reads an assert statement on multiple lines" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        assert do
+           x == 5
+        end
+      CODE
+      claim_code = chunk.claim.to_ruby
+      assert claim_code == "(x == 5)"
+    end
+
+    def yielding
+      yield
+    end
+
+    if RUBY_VERSION > "1.9"
+      test "reads an assert statement that's nested inside another yield block on the same line (Ruby 1.9 only)" do
+        chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+          yielding { assert { x == 5 }}
+        CODE
+        code = chunk.claim.to_ruby
+        assert code == "(x == 5)"
+      end
+
+#      test "goes crazy if you try to nest two asserts on the same line"
+    end
+
+    test "if it can't find an assertion, it uses the whole chunk" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        yielding { x == 5 }
+      CODE
+      code = chunk.claim.to_ruby
+      assert code == "yielding { (x == 5) }"
+    end
+
+    test "fails if it can't parse the code" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        }
+      CODE
+      error = get_error {
+        chunk.claim
+      }
+      assert error.message.include?("Could not parse")      
+    end
+  end
+
+  regarding "#parts" do
+    test "returns all unique sub-expressions of the main sexpression" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        assert { (x == 5) && (y == (z + 10)) }
+      CODE
+      code_parts = chunk.parts
+      assert code_parts == <<-PARTS.split("\n")
+((x == 5) and (y == (z + 10)))
+(x == 5)
+x
+5
+(y == (z + 10))
+y
+(z + 10)
+z
+10
+      PARTS
+    end
+  end
+end
+
+regarding Sexp do
+  regarding "#doop" do
+    test "deeply duplicates the sexp" do
+      original = RubyParser.new.parse("x == 5")
+      duplicate = original.doop
+      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)
+      assert(original[3].object_id != duplicate[3].object_id)
+    end
+  end
+
+  regarding "#to_ruby" do
+    test "converts the sexp to ruby code" do
+      sexp = RubyParser.new.parse("x == 5")
+      assert sexp.to_ruby == "(x == 5)"
+    end
+
+    test "leaves the original sexp alone" do
+      sexp = RubyParser.new.parse("x == 5")
+      assert sexp.to_ruby == "(x == 5)"
+      assert sexp.to_ruby == "(x == 5)"
+    end
+  end
+
+  regarding "#assertion? with a question mark" do
+    test "matches an sexp that looks like assert { }" do
+      sexp = RubyParser.new.parse("assert { true }")
+      assert sexp.assertion?
+    end
+    
+    test "matches an sexp that looks like assert(message) { }" do
+      sexp = RubyParser.new.parse("assert('hi') { true }")
+      assert sexp.assertion?
+    end
+
+    test "matches an sexp that looks like deny { }" do
+      sexp = RubyParser.new.parse("deny { false }")
+      assert sexp.assertion?
+    end
+
+    test "doesn't match an sexp that calls assert without a block" do
+      sexp = RubyParser.new.parse("assert(true)")
+      assert !sexp.assertion?
+    end
+
+    test "doesn't match a normal sexp" do
+      sexp = RubyParser.new.parse("x == 5")
+      assert !sexp.assertion?
+    end
+  end
+
+  regarding "#assertion" do
+    test "matches a top-level sexp that looks like assert { }" do
+      sexp = RubyParser.new.parse("assert { true }")
+      code = sexp.assertion.to_ruby
+      assert code == "assert { true }"
+    end
+    
+    test "matches a nested sexp that looks like assert { }" do
+      sexp = RubyParser.new.parse("nesting { assert { true } }")
+      code = sexp.assertion.to_ruby
+      assert code == "assert { true }"
+    end
+
+    test "matches the first nested sexp that looks like assert { }" do
+      sexp = RubyParser.new.parse("nesting { assert { true } or assert { false } }")
+      code = sexp.assertion.to_ruby
+      assert code == "assert { true }"
+    end
+  end
+
+end

data/test/failures_test.rb

@@ -1,113 +1,148 @@
-require "test/test_helper"
+require "./test/test_helper"
 
 require "wrong/assert"
 
-apropos "failures" do
-  
+regarding "failures" do
+
   before do
     @m = Module.new do
       extend Wrong::Assert
     end
   end
-  
-  apropos "simple" do
-    test "raw boolean failure" do
-      assert_match "false", get_error{@m.assert{false}}.message
-      assert_match "true", get_error{@m.deny{true}}.message
+
+  regarding "simple" do
+
+    test "raw boolean assert failure" do
+      error = get_error { @m.assert { false } }
+#      puts error.message
+      assert_match "false", error.message
+    end
+
+    test "raw boolean deny failure" do
+      error = get_error {
+        @m.deny { true }
+      }
+#      puts error.message
+      assert_match "true", error.message
     end
-  
+
     test "equality failure" do
-      assert_match "1 is not equal to 2", get_error{@m.assert{1==2}}.message
-      assert_match "1 is equal to 1", get_error{@m.deny{1==1}}.message
+      assert_match "1 is not equal to 2", get_error {
+        @m.assert { 1==2 }
+      }.message
+      assert_match "1 is equal to 1", get_error {
+        @m.deny { 1==1 }
+      }.message
     end
-  
+
     test "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
-    
-    class Color
-      attr_reader :name
-      def initialize(name)
-        @name = name
-      end
-    
-      def ==(other)
-        other.is_a?(Color) && @name == other.name
-      end
-      
-      def inspect
-        "Color:#{@name}"
-      end
+      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
-    
+
     test "object failure" do
-      assert_match "'Color:red' is not equal to 2", get_error{@m.assert{Color.new("red")==2}}.message
+      assert_match "Color:red is not equal to 2", get_error {
+        @m.assert { Color.new("red")==2 }
+      }.message
     end
-    
-    test %{multiline assert block shouldn't look any different 
+
+    test %{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{@m.assert{
-        1==
-        2
-      }}.message)
+      assert_match("1 is not equal to 2", get_error {
+        @m.assert {
+          1==
+            2
+        }
+      }.message)
     end
 
   end
-  
-  apropos "accessing and printing values set outside of the assert" do
+
+  regarding "accessing and printing values set outside of the assert" do
     test "use a value in the assert defined outside of it" do
       a = 1
-      assert_match "1 is not equal to 2", get_error{@m.assert{a==2}}.message
-      assert_match "1 is equal to 1", get_error{@m.deny{a==1}}.message
+      assert_match "1 is not equal to 2", get_error {
+        @m.assert { a==2 }
+      }.message
+      assert_match "1 is equal to 1", get_error {
+        @m.deny { a==1 }
+      }.message
     end
   end
-  
-  apropos "the assert block has many statements" do
+
+  regarding "the assert block has many statements" do
     test "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)
+      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
 
     test "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)
+      assert_match("\"aaa\" is not equal to \"bbb\"", get_error {
+        @m.assert {
+          a = "aaa"
+          a=="bbb"
+        }
+      }.message)
     end
   end
-  
-  apropos "array comparisons" do
+
+  regarding "array comparisons" do
     test "basic" do
-      assert_match %{'[1, 2]' is not equal to '["a", "b"]'}, get_error{@m.assert{[1,2]==%w{a b}}}.message
+      assert_match %{[1, 2] is not equal to ["a", "b"]}, get_error {
+        @m.assert { [1, 2]==%w{a b} }
+      }.message
     end
   end
-  
-  apropos "hash comparisons" do
+
+  regarding "hash comparisons" do
     test "basic" do
-      assert_match %{'{1=>2}' is not equal to '{"a"=>"b"}'},
-       get_error{@m.assert{{1=>2}=={"a"=>"b"}}}.message
+      assert_match '{1=>2} is not equal to {"a"=>"b"}',
+                   get_error {
+                     @m.assert { {1=>2}=={"a"=>"b"} }
+                   }.message
     end
   end
-  
-  apropos "methods that result in a boolean.  this might be hard." do
+
+  regarding "methods that result in a boolean.  this might be hard." do
     test "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
+      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
     end
   end
 
-end
+end