Class: Riot::AssertionMacro

Inherits:
Object show all
Defined in:
lib/riot/assertion_macro.rb

Overview

The base class for all assertion macros.

Using macros

Macros are applied to the return value of assertions. For example, the empty macro asserts that the value is empty or denies that it is empty e.g.

asserts(:comments).empty?
denies(:comments).empty?

Writing your own macros

Macros are added by subclassing AssertionMacro. For example, here's the implementation of empty:

class EmptyMacro < AssertionMacro
  register :empty

  def evaluate(actual)
    actual.length == 0 ? pass : fail(expected_message(actual).to_be_empty)
  end

  def devaluate(actual)
    actual.empty? ? fail(expected_message(actual).to_not_be_empty) : pass(new_message.is_empty)
  end
end

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Class Attribute Details

.expects_exceptionBoolean (readonly)

Whether the macro expects an exception to be thrown.

Returns:

  • (Boolean)


36
37
38
# File 'lib/riot/assertion_macro.rb', line 36

def expects_exception
  @expects_exception
end

Instance Attribute Details

#fileString

During failure reporting, what file did the failure occur in

Returns:

  • (String)


65
66
67
# File 'lib/riot/assertion_macro.rb', line 65

def file
  @file
end

#lineNumber

During failure reporting, what line number did the failure occur at

Returns:

  • (Number)


61
62
63
# File 'lib/riot/assertion_macro.rb', line 61

def line
  @line
end

Class Method Details

.expects_exception!Object

Specify that the macro expects an exception to be thrown by the assertion.



47
48
49
# File 'lib/riot/assertion_macro.rb', line 47

def expects_exception!
  @expects_exception = true
end

.register(name) ⇒ Object

Register the macro under the given name.

Parameters:

  • name (String, Symbol)

    the name of the macro



54
55
56
# File 'lib/riot/assertion_macro.rb', line 54

def register(name)
  Assertion.register_macro name, self
end

Instance Method Details

#devaluate(actual) ⇒ Array

Supports negative/converse assertion testing. This is also where magic happens.

Parameters:

Returns:



103
104
105
# File 'lib/riot/assertion_macro.rb', line 103

def devaluate(actual)
  !actual ? pass : fail("Expected non-true but got #{actual.inspect} instead")
end

#error(ex) ⇒ Array[Symbol, Exception]

Returns a status tuple indicating the assertion had an unexpected error.

Parameters:

  • ex (Exception)

    the Exception that was captured

Returns:

  • (Array[Symbol, Exception])


84
# File 'lib/riot/assertion_macro.rb', line 84

def error(ex) [:error, ex]; end

#evaluate(actual) ⇒ Array

Supports positive assertion testing. This is where magic happens.

Parameters:

Returns:



95
96
97
# File 'lib/riot/assertion_macro.rb', line 95

def evaluate(actual)
  actual ? pass : fail("Expected non-false but got #{actual.inspect} instead")
end

#expected_message(*phrases) ⇒ Riot::Message

Creates a new message for use in any macro response that will start as “expected ”.

Parameters:

  • *phrases (Array<Object>)

    array of object whose values will be inspected and added to message

Returns:



123
# File 'lib/riot/assertion_macro.rb', line 123

def expected_message(*phrases) new_message.expected(*phrases); end

#expects_exception?boolean

Returns true if this macro expects to handle Exceptions during evaluation.

Returns:

  • (boolean)


89
# File 'lib/riot/assertion_macro.rb', line 89

def expects_exception?; self.class.expects_exception; end

#fail(message) ⇒ Array[Symbol, String, Number, String]

Returns a status tuple indicating the assertion failed and where it failed it if that can be determined.

Parameters:

  • message (String)

    the message to report with

Returns:

  • (Array[Symbol, String, Number, String])


78
# File 'lib/riot/assertion_macro.rb', line 78

def fail(message) [:fail, message.to_s, line, file]; end

#new_message(*phrases) ⇒ Riot::Message

Creates a new message for use in any macro response that is initially empty.

Parameters:

  • *phrases (Array<Object>)

    array of object whose values will be inspected and added to message

Returns:



111
# File 'lib/riot/assertion_macro.rb', line 111

def new_message(*phrases) Message.new(*phrases); end

#pass(message = nil) ⇒ Array[Symbol, String]

Returns a status tuple indicating the assertion passed.

Parameters:

  • message (String) (defaults to: nil)

    the message to report with

Returns:

  • (Array[Symbol, String])


71
# File 'lib/riot/assertion_macro.rb', line 71

def pass(message=nil) [:pass, message.to_s]; end

#should_have_message(*phrases) ⇒ Riot::Message

Creates a new message for use in any macro response that will start as “should have ”.

Parameters:

  • *phrases (Array<Object>)

    array of object whose values will be inspected and added to message

Returns:



117
# File 'lib/riot/assertion_macro.rb', line 117

def should_have_message(*phrases) new_message.should_have(*phrases); end