Class: Loupe::Expectation

Inherits:
Object
  • Object
show all
Defined in:
lib/loupe/expectation.rb

Overview

Expectation

This class is responsible for instantiating a target so that expectations can be invoked on it.

Example:

expectation = Expectation.new(target, test)
expectation.to_be_empty

The goal of ths class is so that expectations can be written in such a way that they read in plain English. E.g.: expect(something).to_be_truthy

See Also:

  • Test#expect

Defined Under Namespace

Classes: ExpectationFailed

Instance Method Summary collapse

Constructor Details

#initialize(target, test) ⇒ Loupe::Expectation

Parameters:



69
70
71
72
73
 
# File 'lib/loupe/expectation.rb', line 69

def initialize(target, test)
  @target = target
  @color = test.color
  @test = test
end

Instance Method Details

#to_be(predicate) ⇒ Loupe::Expectation

expect(target).to_be(predicate)

Expects ‘target` to return `true` for a given `predicate`. In this expectation, `predicate` is a method name and the expectation will pass if invoking the method on `target` returns `true`.

Example:

Verify if the result of a calculation is an odd number. The `target` is the calculation result
and the `predicate` is the method `odd?`.

calculation_result = a_complex_math_operation
expect(calculation_result).to_be(:odd?)

Parameters:

  • predicate (String, Symbol)

Returns:



281
282
283
284
285
286
 
# File 'lib/loupe/expectation.rb', line 281

def to_be(predicate)
  assert(
    @target.public_send(predicate),
    "Expected #{@color.p(@target.inspect, :red)} to be #{@color.p(predicate, :green)}."
  )
end

#to_be_a_kind_of(klass) ⇒ Loupe::Expectation

expect(target).to_be_a_kind_of(klass)

Expects ‘target` to be a kind of `klass`. Which means that if `target.is_a?(klass)` returns true, the expectation will pass.

Parameters:

  • klass (Class)

Returns:



246
247
248
249
250
251
 
# File 'lib/loupe/expectation.rb', line 246

def to_be_a_kind_of(klass)
  failure_message = "Expected #{@color.p(@target.inspect, :red)} to be a kind of " \
                    "#{@color.p(klass, :green)}, not #{@color.p(@target.inspect.class, :red)}."

  assert(@target.is_a?(klass), failure_message)
end

#to_be_an_existing_path ⇒ Loupe::Expectation

expect(target).to_be_an_existing_path

Expects ‘target` to be an existing path in the file system. That means, invoking `File.exist?(target)` must return `true` for this expectation to pass.

Returns:



384
385
386
 
# File 'lib/loupe/expectation.rb', line 384

def to_be_an_existing_path
  assert(File.exist?(@target), "Expected path '#{@color.p(@target.inspect, :red)}' to exist.")
end

#to_be_an_instance_of(klass) ⇒ Loupe::Expectation

expect(target).to_be_an_instance_of(klass)

Expects ‘target` to be an instance of `klass`. For example, “ruby is awesome” is an instance of `String` and will pass the expectation.

Parameters:

  • klass (Class)

Returns:



218
219
220
221
222
223
 
# File 'lib/loupe/expectation.rb', line 218

def to_be_an_instance_of(klass)
  failure_message = "Expected #{@color.p(@target.inspect, :red)} to be an instance " \
                    "of #{@color.p(klass, :green)}, not #{@color.p(@target.inspect.class, :red)}."

  assert(@target.instance_of?(klass), failure_message)
end

#to_be_empty ⇒ Loupe::Expectation

expect(target).to_be_empty

Expects ‘target` to be empty. Which means invoking `empty?` must return `true`.

Returns:



126
127
128
 
# File 'lib/loupe/expectation.rb', line 126

def to_be_empty
  assert(@target.empty?, "Expected #{@color.p(@target.inspect, :red)} to be empty.")
end

#to_be_equal_to(value) ⇒ Loupe::Expectation

expect(target).to_be_equal_to(value)

Expects ‘target` to be equal to `value`. Compares if the objects are equal in terms of values but not if the objects are the exact same instance. For comparing identity, use #to_be_the_same_as.

Parameters:

  • value (#==)

Returns:



100
101
102
103
104
105
 
# File 'lib/loupe/expectation.rb', line 100

def to_be_equal_to(value)
  assert(
    @target == value,
    "Expected #{@color.p(@target.inspect, :red)} to be equal to #{@color.p(value.inspect, :green)}."
  )
end

#to_be_falsey ⇒ Loupe::Expectation

expect(target).to_be_falsey

Expects ‘target` to be a falsey value (`nil` or `false`).

Returns:



89
90
91
 
# File 'lib/loupe/expectation.rb', line 89

def to_be_falsey
  assert(!@target, "Expected #{@color.p(@target.inspect, :red)} to be #{@color.p('falsey', :green)}.")
end

#to_be_in_delta_of(value, delta = 0.001) ⇒ Loupe::Expectation

expect(target).to_be_in_delta_of(value, delta = 0.001)

Expects ‘target` to be within `delta` of `value`. This means that the absolute difference between `target` and `value` cannot be bigger than `delta`.

Example:

expect(5.0).to_be_in_delta_of(5.1, 0.2)

Parameters:

  • value (Numeric)
  • delta (Numeric) (defaults to: 0.001)

Returns:



409
410
411
412
413
414
415
416
 
# File 'lib/loupe/expectation.rb', line 409

def to_be_in_delta_of(value, delta = 0.001)
  difference = (@target - value).abs

  failure_message = "Expected |#{@target} - #{value}| " \
                    "(#{@color.p(difference, :red)}) to be <= #{@color.p(delta, :green)}."

  assert(delta >= difference, failure_message)
end

#to_be_in_epsilon_of(value, epsilon = 0.001) ⇒ Loupe::Expectation

expect(target).to_be_in_epsilon_of(value, epsilon = 0.001)

Expects ‘target` to be within `epsilon` times the smallest absolute value between `value` and `target`. This expectation simply invokes #to_be_in_delta_of, where the `delta` is `epsilon * [@target.abs, value.abs].min`.

Example:

The minimum absolute value between 5.0 and 5.1 is equal to 5.0.
The delta is equal to 5.0 * 0.1, which is 0.5.
The absolute difference 5.1 - 5.0 is 0.1.
0.1 is smaller than 0.5, therefore the expectation passes.

expect(5.0).to_be_in_epsilon_of(5.1, 0.1)

Parameters:

  • value (Numeric)
  • epsilon (Numeric) (defaults to: 0.001)

Returns:



455
456
457
 
# File 'lib/loupe/expectation.rb', line 455

def to_be_in_epsilon_of(value, epsilon = 0.001)
  to_be_in_delta_of(value, [@target.abs, value.abs].min * epsilon)
end

#to_be_nil ⇒ Loupe::Expectation

expect(target).to_be_nil

Expects ‘target` to be `nil`.

Returns:



198
199
200
 
# File 'lib/loupe/expectation.rb', line 198

def to_be_nil
  assert(@target.nil?, "Expected #{@color.p(@target.inspect, :red)} to be nil.")
end

#to_be_the_same_as(object) ⇒ Loupe::Expectation

expect(target).to_be_the_same_as(object)

Expects ‘target` to be the same as `object`. This means, `target` and `object` must be the exact same object, with the same `object_id`.

Parameters:

  • object (BasicObject)

Returns:



354
355
356
357
358
359
 
# File 'lib/loupe/expectation.rb', line 354

def to_be_the_same_as(object)
  failure_message = "Expected #{@color.p(@target.inspect, :red)} (#{@color.p(@target.inspect.object_id, :red)}) " \
                    "to be the same as #{@color.p(object, :green)} (#{@color.p(object.object_id, :green)})."

  assert(@target.equal?(object), failure_message)
end

#to_be_truthy ⇒ Loupe::Expectation

expect(target).to_be_truthy

Expects ‘target` to be a truthy value (not `nil` or `false`).

Returns:



80
81
82
 
# File 'lib/loupe/expectation.rb', line 80

def to_be_truthy
  assert(@target, "Expected #{@color.p(@target.inspect, :red)} to be #{@color.p('truthy', :green)}.")
end

#to_include(object) ⇒ Loupe::Expectation

expect(target).to_include(object)

Expects ‘target` to include `object`. In this expectation, `target` is typically a collection or another object that responds to `include?`. The expectation passes if `target` includes `object`.

Parameters:

  • object (BasicObject)

Returns:



172
173
174
175
176
177
 
# File 'lib/loupe/expectation.rb', line 172

def to_include(object)
  assert(
    @target.include?(object),
    "Expected #{@color.p(@target.inspect, :red)} to include #{@color.p(object, :green)}."
  )
end

#to_match(object) ⇒ Loupe::Expectation

expect(target).to_match(object)

Expects ‘target` to match `object`. In this expectation, `target` is a matcher (string or a regex) that must match `object`. The matcher needs to respond to `=~` and needs to return `true` when it is invoked with `object`.

Example:

expect(/ruby .*/).to_match("ruby is awesome")
expect("awesome").to_match("ruby is awesome")

Parameters:

  • object (BasicObject)

Returns:



321
322
323
324
325
326
 
# File 'lib/loupe/expectation.rb', line 321

def to_match(object)
  to_respond_to(:=~)

  @target = Regexp.new(Regexp.escape(@target)) if @target.is_a?(String)
  assert(@target =~ object, "Expected #{@color.p(@target.inspect, :red)} to match #{@color.p(object, :green)}.")
end

#to_not_be(predicate) ⇒ Loupe::Expectation

expect(target).to_not_be(predicate)

Expects ‘target` to return `false` for a given `predicate`. In this expectation, `predicate` is a method name and the expectation will pass if invoking the method on `target` returns `false`.

Example:

Verify if the result of a calculation is not zero. The `target` is the calculation result
and the `predicate` is the method `zero?`.

calculation_result = a_complex_math_operation
expect(calculation_result).to_not_be(:zero?)

Parameters:

  • predicate (String, Symbol)

Returns:



302
303
304
305
306
307
 
# File 'lib/loupe/expectation.rb', line 302

def to_not_be(predicate)
  assert(
    !@target.public_send(predicate),
    "Expected #{@color.p(@target.inspect, :red)} to not be #{@color.p(predicate, :green)}."
  )
end

#to_not_be_a_kind_of(klass) ⇒ Loupe::Expectation

expect(target).to_not_be_a_kind_of(klass)

Expects ‘target` to not be a kind of `klass`. Which means that if `target.is_a?(klass)` returns false, the expectation will pass.

Parameters:

  • klass (Class)

Returns:



260
261
262
263
264
265
 
# File 'lib/loupe/expectation.rb', line 260

def to_not_be_a_kind_of(klass)
  failure_message = "Expected #{@color.p(@target.inspect, :red)} to not be a kind of " \
                    "#{@color.p(klass, :green)}, not #{@color.p(@target.inspect.class, :red)}."

  assert(!@target.is_a?(klass), failure_message)
end

#to_not_be_an_existing_path ⇒ Loupe::Expectation

expect(target).to_not_be_an_existing_path

Expects ‘target` to not be an existing path in the file system. That means, invoking `File.exist?(target)` must return `false` for this expectation to pass.

Returns:



394
395
396
 
# File 'lib/loupe/expectation.rb', line 394

def to_not_be_an_existing_path
  assert(!File.exist?(@target), "Expected path '#{@color.p(@target.inspect, :red)}' to not exist.")
end

#to_not_be_an_instance_of(klass) ⇒ Loupe::Expectation

expect(target).to_not_be_an_instance_of(klass)

Expects ‘target` to not be an instance of `klass`. For example, “ruby is awesome” is not an instance of `Integer` and will not pass the expectation.

Parameters:

  • klass (Class)

Returns:



232
233
234
235
236
237
 
# File 'lib/loupe/expectation.rb', line 232

def to_not_be_an_instance_of(klass)
  failure_message = "Expected #{@color.p(@target.inspect, :red)} to not be an instance of " \
                    "#{@color.p(klass, :green)}, not #{@color.p(@target.inspect.class, :red)}."

  assert(!@target.instance_of?(klass), failure_message)
end

#to_not_be_empty ⇒ Loupe::Expectation

expect(target).to_not_be_empty

Expects ‘target` to not be empty. Which means invoking `empty?` must return `false`.

Returns:



135
136
137
 
# File 'lib/loupe/expectation.rb', line 135

def to_not_be_empty
  assert(!@target.empty?, "Expected #{@color.p(@target.inspect, :red)} to not be empty.")
end

#to_not_be_equal_to(value) ⇒ Loupe::Expectation

expect(target).to_not_be_equal_to(value)

Expects ‘target` to not be equal to `value`. Compares if the objects are different in terms of values, but not if the objects are the different instances. For comparing identity, use #to_not_be_the_same_as.

Parameters:

  • value (#!=)

Returns:



114
115
116
117
118
119
 
# File 'lib/loupe/expectation.rb', line 114

def to_not_be_equal_to(value)
  assert(
    @target != value,
    "Expected #{@color.p(@target.inspect, :red)} to not be equal to #{@color.p(value.inspect, :green)}."
  )
end

#to_not_be_in_delta_of(value, delta = 0.001) ⇒ Loupe::Expectation

expect(target).to_not_be_in_delta_of(value, delta = 0.001)

Expects ‘target` to not be within `delta` of `value`. This means that the absolute difference between `target` and `value` must be bigger than `delta`.

Example:

expect(5.0).to_not_be_in_delta_of(5.1, 0.01)

Parameters:

  • value (Numeric)
  • delta (Numeric) (defaults to: 0.001)

Returns:



429
430
431
432
433
434
435
436
 
# File 'lib/loupe/expectation.rb', line 429

def to_not_be_in_delta_of(value, delta = 0.001)
  difference = (@target - value).abs

  failure_message = "Expected |#{@target} - #{value}| " \
                    "(#{@color.p(difference, :red)}) to not be <= #{@color.p(delta, :green)}."

  assert(delta <= difference, failure_message)
end

#to_not_be_in_epsilon_of(value, epsilon = 0.001) ⇒ Loupe::Expectation

expect(target).to_not_be_in_epsilon_of(value, epsilon = 0.001)

Expects ‘target` to not be within `epsilon` times the smallest absolute value between `value` and `target`. This expectation simply invokes #to_not_be_in_delta_of, where the `delta` is `epsilon * [@target.abs, value.abs].min`.

Example:

The minimum absolute value between 5.0 and 5.1 is equal to 5.0.
The delta is equal to 5.0 * 0.01, which is 0.05.
The absolute difference 5.1 - 5.0 is 0.1.
0.1 is not smaller than 0.05, therefore the expectation passes.

expect(5.0).to_not_be_in_epsilon_of(5.1, 0.01)

Parameters:

  • value (Numeric)
  • epsilon (Numeric) (defaults to: 0.001)

Returns:



476
477
478
 
# File 'lib/loupe/expectation.rb', line 476

def to_not_be_in_epsilon_of(value, epsilon = 0.001)
  to_not_be_in_delta_of(value, [@target.abs, value.abs].min * epsilon)
end

#to_not_be_nil ⇒ Loupe::Expectation

expect(target).to_not_be_nil

Expects ‘target` not to be `nil`.

Returns:



207
208
209
 
# File 'lib/loupe/expectation.rb', line 207

def to_not_be_nil
  assert(!@target.nil?, "Expected #{@color.p(@target.inspect, :red)} to not be nil.")
end

#to_not_be_the_same_as(object) ⇒ Loupe::Expectation

expect(target).to_not_be_the_same_as(object)

Expects ‘target` to not be the same as `object`. This means, `target` and `object` are not the exact same object with the same `object_id`.

Note: this is an identity comparison. If the values of both objects are the same, but the object IDs are different, this expectation will pass.

Parameters:

  • object (BasicObject)

Returns:



371
372
373
374
375
376
 
# File 'lib/loupe/expectation.rb', line 371

def to_not_be_the_same_as(object)
  failure_message = "Expected #{@color.p(@target.inspect, :red)} (#{@color.p(@target.inspect.object_id, :red)}) " \
                    "to not be the same as #{@color.p(object, :green)} (#{@color.p(object.object_id, :green)})."

  assert(!@target.equal?(object), failure_message)
end

#to_not_include(object) ⇒ Loupe::Expectation

expect(target).to_not_include(object)

Expects ‘target` to not include `object`. In this expectation, `target` is typically a collection or another object that responds to `include?`. The expectation passes if `target` does not include `object`.

Parameters:

  • object (BasicObject)

Returns:



186
187
188
189
190
191
 
# File 'lib/loupe/expectation.rb', line 186

def to_not_include(object)
  assert(
    !@target.include?(object),
    "Expected #{@color.p(@target.inspect, :red)} to not include #{@color.p(object, :green)}."
  )
end

#to_not_match(object) ⇒ Loupe::Expectation

expect(target).to_not_match(object)

Expects ‘target` to not match `object`. In this expectation, `target` is a matcher (string or a regex) that must not match `object`. The matcher needs to respond to `=~` and needs to return `false` when it is invoked with `object`.

Example:

expect(/python .*/).to_not_match("ruby is awesome")
expect("terrible").to_not_match("ruby is awesome")

Parameters:

  • object (BasicObject)

Returns:



340
341
342
343
344
345
 
# File 'lib/loupe/expectation.rb', line 340

def to_not_match(object)
  to_respond_to(:=~)

  @target = Regexp.new(Regexp.escape(@target)) if @target.is_a?(String)
  assert(@target !~ object, "Expected #{@color.p(@target.inspect, :red)} to not match #{@color.p(object, :green)}.")
end

#to_not_respond_to(method) ⇒ Loupe::Expectation

expect(target).to_not_respond_to(method)

Expects ‘target` to not respond to `method`. This expectation passes if `method` does not exist in `target`.

Parameters:

  • method (String, Symbol)

Returns:



158
159
160
161
162
163
 
# File 'lib/loupe/expectation.rb', line 158

def to_not_respond_to(method)
  assert(
    !@target.respond_to?(method.to_sym),
    "Expected #{@color.p(@target.inspect, :red)} to not respond to #{@color.p(method, :green)}."
  )
end

#to_not_satisfy_operator(operator, other) ⇒ Loupe::Expectation

expect(target).to_not_satisfy_operator(operator, other)

Expects ‘target` to return false when the `operator` is applied on `other`. This expectation is used to verify operations between two objects.

Example:

expect(5.0).to_not_satisfy_operator(:<, 4.9)

Parameters:

  • operator (Symbol)
  • other (BasicObject)

Returns:



513
514
515
516
517
518
519
520
 
# File 'lib/loupe/expectation.rb', line 513

def to_not_satisfy_operator(operator, other)
  return to_not_be(operator) unless other

  failure_message = "Expected #{@color.p(@target.inspect, :red)} to not be #{operator}" \
                    " #{@color.p(other, :green)}."

  assert(!@target.public_send(operator, other), failure_message)
end

#to_respond_to(method) ⇒ Loupe::Expectation

expect(target).to_respond_to(method)

Expects ‘target` to respond to `method`. This expectation passes if `method` exists in `target`.

Parameters:

  • method (String, Symbol)

Returns:



145
146
147
148
149
150
 
# File 'lib/loupe/expectation.rb', line 145

def to_respond_to(method)
  assert(
    @target.respond_to?(method.to_sym),
    "Expected #{@color.p(@target.inspect, :red)} to respond to #{@color.p(method, :green)}."
  )
end

#to_satisfy_operator(operator, other) ⇒ Loupe::Expectation

expect(target).to_satisfy_operator(operator, other)

Expects ‘target` to return true when the `operator` is applied on `other`. This expectation is used to verify operations between two objects.

Example:

expect(5.0).to_satisfy_operator(:>, 4.9)

Parameters:

  • operator (Symbol)
  • other (BasicObject)

Returns:



492
493
494
495
496
497
498
499
 
# File 'lib/loupe/expectation.rb', line 492

def to_satisfy_operator(operator, other)
  return to_be(operator) unless other

  failure_message = "Expected #{@color.p(@target.inspect, :red)} to be #{operator}" \
                    " #{@color.p(other, :green)}."

  assert(@target.public_send(operator, other), failure_message)
end