Module: Wrong::Assert

Included in:
MiniTest::Unit::TestCase, Test::Unit::TestCase
Defined in:
lib/wrong/assert.rb,
lib/wrong/message/array_diff.rb,
lib/wrong/message/string_diff.rb,
lib/wrong/message/test_context.rb

Defined Under Namespace

Modules: ArrayDiff, StringDiff Classes: AssertionFailedError

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.disable_existing_assert_methods(the_class) ⇒ Object 



48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/wrong/assert.rb', line 48

def self.disable_existing_assert_methods(the_class)
  (the_class.public_instance_methods.
    map { |m| m.to_s }.
    select { |m| m =~ /^assert/ } - ["assert"]).each do |old_assert_method|
    the_class.class_eval(%{
      def #{old_assert_method}(*args)
        raise "#{old_assert_method} has been disabled.  When you use Wrong, it overrides 'assert', which most test frameworks have defined, and use internally."
      end
    })
  end
end

Instance Method Details

#assert(explanation = nil, depth = 0, &block) ⇒ Object 



24
25
26
 
# File 'lib/wrong/assert.rb', line 24

def assert(explanation = nil, depth = 0, &block)
  aver(:assert, explanation, depth, &block)
end

#catch_raise ⇒ Object 



32
33
34
35
36
37
38
39
40
 
# File 'lib/wrong/assert.rb', line 32

def catch_raise
  error = nil
  begin
    yield
  rescue Exception, RuntimeError => e
    error = e
  end
  error
end

#deny(explanation = nil, depth = 0, &block) ⇒ Object 



28
29
30
 
# File 'lib/wrong/assert.rb', line 28

def deny(explanation = nil, depth = 0, &block)
  aver(:deny, explanation, depth, &block)
end

#failure_class ⇒ Object 



20
21
22
 
# File 'lib/wrong/assert.rb', line 20

def failure_class
  AssertionFailedError
end

#failure_message(method_sym, block, predicate) ⇒ Object

todo: integrate with / use Chunk somehow?



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/wrong/message/test_context.rb', line 4

def failure_message(method_sym, block, predicate)
  message = super
  
  if predicate.is_a?(Predicated::Equal) && 
     predicate.left.is_a?(Enumerable) &&
     predicate.right.is_a?(Enumerable)
    
    
    
    diffs = Diff::LCS.sdiff(predicate.left, predicate.right)
    # left_offset = 0
    left_arr = []
    right_arr = []
    diff_arr = []
    
    diffs.each do |diff|
      left_elem = diff.old_element.nil? ? "nil" : diff.old_element.inspect
      right_elem = diff.new_element.nil? ? "nil" : diff.new_element.inspect
      
      max_length = [left_elem.length, right_elem.length].max
      left_arr << left_elem.ljust(max_length) unless diff.action == "+"
      right_arr << right_elem.ljust(max_length) unless diff.action == "-"
      diff_arr <<  (diff.action == "=" ? " ".ljust(max_length) : "^".ljust(max_length))
    end
    
    
    left_str, right_str, diff_str = ArrayDiff.compute_and_format(predicate.left, predicate.right)

    message << "\n\narray diff:\n"
    message << left_str + "\n"
    message << right_str + "\n"
    message << diff_str + "\n"
  end
  
  message
end