Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP

[UNSUPPORTED: consider minitest-should_syntax instead.] RSpec-like syntax for Test::Unit

branch: master

Fetching latest commit…

Octocat-spinner-32-eaf2f5

Cannot retrieve the latest commit at this time

Octocat-spinner-32 lib
Octocat-spinner-32 test
Octocat-spinner-32 .gitignore
Octocat-spinner-32 HISTORY.md
Octocat-spinner-32 README.md
Octocat-spinner-32 Rakefile
Octocat-spinner-32 renvy.gemspec
README.md

REnvy

Rspec-like matching for Test::Unit.

REnvy lets you use a syntax similar to RSpec on your Test::Unit tests. It monkey-patches Object to translate RSpec-like sugar into plain Test::Unit assert matchers.

$ gem install renvy

Then you may use it as so:

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

# You can also use should_not, or should.not:
obj.should_not == 3
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?

should.raise(Error) { lol }
should_not.raise { puts "hi" }

# You may add messages to your asserts with #blaming or #messaging.
(2 + 2).should.blaming("weird math") == 4

Wrapped assertions

These are based from Test::Spec.

Test::Unit REnvy
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_nothing_thrown should.not.throw
assert_block should.satisfy

Extending

Need to create your own matchers? Create your new matcher in a module, then use REnvy::Should.add.

module DanceMatcher
  def boogie_all_night!
    if positive?
      test.assert left.respond_to?(:dance)
    else
      test.assert ! left.respond_to?(:dance)
    end
  end
end

REnvy::Should.add DanceMatcher

# Then in your tests, use:
dancer.should.boogie_all_night!

REnvy vs. Test::Spec

Test-Spec accomplishes roughly the same thing as REnvy, but:

  • REnvy does it with lean <4kb code.

  • REnvy can play alongside with other Test::Unit wrappers. In fact, is made to be used with gems like Contest, Shoulda, and other similar tools.

  • REnvy does not provide contexts or 'should'-like syntax like Test::Spec does. For that, I suggest using REnvy alongside Contest.

Something went wrong with that request. Please try again.