Wrong provides a general assert method that takes a predicate block. Assertion failure messages are rich in detail.
Wrong provides a general assert method that takes a predicate block. Assertion failure messages are rich in detail.
Maintained by: Alex Chaffee
Wrong provides a simple, general assert method that takes a block, and understands the code inside it, providing verbose failure messages for free.
The Wrong idea is to replace assert_equal and all those countless assert\_this, assert\_that, should\_something library methods which only exist to give a failure message that's not simply "assertion failed". Wrong replaces all of them in one fell swoop, since if you can write it in Ruby, Wrong can make a sensible failure message out of it.
We'd very much appreciate feedback and bug reports. There are plenty of things left to be done to make the results look uniformly clean and beautiful. We want your feedback, and especially to give us cases where either it blows up or the output is ugly or uninformative.
Inspired by assert { 2.0 } but rewritten from scratch. Compatible with Ruby (MRI) 1.8, 1.9, and JRuby 1.5.
gem install wrongWe have deployed gems for both Ruby and JRuby; if you get dependency issues on your platform, please let us know what Ruby interpreter and version you're using and what errors you get, and we'll try to track it down.
Wrong provides a simple assert method that takes a block:
require "wrong" # or require "wrong/adapters/rspec" (see below)
include Wrong
assert { 1 == 1 }
==> nil
assert { 2 == 1 }
==> Expected (2 == 1), but 2 is not equal to 1If your assertion is more than a simple predicate, then Wrong will split it into parts and show you the values of all the relevant subexpressions.
x = 7; y = 10; assert { x == 7 && y == 11 }
==>
Expected ((x == 7) and (y == 11)), but
(x == 7) is true
x is 7
(y == 11) is false
y is 10--
age = 24
name = "Gaga"
assert { age >= 18 && ["Britney", "Snooki"].include?(name) }
==>
Expected ((age >= 18) and ["Britney", "Snooki"].include?(name)), but
(age >= 18) is true
age is 24
["Britney", "Snooki"].include?(name) is false
name is "Gaga"And a companion, 'deny':
deny{'abc'.include?('bc')}
==> Didn't expect "abc".include?("bc")More examples are in the file examples.rb
There's also a spreadsheet showing a translation from Test::Unit and RSpec to Wrong, with notes, at this Google Doc. (Ask if you want editing privileges.)
And don't miss the slideshare presentation.
All these helper methods are provided if you do include Wrong.
There's also a convenience method for catching errors:
assert{ rescuing{raise "vanilla"}.message == "chocolate" }
==>
Expected (rescuing { raise("vanilla") }.message == "chocolate"), but
rescuing { raise("vanilla") }.message is "vanilla"
rescuing { raise("vanilla") } is #
raise("vanilla") raises RuntimeError: vanillaAnd one for capturing output streams:
assert { capturing { puts "hi" } == "hi\n" }
assert { capturing(:stderr) { $stderr.puts "hi" } == "hi\n" }
out, err = capturing(:stdout, :stderr) { ... }
assert { out == "something standard\n" }
assert { err =~ /something erroneous/ }If you want to compare floats, try this:
assert { 5.0.close_to?(5.0001) } # default tolerance = 0.001
assert { 5.0.close_to?(5.1, 0.5) } # optional tolerance parameterIf you don't want close_to? cluttering up Float in your test runs then use include Wrong::Assert instead of include Wrong.
close_to? also works on Times, Dates, and DateTimes. The default tolerance of 1 msec may be too small for you, so you might want to do something like:
assert { user.created_at.close_to?(Time.now, 2) } # or 2.secondsclose_to? also works inside RSpec should statements with the magic be matcher, e.g.
5.should be_close_to(6)We also implement the most amazing debugging method ever, d, which gives you a sort of mini-wrong wherever you want it
, even in production code at runtime:
require 'wrong'
x = 7
d { x } # => prints "x is 7" to the console
d { x * 2 } # => prints "(x * 2) is 14" to the console
d("math is hard") { 2 + 2 } #=> prints "math is hard: (2 + 2) is 4"d was originally implemented by Rob Sanheim in LogBuddy; as with Assert2 this version is a rewrite and homage. You may also enjoy g by jugyo.
Remember, if you want d to work at runtime (e.g. in a webapp) then you must include Wrong::D inside your app, e.g. in your environment.rb file.
If you care that something is going to be true soon, but maybe not right now, use eventually.
eventually { night? }It will keep executing the block, up to 4 times a second, until either
If the block raises an exception, then eventually will treat that as a false and keep trying. The last time it fails, it'll raise that exception instead of a mere AssertionFailedError. That way, the following are all possible:
eventually { false }
eventually { assert { false } }
eventually { false.should be_true } # in RSpecand you should get the expected failure after time expires.
You can also send options to eventually as hash parameters.
eventually(:timeout => 10) { false } # keep trying for 10 sec
eventually(:delay => 1) { false } # try every 1.0 sec, not every 0.25 sec(For now, eventually is in its own module, but you get it when you include Wrong. Maybe it should be in Helpers like the rest?)
Adapters for various test frameworks sit under wrong/adapters.
Currently we support
require 'wrong/adapters/test_unit'require 'wrong/adapters/minitest'require 'wrong/adapters/rspec' (now supports both 1.3 and 2.0)To use these, put the appropriate require in your helper, after requiring your test framework; it should extend the framework enough that you can use assert { } in your test cases without extra fussing around.
For example:
require "test/unit"
require "wrong/adapters/test_unit"
class PlusTest Expected (increment == 2), but
increment is 5The first time increment fires the result is 2. The second time the result is 3, and then Wrong introspects the block to create a good failure message, causing increment to fire a couple more times.
Confusing, we know! A few patient Wrong users have hit this when the assert involves ActiveRecord write methods like #create! and #save.
The fix: introduce a variable:
value = increment
assert { value == 2 }
assert { value == 2 }So does the world need another assertion framework? In fact, it does not! We actually believe the world needs fewer assert methods.
The Wrong idea is to replace all those countless assert_this, assert_that, should_something library methods which only exist to give a more useful failure message than "assertion failed". Wrong replaces all of them in one fell swoop, since if you can write it in Ruby, Wrong can make a sensible failure message out of it.
Even the lowly workhorse assert_equal is bloated compared to Wrong: would you rather write this
assert_equal time, moneyor this
assert { time == money }? The Wrong way has the advantage of being plain, transparent Ruby code, not an awkward DSL that moves "equal" out of its natural place between the comparands. Plus, WYSIWYG! You know just from looking at it that "equal" means ==, not eql? or === or =~.
Moreover, much like TDD itself, Wrong encourages you to write cleaner code. If your assertion messages are not clear and "Englishy", then maybe it's time for you to refactor a bit -- extract an informatively named variable or method, maybe push some function onto its natural object a la the Law of Demeter... Also, try not to call any methods with side effects inside an assert. In addition to being bad form, this can cause messed-up failure messages, since the side effects may occur several times in the process of building the message.
Wrong also lets you put the expected and actual values in any order you want! Consider the failure messages for
assert { current_user == "joe" } # => Expected (current_user == "joe") but current_user is "fred"
assert { "joe" == current_user } # => Expected ("joe" == current_user) but current_user is "fred"You get all the information you want, and none you don't want. At least, that's the plan! :-)
Wrong is compatible with RSpec and MiniTest::Spec, and probably Cucumber too, so you can use it inside your BDD framework of choice. To make your test code even BDD-er, try aliasing assert to either should or (Alex's favorite) expect.
Here's an RSpec example:
require "wrong/adapters/rspec"
Wrong.config.alias_assert :expect, override: true
describe BleuCheese do
it "stinks" do
cheese = BleuCheese.new
expect { cheese.smell > 9000 }
end
endThis makes your code read like a BDD-style DSL, without RSpec's "should" syntax (which is, let's face it, pretty weird the first few hundred times you have to use it). Compare
expect { cheese.smell > 9000 }to
cheese.smell.should be > 9000and consider which one more clearly describes the desired behavior. The object under test doesn't really have a should method, so why should it magically get one during a test?
Warning: currently the use of alias_assert :expect is not compatible with RSpec, since RSpec also defines expect as a synonym for lambda. If you really want to use expect as an alias form assert, then use Wrong.config.alias_assert :expect, :override => true. See issue #6 for more details.
So wait a second. How do we do it? Doesn't Ruby have poor support for AST introspection? Well, yes, it does, so we cheat: we figure out what file and line the assert block is defined in, then open the file, read the code, and parse it directly using Ryan Davis' amazing RubyParser and Ruby2Ruby. You can bask in the kludge by examining chunk.rb and assert.rb. If you find some code it can't parse, please send it our way.
Before you get your knickers in a twist about how this is totally unacceptable because it doesn't support this or that use case, here are our caveats and excuses:
irb -rwrong it'll save off your session in memory where Wrong can read it.-e block but as far as we can tell, there's no way to grab that -e source code from inside Ruby.eval isn't evil, it's just misunderstood.assert per line. (This should not be a problem since even if you're nesting asserts for some bizarre reason, we assume you know where your Return key is.)No open issues yet, or sync has not completed.