Module: Riot::ContextHelpers

Included in:
Context
Defined in:
lib/riot/context_helpers.rb

Instance Method Summary collapse

Instance Method Details

#asserts(what, &definition) ⇒ Object

Makes an assertion.

In the most basic form, an assertion requires a descriptive name and a block.

asserts("#size is equals to 2") { topic.size == 2 }

However, several shortcuts are available. Assertion macros can be added to the end, automating a number of common assertion patterns, e.g.

asserts("#size") { topic.size }.equals(2)

Furthermore, the pattern of testing an attribute on the topic is codified as

asserts(:size).equals(2)

Passing a Symbol to asserts enables this behaviour. For more information on assertion macros, see AssertionMacro.

Parameters:

  • the (String, Symbol) —

    property being tested



77
78
79
 
# File 'lib/riot/context_helpers.rb', line 77

def asserts(what, &definition)
  new_assertion("asserts", what, &definition)
end

#asserts_topic(what = "that it") ⇒ Object

Makes an assertion on the topic itself, e.g.

asserts_topic.matches(/^ab+/)



117
118
119
 
# File 'lib/riot/context_helpers.rb', line 117

def asserts_topic(what="that it")
  asserts(what) { topic }
end

#denies(what, &definition) ⇒ Object

Like an assertion, but expects negative results.

In the most basic form, a denial requires a descriptive name and a block.

denies("#size is equals to 2") { topic.size != 2 }

Several shortcuts are available here as well. Assertion macros can be added to the end, automating a number of common assertion patterns, e.g.

denies("#size") { topic.size }.equals(2)

Furthermore, the pattern of testing an attribute on the topic is codified as

denies(:size).equals(2)

Passing a Symbol to denies enables this behaviour. For more information on assertion macros, see AssertionMacro.

Parameters:

  • the (String, Symbol) —

    property being tested



110
111
112
 
# File 'lib/riot/context_helpers.rb', line 110

def denies(what, &definition)
  new_assertion("denies", what, true, &definition)
end

#helper(name, &block) ⇒ Object

Helpers are essentially methods accessible within a situation.

They’re not setup methods, but can be called from setups or from assetions. Each time called, the helper will be evaluated. It’s not currently memoized.

context "A string" do
  helper(:foo) { "bar" }
  asserts("a foo") { foo }.equals("bar")
end



32
33
34
 
# File 'lib/riot/context_helpers.rb', line 32

def helper(name, &block)
  (@setups << Helper.new(name, &block)).last
end

#hookup(&definition) ⇒ Object

A setup shortcut that returns the original topic so you don’t have to. Good for nested setups. Instead of doing this in your context:

setup do
  topic.do_something
  topic
end

You would do this:

hookup { topic.do_something } # Yay!



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

def hookup(&definition)
  setup { self.instance_eval(&definition); topic }
end

#setup(premium = false, &definition) ⇒ Object

Add a setup block.

A setup block defines the topic of the context. There can be multiple setup blocks; each can access the previous topic through the topic attribute.

context "A string" do
  setup { "foo" }
  setup { topic * 2 }
  asserts(:length).equals(6)
end

If you provide true as the first argument, the setup will be unshifted onto the list of setups, ensuring it will be run before any other setups. This is really only useful for context middlewares.



17
18
19
20
21
 
# File 'lib/riot/context_helpers.rb', line 17

def setup(premium=false, &definition)
  setup = Setup.new(&definition)
  premium ? @setups.unshift(setup) : @setups.push(setup)
  setup
end

#should(what, &definition) ⇒ Object

Same as #asserts, except it uses the phrase “should” in the report output. Sometimes you feel like a nut, sometimes you don’t.

should("ensure expected") { "bar" }.equals("bar")

Parameters:

  • the (String, Symbol) —

    property being tested



87
88
89
 
# File 'lib/riot/context_helpers.rb', line 87

def should(what, &definition)
  new_assertion("should", what, &definition)
end

#teardown(&definition) ⇒ Object

Add a teardown block. You may define multiple of these as well.

teardown { Bombs.drop! }



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

def teardown(&definition)
  (@teardowns << Setup.new(&definition)).last
end