Module: RSpecial::Matchers

Included in:
Test::Matchers
Defined in:
lib/rspecial/matchers.rb

Overview

This module provides matchers for RSpec-compatiblity.

The set is not fully compataible, but provides most RSpec matchers. The most notable exlusion for the moment is the have matchers.

Compatability will improve with time. Feel obligated to submit a patch if you really need it. ;)

See Also:

Instance Method Summary collapse

Instance Method Details

#be_close(delta, criterion) ⇒ Object

Passes if expected and actual are nto equal within delta tolerance.

value.should be_close(delta, criterion)

Raises:

  • WithinAssay



42
43
44
 
# File 'lib/rspecial/matchers.rb', line 42

def be_close(delta, criterion)
  WithinAssay.assertor(criterion, delta)
end

#be_empty ⇒ Object

Passes if object is empty.

object.should be_empty

Raises:

  • EmptyAssay



52
53
54
 
# File 'lib/rspecial/matchers.rb', line 52

def be_empty
  EmptyAssay.assertor
end

#be_false ⇒ Object

Passed if object is false.

value.should be_false

Raises:

  • FalseAssay



88
89
90
 
# File 'lib/rspecial/matchers.rb', line 88

def be_false
  FalseAssay.assertor
end

#be_instance_of(cls) ⇒ Object Also known as: be_an_instance_of

Passes if object is an instance of class.

object.should be_instance_of(class)

Raises:

  • InstanceAssay



123
124
125
 
# File 'lib/rspecial/matchers.rb', line 123

def be_instance_of(cls)
  InstanceAssay.assertor(cls)
end

#be_kind_of(cls) ⇒ Object Also known as: be_a_kind_of, be_a, be_an

Pass if object is a kind of class.

object.should be_kind_of(class)

Raises:

  • KindAssay



136
137
138
 
# File 'lib/rspecial/matchers.rb', line 136

def be_kind_of(cls)
  KindAssay.assertor(cls)
end

#be_like(criterion) ⇒ Object

Passes if the expected and actual are alike.

object.should be_like(criterion)

There is no equivalant for this in RSpec, we simply add it here to cover all Assays available.

Raises:

  • LikeAssay



32
33
34
 
# File 'lib/rspecial/matchers.rb', line 32

def be_like(criterion)
  LikeAssay.assertor(criterion)
end

#be_nil ⇒ Object

Pass if object is nil.

value.should be_nil

Raises:

  • NilAssay



162
163
164
 
# File 'lib/rspecial/matchers.rb', line 162

def be_nil
  NilAssay.assertor
end

#be_true ⇒ Object

Passed if object is true.

object.should be_true

Raises:

  • TrueAssay



223
224
225
 
# File 'lib/rspecial/matchers.rb', line 223

def be_true
  TrueAssay.assertor
end

#eq(obj) ⇒ Object

Passes if actual == expected.

object.should eq(object)

Raises:

  • EqualAssay



112
113
114
 
# File 'lib/rspecial/matchers.rb', line 112

def eq(obj)
  EqualAssay.assertor(obj)
end

#eql(exp) ⇒ Object

Pass if two objects are equal using #eql? method.

object1.should eql(object2)

Raises:

  • EqualityAssay



198
199
200
 
# File 'lib/rspecial/matchers.rb', line 198

def eql(exp)
  EqualityAssay.assertor(exp)
end

#equal(obj) ⇒ Object Also known as: be_identical_to

Passes if actual is the same exact object as expected.

object.should be_identical_to(object)

Raises:

  • IdentityAssay



99
100
101
 
# File 'lib/rspecial/matchers.rb', line 99

def equal(obj)
  IdentityAssay.assertor(obj)
end

#equate_to(exp) ⇒ Object

Passes if expected == actual.

'MY STRING'.should equate_to('my string'.upcase)
'MY STRING'.should_not equate_to('another string')

This matcher is not supported by RSpec, but is added so that the EqualityAssay has an explict matcher available.

Raises:

  • EqualityAssay



66
67
68
 
# File 'lib/rspecial/matchers.rb', line 66

def equate_to(exp)
  EqualityAssay.assertor(exp)
end

#expect(target) ⇒ Object 



252
253
254
 
# File 'lib/rspecial/matchers.rb', line 252

def expect(target)
  Expect.new(target)
end

#have(n) ⇒ Object Also known as: have_exactly 



230
231
232
 
# File 'lib/rspecial/matchers.rb', line 230

def have(n)
  Have.new(n)
end

#have_at_least(n) ⇒ Object 



239
240
241
 
# File 'lib/rspecial/matchers.rb', line 239

def have_at_least(n)
  Have.new(n, :at_least)
end

#have_at_most(n) ⇒ Object 



246
247
248
 
# File 'lib/rspecial/matchers.rb', line 246

def have_at_most(n)
  Have.new(n, :at_most)
end

#match(regexp) ⇒ Object

Pass if object matches pattern using #=~ method.

object.should match(regexp)

Raises:

  • MatchAssay



151
152
153
 
# File 'lib/rspecial/matchers.rb', line 151

def match(regexp)
  MatchAssay.assertor(regexp)
end

#raise_error(exception = Exception) ⇒ Object

TODO:

Support for message matching ?

Pass if an exception is raised.

lambda { do_something_risky }.should raise_error
lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)

Raises:

  • RaiseAssay



176
177
178
 
# File 'lib/rspecial/matchers.rb', line 176

def raise_error(exception=Exception)
  RaiseAssay.assertor(exception)
end

#respond_to(method) ⇒ Object

Pass if object responds to message.

object.should respond_to(:method_name)

Raises:

  • RespondAssay



187
188
189
 
# File 'lib/rspecial/matchers.rb', line 187

def respond_to(method)
  RespondAssay.assertor(method)
end

#satisfy(&block) ⇒ Object

Passes if block is satisfied given target object as argument.

5.should satisfy{ |n| n > 3}

Raises:

  • ExecutionAssay



77
78
79
 
# File 'lib/rspecial/matchers.rb', line 77

def satisfy(&block)
  ExecutionAssay.assertor(&block)
end

#throw_symbol(sym = nil) ⇒ Object

TODO:

Support for throw argument. (Does RSpec even support this?)

Pass if procedure throws a specified symbol.

lambda { do_something_risky }.should throw_symbol
lambda { do_something_risky }.should throw_symbol(:that_was_risky)

Raises:

  • ThrowAssay



212
213
214
 
# File 'lib/rspecial/matchers.rb', line 212

def throw_symbol(sym=nil) #, arg=nil)
  ThrowAssay.assertor(sym)
end