Module: TLDR::Assertions

Included in:
TLDR
Defined in:
lib/tldr/assertions.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.capture_io ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/tldr/assertions.rb', line 30

def self.capture_io
  captured_stdout, captured_stderr = StringIO.new, StringIO.new

  original_stdout, original_stderr = $stdout, $stderr
  $stdout, $stderr = captured_stdout, captured_stderr

  yield

  [captured_stdout.string, captured_stderr.string]
ensure
  $stdout = original_stdout
  $stderr = original_stderr
end

.diff(expected, actual) ⇒ Object 



26
27
28
 
# File 'lib/tldr/assertions.rb', line 26

def self.diff expected, actual
  SuperDiff::EqualityMatchers::Main.call(expected:, actual:)
end

.h(obj) ⇒ Object 



15
16
17
 
# File 'lib/tldr/assertions.rb', line 15

def self.h obj
  obj.pretty_inspect.chomp
end

.msg(message = nil, &default) ⇒ Object 



19
20
21
22
23
24
 
# File 'lib/tldr/assertions.rb', line 19

def self.msg message = nil, &default
  proc {
    message = message.call if Proc === message
    [message.to_s, default.call].reject(&:empty?).join("\n")
  }
end

Instance Method Details

#assert(bool, message = nil) ⇒ Object 



44
45
46
47
48
49
50
51
52
53
 
# File 'lib/tldr/assertions.rb', line 44

def assert bool, message = nil
  message ||= "Expected #{Assertions.h(bool)} to be truthy"

  if bool
    true
  else
    message = message.call if Proc === message
    fail Failure, message
  end
end

#assert_empty(obj, message = nil) ⇒ Object 



60
61
62
63
64
65
66
67
 
# File 'lib/tldr/assertions.rb', line 60

def assert_empty obj, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(obj)} to be empty"
  }

  assert_respond_to obj, :empty?
  assert obj.empty?, message
end

#assert_equal(expected, actual, message = nil) ⇒ Object 



75
76
77
78
 
# File 'lib/tldr/assertions.rb', line 75

def assert_equal expected, actual, message = nil
  message = Assertions.msg(message) { Assertions.diff(expected, actual) }
  assert expected == actual, message
end

#assert_in_delta(expected, actual, delta = 0.001, message = nil) ⇒ Object 



87
88
89
90
91
92
93
 
# File 'lib/tldr/assertions.rb', line 87

def assert_in_delta expected, actual, delta = 0.001, message = nil
  difference = (expected - actual).abs
  message = Assertions.msg(message) {
    "Expected |#{expected} - #{actual}| (#{difference}) to be within #{delta}"
  }
  assert delta >= difference, message
end

#assert_in_epsilon(expected, actual, epsilon = 0.001, message = nil) ⇒ Object 



103
104
105
 
# File 'lib/tldr/assertions.rb', line 103

def assert_in_epsilon expected, actual, epsilon = 0.001, message = nil
  assert_in_delta expected, actual, [expected.abs, actual.abs].min * epsilon, message
end

#assert_includes(actual, expected, message = nil) ⇒ Object 



111
112
113
114
115
116
117
 
# File 'lib/tldr/assertions.rb', line 111

def assert_includes actual, expected, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(actual)} to include #{Assertions.h(expected)}"
  }
  assert_respond_to actual, :include?
  assert actual.include?(expected), message
end

#assert_instance_of(expected, actual, message = nil) ⇒ Object 



127
128
129
130
131
132
 
# File 'lib/tldr/assertions.rb', line 127

def assert_instance_of expected, actual, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(actual)} to be an instance of #{expected}, not #{actual.class}"
  }
  assert actual.instance_of?(expected), message
end

#assert_kind_of(expected, actual, message = nil) ⇒ Object 



141
142
143
144
145
146
 
# File 'lib/tldr/assertions.rb', line 141

def assert_kind_of expected, actual, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(actual)} to be a kind of #{expected}, not #{actual.class}"
  }
  assert actual.kind_of?(expected), message # standard:disable Style/ClassCheck
end

#assert_match(matcher, actual, message = nil) ⇒ Object 



155
156
157
158
159
160
161
162
163
 
# File 'lib/tldr/assertions.rb', line 155

def assert_match matcher, actual, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(actual)} to match #{Assertions.h(matcher)}"
  }
  assert_respond_to matcher, :=~
  matcher = Regexp.new(Regexp.escape(matcher)) if String === matcher
  assert matcher =~ actual, message
  Regexp.last_match
end

#assert_nil(obj, message = nil) ⇒ Object 



173
174
175
176
177
178
179
 
# File 'lib/tldr/assertions.rb', line 173

def assert_nil obj, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(obj)} to be nil"
  }

  assert obj.nil?, message
end

#assert_operator(left_operand, operator, right_operand, message = nil) ⇒ Object 



189
190
191
192
193
194
 
# File 'lib/tldr/assertions.rb', line 189

def assert_operator left_operand, operator, right_operand, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(left_operand)} to be #{operator} #{Assertions.h(right_operand)}"
  }
  assert left_operand.__send__(operator, right_operand), message
end

#assert_output(expected_stdout, expected_stderr, message = nil, &block) ⇒ Object 



203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/tldr/assertions.rb', line 203

def assert_output expected_stdout, expected_stderr, message = nil, &block
  assert_block "assert_output requires a block to capture output" unless block

  actual_stdout, actual_stderr = Assertions.capture_io(&block)

  if Regexp === expected_stderr
    assert_match expected_stderr, actual_stderr, "In stderr"
  elsif !expected_stderr.nil?
    assert_equal expected_stderr, actual_stderr, "In stderr"
  end

  if Regexp === expected_stdout
    assert_match expected_stdout, actual_stdout, "In stdout"
  elsif !expected_stdout.nil?
    assert_equal expected_stdout, actual_stdout, "In stdout"
  end
end

#assert_path_exists(path, message = nil) ⇒ Object 



221
222
223
224
225
226
227
 
# File 'lib/tldr/assertions.rb', line 221

def assert_path_exists path, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(path)} to exist"
  }

  assert File.exist?(path), message
end

#assert_pattern(message = nil) ⇒ Object 



237
238
239
240
241
242
243
244
245
 
# File 'lib/tldr/assertions.rb', line 237

def assert_pattern message = nil
  assert false, "assert_pattern requires a block to capture errors" unless block_given?

  begin
    yield
  rescue NoMatchingPatternError => e
    assert false, Assertions.msg(message) { "Expected pattern to match, but NoMatchingPatternError was raised: #{e.message}" }
  end
end

#assert_predicate(obj, method, message = nil) ⇒ Object 



257
258
259
260
261
262
263
 
# File 'lib/tldr/assertions.rb', line 257

def assert_predicate obj, method, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(obj)} to be #{method}"
  }

  assert obj.send(method), message
end

#assert_raises(*exp) ⇒ Object 



273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
 
# File 'lib/tldr/assertions.rb', line 273

def assert_raises *exp
  assert false, "assert_raises requires a block to capture errors" unless block_given?

  message = exp.pop if String === exp.last
  exp << StandardError if exp.empty?

  begin
    yield
  rescue Failure, Skip
    raise
  rescue *exp => e
    return e
  rescue SignalException, SystemExit
    raise
  rescue Exception => e # standard:disable Lint/RescueException
    assert false, Assertions.msg(message) {
      [
        "#{Assertions.h(exp)} exception expected, not",
        "Class: <#{e.class}>",
        "Message: <#{e.message.inspect}>",
        "---Backtrace---",
        TLDR.filter_backtrace(e.backtrace).join("\n"),
        "---------------"
      ].compact.join("\n")
    }
  end

  exp = exp.first if exp.size == 1

  assert false, "#{message}#{Assertions.h(exp)} expected but nothing was raised"
end

#assert_respond_to(obj, method, message = nil) ⇒ Object 



305
306
307
308
309
310
311
 
# File 'lib/tldr/assertions.rb', line 305

def assert_respond_to obj, method, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(obj)} (#{obj.class}) to respond to #{Assertions.h(method)}"
  }

  assert obj.respond_to?(method), message
end

#assert_same(expected, actual, message = nil) ⇒ Object 



321
322
323
324
325
326
327
328
329
330
 
# File 'lib/tldr/assertions.rb', line 321

def assert_same expected, actual, message = nil
  message = Assertions.msg(message) {
    "      Expected objects to be the same, but weren't\n      Expected: \#{Assertions.h(expected)} (oid=\#{expected.object_id})\n      Actual: \#{Assertions.h(actual)} (oid=\#{actual.object_id})\n    MSG\n  }\n  assert expected.equal?(actual), message\nend\n"

#assert_silent ⇒ Object 



339
340
341
342
343
 
# File 'lib/tldr/assertions.rb', line 339

def assert_silent
  assert_output "", "" do
    yield
  end
end

#assert_throws(expected, message = nil) ⇒ Object 



345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
 
# File 'lib/tldr/assertions.rb', line 345

def assert_throws expected, message = nil
  punchline = nil
  caught = true
  value = catch(expected) do
    begin
      yield
    rescue ArgumentError => e
      raise e unless e.message.include?("uncaught throw")
      punchline = ", not #{e.message.split(" ").last}"
    end
    caught = false
  end

  assert caught, Assertions.msg(message) {
    "Expected #{Assertions.h(expected)} to have been thrown#{punchline}"
  }
  value
end

#refute(test, message = nil) ⇒ Object 



55
56
57
58
 
# File 'lib/tldr/assertions.rb', line 55

def refute test, message = nil
  message ||= Assertions.msg(message) { "Expected #{Assertions.h(test)} to not be truthy" }
  assert !test, message
end

#refute_empty(obj, message = nil) ⇒ Object 



69
70
71
72
73
 
# File 'lib/tldr/assertions.rb', line 69

def refute_empty obj, message = nil
  message = Assertions.msg(message) { "Expected #{Assertions.h(obj)} to not be empty" }
  assert_respond_to obj, :empty?
  refute obj.empty?, message
end

#refute_equal(expected, actual, message = nil) ⇒ Object 



80
81
82
83
84
85
 
# File 'lib/tldr/assertions.rb', line 80

def refute_equal expected, actual, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(actual)} to not be equal to #{Assertions.h(expected)}"
  }
  refute expected == actual, message
end

#refute_in_delta(expected, actual, delta = 0.001, message = nil) ⇒ Object 



95
96
97
98
99
100
101
 
# File 'lib/tldr/assertions.rb', line 95

def refute_in_delta expected, actual, delta = 0.001, message = nil
  difference = (expected - actual).abs
  message = Assertions.msg(message) {
    "Expected |#{expected} - #{actual}| (#{difference}) to not be within #{delta}"
  }
  refute delta >= difference, message
end

#refute_in_epsilon(expected, actual, epsilon = 0.001, msg = nil) ⇒ Object 



107
108
109
 
# File 'lib/tldr/assertions.rb', line 107

def refute_in_epsilon expected, actual, epsilon = 0.001, msg = nil
  refute_in_delta expected, actual, expected * epsilon, msg
end

#refute_includes(actual, expected, message = nil) ⇒ Object 



119
120
121
122
123
124
125
 
# File 'lib/tldr/assertions.rb', line 119

def refute_includes actual, expected, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(actual)} to not include #{Assertions.h(expected)}"
  }
  assert_respond_to actual, :include?
  refute actual.include?(expected), message
end

#refute_instance_of(expected, actual, message = nil) ⇒ Object 



134
135
136
137
138
139
 
# File 'lib/tldr/assertions.rb', line 134

def refute_instance_of expected, actual, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(actual)} to not be an instance of #{expected}"
  }
  refute actual.instance_of?(expected), message
end

#refute_kind_of(expected, actual, message = nil) ⇒ Object 



148
149
150
151
152
153
 
# File 'lib/tldr/assertions.rb', line 148

def refute_kind_of expected, actual, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(actual)} to not be a kind of #{expected}"
  }
  refute actual.kind_of?(expected), message # standard:disable Style/ClassCheck
end

#refute_match(matcher, actual, message = nil) ⇒ Object 



165
166
167
168
169
170
171
 
# File 'lib/tldr/assertions.rb', line 165

def refute_match matcher, actual, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(actual)} to not match #{Assertions.h(matcher)}"
  }
  assert_respond_to matcher, :=~
  refute matcher =~ actual, message
end

#refute_nil(obj, message = nil) ⇒ Object 



181
182
183
184
185
186
187
 
# File 'lib/tldr/assertions.rb', line 181

def refute_nil obj, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(obj)} to not be nil"
  }

  refute obj.nil?, message
end

#refute_operator(left_operand, operator, right_operand, message = nil) ⇒ Object 



196
197
198
199
200
201
 
# File 'lib/tldr/assertions.rb', line 196

def refute_operator left_operand, operator, right_operand, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(left_operand)} to not be #{operator} #{Assertions.h(right_operand)}"
  }
  refute left_operand.__send__(operator, right_operand), message
end

#refute_path_exists(path, message = nil) ⇒ Object 



229
230
231
232
233
234
235
 
# File 'lib/tldr/assertions.rb', line 229

def refute_path_exists path, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(path)} to not exist"
  }

  refute File.exist?(path), message
end

#refute_pattern(message = nil) ⇒ Object 



247
248
249
250
251
252
253
254
255
 
# File 'lib/tldr/assertions.rb', line 247

def refute_pattern message = nil
  assert false, "assert_pattern requires a block to capture errors" unless block_given?

  begin
    yield
    refute true, Assertions.msg(message) { "Expected pattern not to match, but NoMatchingPatternError was not raised" }
  rescue NoMatchingPatternError
  end
end

#refute_predicate(obj, method, message = nil) ⇒ Object 



265
266
267
268
269
270
271
 
# File 'lib/tldr/assertions.rb', line 265

def refute_predicate obj, method, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(obj)} to not be #{method}"
  }

  refute obj.send(method), message
end

#refute_respond_to(obj, method, message = nil) ⇒ Object 



313
314
315
316
317
318
319
 
# File 'lib/tldr/assertions.rb', line 313

def refute_respond_to obj, method, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(obj)} (#{obj.class}) to not respond to #{Assertions.h(method)}"
  }

  refute obj.respond_to?(method), message
end

#refute_same(expected, actual, message = nil) ⇒ Object 



332
333
334
335
336
337
 
# File 'lib/tldr/assertions.rb', line 332

def refute_same expected, actual, message = nil
  message = Assertions.msg(message) {
    "Expected #{Assertions.h(expected)} (oid=#{expected.object_id}) to not be the same as #{Assertions.h(actual)} (oid=#{actual.object_id})"
  }
  refute expected.equal?(actual), message
end