minitest-should_syntax 1.0.0 → 1.0.2

data/HISTORY.md

@@ -1,3 +1,21 @@
+v1.0.2 - Jan 31, 2013
+---------------------
+
+  * Ruby 1.8 compatibility fixes.
+
+v1.0.1 - Jan 31, 2013
+---------------------
+
+  * Implement the `#otherwise` helper.
+  * Fixed: Make MiniTest show the correct file paths to errors.
+
+### Other changes:
+
+  * Clarify should.not vs should_not in README.
+  * Make the extension test give a more proper example.
+  * More readable tests.
+  * Refactor should_not.
+
 v1.0.0 - Jan 13, 2013
 ---------------------
 

data/README.md

@@ -6,6 +6,9 @@ Rspec-like matching for MiniTest.
 tests.  It monkey-patches Object to translate RSpec-like sugar into plain 
 MiniTest `assert` matchers.
 
+(*Ouch! Monkey patch?* Yes! But it only defines `Object#should` and 
+ `#should_not`.)
+
 ```
 $ gem install minitest-should_syntax
 ```
@@ -31,68 +34,84 @@ end
 Then you may use it as so:
 
 ```ruby
-obj.should == 2                    # => assert_equal 2, obj
-obj.should =~ /regex/              # => assert_match /regex/, obj
-obj.should != 3                    # => assert_not_equal 3, obj
-obj.should.nil                     # => assert_nil obj
-obj.should.respond_to(:freeze)     # => assert_respond_to obj, :freeze 
+  obj.should == 2                    # => assert_equal 2, obj
+  obj.should =~ /regex/              # => assert_match /regex/, obj
+  obj.should != 3                    # => assert_not_equal 3, obj
+  obj.should.nil                     # => assert_nil obj
+  obj.should.respond_to(:freeze)     # => assert_respond_to obj, :freeze 
 
 # Note that .be, .a and .an are optional.
-obj.should.nil                     # => assert_nil obj
-obj.should.be.nil                  # => assert_nil obj
-obj.should.be.a.nil                # => assert_nil obj
+  obj.should.nil                     # => assert_nil obj
+  obj.should.be.nil                  # => assert_nil obj
+  obj.should.be.a.nil                # => assert_nil obj
 
-# You can also use should_not, or should.not:
-obj.should_not == 3
-obj.should.not == 3
-obj.should_not.be.nil
+# You can also use should.not:
+  obj.should.not == 3
+  obj.should.not.be.nil
 
 # Anything else will pass through with a ?:
-obj.should.be.good_looking         # => assert obj.good_looking?
+  obj.should.be.good_looking         # => assert obj.good_looking?
 
-should.raise(Error) { lol }
-should_not.raise { puts "hi" }
+# Testing exceptions:
+  should.raise(ZeroDivisionError) { 2/0 }
 
-# You may add messages to your asserts with #blaming or #messaging.
-(2 + 2).should.blaming("weird math") == 4
+# should_not is an alias for should.not:
+  obj.should_not == 3
 ```
 
 ## Wrapped assertions
 
-These are based from MiniTest::Assertions.
-
-| Test::Unit                  | MiniTest::ShouldSyntax                |
-|-----------------------------|---------------------------------------|
-| assert_equal                | should.equal, should ==               |
-| assert_not_equal            | should.not.equal, should.not ==       |
-| assert_same                 | should.be                             |
-| assert_not_same             | should.not.be                         |
-| assert_nil                  | should.be.nil                         |
-| assert_not_nil              | should.not.be.nil                     |
-| assert_in_delta             | should.be.close                       |
-| assert_match                | should.match, should =~               |
-| assert_no_match             | should.not.match, should.not =~       |
-| assert_instance_of          | should.be.an.instance_of              |
-| assert_kind_of              | should.be.a.kind_of                   |
-| assert_respond_to           | should.respond_to                     |
-| assert_raise                | should.raise                          |
-| assert_nothing_raised       | should.not.raise                      |
-| assert_throws               | should.throw                          |
-| assert_block                | should.satisfy                        |
+These are based on [MiniTest::Assertions].
+
+| MiniTest::ShouldSyntax                  | [MiniTest::Assertions]      |
+|-----------------------------------------|-----------------------------|
+| x.should.equal y                        | assert_equal x, y           |
+| x.should == y                           | assert_equal x, y           |
+| x.should.not.equal                      | refute_equal x, y           |
+| x.should !=                             | refute_equal x, y           |
+| x.should.be                             | assert_same x, y            |
+| x.should.not.be                         | refute_same x, y            |
+| x.should >= *(and others)*              | assert_operator x, :>=, y   |
+| x.should.not >= *(and others)*          | refute_operator x, :>=, y   |
+| x.should.be.nil                         | assert_nil x                |
+| x.should.not.be.nil                     | refute_nil x                |
+| x.should.be.close y                     | assert_in_delta y           |
+| x.should.be.in_epsilon y                | assert_in_epsilon y         |
+| x.should.match /y/                      | assert_match x, /y/         |
+| x.should =~ /y/                         | assert_match x, /y/         |
+| x.should.not.match, should.not =~       | refute_match                |
+| x.should.be.an.instance_of y            | assert_instance_of x, y     |
+| x.should.be.a.kind_of x, y              | assert_kind_of x, y         |
+| x.should.respond_to :y                  | assert_respond_to x, :y     |
+| should.raise(x) { ... }                 | assert_raise(x) { ... }     |
+| should.throw(x) { ... }                 | assert_throws(x) { ... }    |
+| should.satisfy { ... }                  | assert_block { ... }        |
+
+[MiniTest::Assertions]: https://github.com/seattlerb/minitest/blob/master/lib/minitest/unit.rb
 
 ## Messages
 
-Use the `msg` helper:
+Use the `otherwise` helper:
 
 ``` ruby
 it "should work" do
   book = Book.new title: "Pride & Prejudice"
 
-  msg "The title should've been set on constructor."
+  otherwise "The title should've been set on constructor"
   book.title.should == "Pride & Prejudice"
 end
 ```
 
+Result:
+
+```
+1) Failure:
+should work(Test) [your_test.rb:77]:
+The title should've been set on constructor.
+Expected: "Pride & Prejudice"
+  Actual: nil
+```
+
 Or you can use `.blaming` which does the same thing (with a more cumbersome 
     syntax):
 
@@ -100,7 +119,7 @@ Or you can use `.blaming` which does the same thing (with a more cumbersome
 it "should work" do
   book = Book.new title: "Pride & Prejudice"
 
-  message = "The title should've been set on constructor."
+  message = "The title should've been set on constructor"
   book.title.should.blaming(message) == "Pride & Prejudice"
 end
 ```
@@ -113,10 +132,16 @@ Need to create your own matchers? Create your new matcher in a module, then use
 ```ruby
 module DanceMatcher
   def boogie_all_night!
+    # Delegates to `assert(condition, message)`.
+    #
+    #   positive?   - returns `true` if .should, or `false` if .should.not
+    #   test        - the MiniTest object
+    #   msg         - the failure message. `nil` if not set
+    #
     if positive?
-      test.assert left.respond_to?(:dance)
+      test.assert left.respond_to?(:dance), msg
     else
-      test.assert ! left.respond_to?(:dance)
+      test.refute left.respond_to?(:dance), msg
     end
   end
 end

data/lib/minitest/should_syntax.rb

@@ -44,9 +44,8 @@ module MiniTest
       self.send :include, extension
     end
 
-    def initialize(left, neg=false)
+    def initialize(left)
       @left = left
-      @neg  = neg
       if test.msg
         blaming test.msg
         test.msg = nil
@@ -76,7 +75,6 @@ module MiniTest
     def messaging(msg); @msg = msg; self; end
 
     def ==(right)             assert_or_refute :equal, right, left; end
-    def !=(right)             refute_or_assert :equal, right, left; end
     def =~(right)             assert_or_refute :match, right, left; end
     def >(right)              assert_or_refute :operator, left, :>,  right; end
     def <(right)              assert_or_refute :operator, left, :<,  right; end
@@ -91,6 +89,13 @@ module MiniTest
     def empty()               assert_or_refute :empty, left; end
     def satisfy(&blk)         assert_or_refute :block, &blk; end
 
+    # Ruby 1.8 doesn't support overriding !=.
+    if RUBY_VERSION >= "1.9"
+      class_eval %[
+        def !=(right) refute_or_assert :equal, right, left; end
+      ]
+    end
+
     def match(right)          self =~ right; end
     def equal(right)          self == right; end
 
@@ -98,11 +103,13 @@ module MiniTest
     def in_epsilon(right, d=0.001)  assert_or_refute :in_epsilon, right, left, d; end
 
     def assert_or_refute(what, *args, &blk)
-      test.send (positive? ? :"assert_#{what}" : :"refute_#{what}"), *args, msg, &blk
+      args << msg
+      test.send((positive? ? :"assert_#{what}" : :"refute_#{what}"), *args, &blk)
     end
 
     def refute_or_assert(what, *args)
-      test.send (negative? ? :"assert_#{what}" : :"refute_#{what}"), *args, msg
+      args << msg
+      test.send((negative? ? :"assert_#{what}" : :"refute_#{what}"), *args)
     end
 
     def throw(what=nil, &blk)
@@ -139,10 +146,12 @@ class Object
   end
 
   def should_not
-    MiniTest::ShouldSyntax.new(self, true)
+    should.not
   end
 end
 
+# Patch TestCase::before_setup to invoke ShouldSyntax,
+# and inject the #msg and #otherwise helper.
 class MiniTest::Unit::TestCase
   alias :mts_before_setup :before_setup
 
@@ -159,4 +168,21 @@ class MiniTest::Unit::TestCase
   def msg=(string)
     @msg = string
   end
+
+  def otherwise(message)
+    msg message
+  end
 end
+
+# Patch #location() to ignore should_syntax.
+class MiniTest::Unit
+  def location(e) # :nodoc:
+    last_before_assertion = ""
+    e.backtrace.reverse_each do |s|
+      break if s =~ /(in .(assert|refute|flunk|pass|fail|raise|must|wont))|(minitest\/should_syntax)/
+      last_before_assertion = s
+    end
+    last_before_assertion.sub(/:in .*$/, '')
+  end
+end
+

data/lib/minitest/should_syntax/version.rb

@@ -1,7 +1,7 @@
 module MiniTest
   class ShouldSyntax
     def self.version
-      "1.0.0"
+      "1.0.2"
     end
   end
 end

data/test/extension_test.rb

@@ -4,31 +4,31 @@ module MiniTest::ArrayMatcher
   def like(right)
     super  unless left.is_a?(Array) && right.is_a?(Array)
     if positive?
-      test.assert_equal left.sort, right.sort
+      test.assert_equal left.sort, right.sort, msg
     else
-      test.refute_equal left.sort, right.sort
+      test.refute_equal left.sort, right.sort, msg
     end
   end
 end
 
 MiniTest::ShouldSyntax.add MiniTest::ArrayMatcher
 
-class ExtensionTest < UnitTest
-  def test_extension
+describe "Extensions" do
+  it ".should.be.like" do
     a = %w(a b c)
     b = %w(b c a)
 
     a.should.be.like b
   end
 
-  def test_extension_2
+  it ".should.not.be.like" do
     a = %w(a b c)
     b = %w(b c A)
 
-    a.should_not.be.like b
+    a.should.not.be.like b
   end
 
-  def test_extension_3
+  it "super" do
     a = %w(a b c)
     b = 2
 

data/test/helper.rb

@@ -4,5 +4,7 @@ require 'minitest/autorun'
 require 'minitest/should_syntax'
 require 'mocha/setup'
 
-class UnitTest < MiniTest::Unit::TestCase
+class MiniTest::Unit::TestCase
+  # helpers
 end
+

data/test/include_test.rb

@@ -1,11 +1,11 @@
 require File.expand_path('../helper', __FILE__)
 
-class IncludeTest < UnitTest
-  def test_should_include
+describe "Includes" do
+  it ".should.include" do
     "abc".should.include "b"
   end
 
-  def test_should_include_fail
+  it ".should.include failure" do
     self.expects(:assert_includes).with { |a, b| a == "axxc" && b == "b" }
     "axxc".should.include "b"
   end

data/test/should_test.rb

@@ -10,133 +10,131 @@ class Foo
   end
 end
 
-class ShouldTest < UnitTest
-  describe "should" do
-    it ".should ==" do
-      2.should     == 2
-      2.should_not == 3
-      2.should.not == 3
-    end
-
-    it ".should !=" do
-      2.should     != 3
-      2.should_not != 2
-      2.should.not != 2
-    end
-
-    it ".should.match" do
-      "hi".should =~ /hi/
-      "hi".should.match /hi/
-      "hi".should_not =~ /HI/
-      "hi".should.not.match /HI/
-    end
-
-    it ".should.be.nil?" do
-      @foo.should.be.nil?
-      1000.should_not.be.nil?
-    end
-
-    it ".should.respond_to" do
-      "".should.respond_to(:empty?)
-      "".should_not.respond_to(:lolwhat)
-    end
-
-    it ".should.raise" do
-      should.raise(ZeroDivisionError) { 2 / 0 }
-      # should_not.raise { 2 + 2 }
-    end
-
-    it ".should.be.empty" do
-      [].should.be.empty
-      [].should.empty
-    end
-
-    it ".should.not.be.empty" do
-      [1].should_not.be.empty
-      [1].should.include(1)
-    end
-
-    it ".should <" do
-      2.should < 3
-      1.should < 2
-      2.should <= 2
-      2.should <= 4
-      4.should >= 4
-      4.should >= 3
-    end
-
-    it ".should.be.kind_of" do
-      Object.new.should.respond_to(:freeze)
-      Object.new.should.be.kind_of(Object)
-      Object.new.should.be.an.instance_of(Object)
-    end
-
-    it "should.be.equal again" do
-      a = Object.new
-      b = a
-      a.should.be.equal(b)
-      a.should.be(b)
-      a.should_not.be.equal(Object.new)
-    end
-
-
-    it ".should.be.close" do
-      Math::PI.should.be.close(22.0/7, 0.1)
-    end
-
-    it ".should.throw" do
-      should.throw(:x) { throw :x }
-      # should.not.throw { 2 + 2 }
-    end
-
-    it ".should.not.method_missing" do
-      Foo.new.should.not.get_false
-      Foo.new.should.get_true
-    end
-
-    it ".should.be" do
-      a = Object.new
-      b = a
-
-      expects(:assert_same).with(a, b, nil)
-      a.should.be(b)
-    end
-
-    it ".should.include" do
-      expects(:assert_includes).with([], 2, nil)
-      [].should.include 2
-    end
-
-    it ".should.not.include" do
-      expects(:refute_includes).with([], 2, nil)
-      [].should.not.include 2
-    end
-
-    it ".should.blaming" do
-      expects(:assert_equal).with(4, 3, 'lol')
-      3.should.blaming('lol') == 4
-    end
-
-    it ".msg" do
-      expects(:assert_equal).with(4, 3, 'oh no')
-
-      msg "oh no"
-      3.should == 4
-    end
-
-    it ".should.blaming again" do
-      object = Object.new
-
-      expects(:assert).with(true).at_least_once # Because minitest does this
-      expects(:assert).with(true, 'he cant dance')
-      object.expects(:dance?).returns(true)
-
-      object.should.blaming('he cant dance').dance
-    end
-
-    it ".should.satisfy" do
-      expects :assert_block
-      should.satisfy { false }
-    end
+describe "should" do
+  it ".should ==" do
+    2.should     == 2
+    2.should_not == 3
+    2.should.not == 3
+  end
+
+  it ".should !=" do
+    2.should     != 3
+    2.should_not != 2
+    2.should.not != 2
+  end
+
+  it ".should.match" do
+    "hi".should =~ /hi/
+    "hi".should.match /hi/
+    "hi".should_not =~ /HI/
+    "hi".should.not.match /HI/
+  end
+
+  it ".should.be.nil?" do
+    @foo.should.be.nil?
+    1000.should_not.be.nil?
+  end
+
+  it ".should.respond_to" do
+    "".should.respond_to(:empty?)
+    "".should_not.respond_to(:lolwhat)
+  end
+
+  it ".should.raise" do
+    should.raise(ZeroDivisionError) { 2 / 0 }
+    # should_not.raise { 2 + 2 }
+  end
+
+  it ".should.be.empty" do
+    [].should.be.empty
+    [].should.empty
+  end
+
+  it ".should.not.be.empty" do
+    [1].should_not.be.empty
+    [1].should.include(1)
+  end
+
+  it ".should <" do
+    2.should < 3
+    1.should < 2
+    2.should <= 2
+    2.should <= 4
+    4.should >= 4
+    4.should >= 3
+  end
+
+  it ".should.be.kind_of" do
+    Object.new.should.respond_to(:freeze)
+    Object.new.should.be.kind_of(Object)
+    Object.new.should.be.an.instance_of(Object)
+  end
+
+  it "should.be.equal again" do
+    a = Object.new
+    b = a
+    a.should.be.equal(b)
+    a.should.be(b)
+    a.should_not.be.equal(Object.new)
+  end
+
+
+  it ".should.be.close" do
+    Math::PI.should.be.close(22.0/7, 0.1)
+  end
+
+  it ".should.throw" do
+    should.throw(:x) { throw :x }
+    # should.not.throw { 2 + 2 }
+  end
+
+  it ".should.not.method_missing" do
+    Foo.new.should.not.get_false
+    Foo.new.should.get_true
+  end
+
+  it ".should.be" do
+    a = Object.new
+    b = a
+
+    expects(:assert_same).with(a, b, nil)
+    a.should.be(b)
+  end
+
+  it ".should.include" do
+    expects(:assert_includes).with([], 2, nil)
+    [].should.include 2
+  end
+
+  it ".should.not.include" do
+    expects(:refute_includes).with([], 2, nil)
+    [].should.not.include 2
+  end
+
+  it ".should.blaming" do
+    expects(:assert_equal).with(4, 3, 'lol')
+    3.should.blaming('lol') == 4
+  end
+
+  it ".msg" do
+    expects(:assert_equal).with(4, 3, 'oh no')
+
+    msg "oh no"
+    3.should == 4
+  end
+
+  it ".should.blaming again" do
+    object = Object.new
+
+    expects(:assert).with(true).at_least_once # Because minitest does this
+    expects(:assert).with(true, 'he cant dance')
+    object.expects(:dance?).returns(true)
+
+    object.should.blaming('he cant dance').dance
+  end
+
+  it ".should.satisfy" do
+    expects :assert_block
+    should.satisfy { false }
   end
 end

metadata

@@ -2,25 +2,25 @@
 name: minitest-should_syntax
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Rico Sta. Cruz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-12 00:00:00.000000000 Z
+date: 2013-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
     none: false
-  name: minitest
   type: :runtime
-  prerelease: false
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -28,15 +28,15 @@ dependencies:
         version: '0'
     none: false
 - !ruby/object:Gem::Dependency
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
     none: false
-  name: mocha
   type: :development
-  prerelease: false
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -44,15 +44,15 @@ dependencies:
         version: '0'
     none: false
 - !ruby/object:Gem::Dependency
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
     none: false
-  name: rake
   type: :development
-  prerelease: false
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -98,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: RSpec-like syntax for MiniTest.