Class: MrubycTestCase

Inherits:
Object show all
Defined in:
lib/mrubyc-ext/mrubyc_test_case.rb,
lib/mrubyc_test_case/mrubyc_test_case.rb

Constant Summary collapse

@@description_locations = 
{}
@@added_method_names = 
{}
@@method_locations = 
{}

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(information, verbose = true) ⇒ MrubycTestCase

Returns a new instance of MrubycTestCase.



2
3
4
5
6
7
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 2

def initialize(information, verbose = true)
  @information = information
  $mock ||= Mock.new
  @puts_success_message = verbose
  @puts_failure_message = verbose
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args) ⇒ Object 



70
71
72
73
74
75
76
 
# File 'lib/mrubyc_test_case/mrubyc_test_case.rb', line 70

def method_missing(method_name, *args)
  case method_name
  when :stub, :mock
    location = caller_locations(1, 1)[0]
    Mrubyc::Test::Generator::Double.new(method_name, args[0], location)
  end
end

Class Method Details

.added_method_names ⇒ Object 



40
41
42
 
# File 'lib/mrubyc_test_case/mrubyc_test_case.rb', line 40

def added_method_names
  (@@added_method_names[self] ||= {}).keys
end

.description(text) ⇒ Object Also known as: desc 



109
110
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 109

def self.description(text)
end

.init_class_variables ⇒ Object 



44
45
46
47
48
 
# File 'lib/mrubyc_test_case/mrubyc_test_case.rb', line 44

def init_class_variables
  @@description_locations = {}
  @@method_locations = {}
  @@added_method_names = {}
end

.method_added(name) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/mrubyc_test_case/mrubyc_test_case.rb', line 23

def method_added(name)
  return false if %i(method_missing setup teardown).include?(name)
  # puts "method '#{self}' '#{name}' '#{name.class}' was added"
  added_method_names = (@@added_method_names[self] ||= {})
  stringified_name = name.to_s
  location = caller_locations(1, 1)[0]
  path = location.absolute_path || location.path
  line = location.lineno
  location = {
    method_name: stringified_name,
    path: File.expand_path(path),
    line: line,
  }
  add_method_location(location)
  added_method_names[stringified_name] = true
end

Instance Method Details

#assert(expression, message = nil) ⇒ Object 



84
85
86
87
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 84

def assert(expression, message = nil)
  assertion = :assert
  expression ? success(assertion, nil, expression) : failure(assertion, "!nil && !false", expression, message)
end

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



64
65
66
67
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 64

def assert_equal(expected, actual, message = nil)
  assertion = :assert_equal
  actual == expected ? success(assertion, expected, actual) : failure(assertion, expected, actual, message)
end

#assert_false(expression, message = nil) ⇒ Object 



94
95
96
97
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 94

def assert_false(expression, message = nil)
  assertion = :assert_false
  expression == false ? success(assertion, nil, expression) : failure(assertion, "false", expression, message)
end

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



99
100
101
102
103
104
105
106
107
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 99

def assert_in_delta(expected, actual, message = nil, delta = 0.001)
  assertion = :assert_in_delta
  dt = actual - expected
  if -delta <= dt && dt <= delta
    success(assertion, expected, actual)
  else
    failure(assertion, expected, actual, message)
  end
end

#assert_nil(expression, message = nil) ⇒ Object 



74
75
76
77
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 74

def assert_nil(expression, message = nil)
  assertion = :assert_not_nil
  expression == nil ? success(assertion, nil, expression) : failure(assertion, "nil", expression, message)
end

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



69
70
71
72
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 69

def assert_not_equal(expected, actual, message = nil)
  assertion = :assert_not_equal
  actual != expected ? success(assertion, expected, actual) : failure(assertion, expected, actual, message)
end

#assert_not_nil(expression, message = nil) ⇒ Object 



79
80
81
82
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 79

def assert_not_nil(expression, message = nil)
  assertion = :assert_not_nil
  expression != nil ? success(assertion, nil, expression) : failure(assertion, "!nil", expression, message)
end

#assert_raise(*errors, &block) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 45

def assert_raise(*errors, &block)
  assertion = :assert_raise
  e = nil
  begin
    block.call
  rescue => e
    errors.each do |error|
      if error == e.class || (error.class == e.class && error.message == e.message)
        success(assertion, errors, error)
        return
      end
    end
  end
  expected = errors.map {|error|
    error.message.length > 0 ? "#<#{error.class}: #{error.message}>" : "#{error.class}"
  }.join(" || ")
  failure(assertion, expected, (e || "[No error]"), "")
end

#assert_true(expression, message = nil) ⇒ Object 



89
90
91
92
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 89

def assert_true(expression, message = nil)
  assertion = :assert_true
  expression == true ? success(assertion, nil, expression) : failure(assertion, "true", expression, message)
end

#check_mock ⇒ Object 



120
121
122
123
124
125
126
127
128
129
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 120

def check_mock
  $mock.expected.keys.each do |key|
    $mock.actual[key] = 0 unless $mock.actual[key]
    if $mock.expected[key] > $mock.actual[key]
      failure(:mock, $mock.expected[key], $mock.actual[key], key.to_s + ' shoud have been called at least expected times')
    else
      success(:mock, $mock.expected[key], $mock.actual[key])
    end
  end
end

#failure(assertion, expected, actual, message, error = nil) ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 17

def failure(assertion, expected, actual, message, error = nil)
  $failures << {
    class_and_method: $current_class_and_method,
    path: @information[:path].to_s,
    line: @information[:line].to_s,
    description: @information[:description].to_s,
    message: message,
    assertion: assertion.to_s,
    expected: expected.to_ss,
    actual: actual.to_ss,
    error: error
  }
  if @puts_failure_message
    puts $colors[:failure] + '  ' + actual.to_ss + " (:" + assertion.to_s + ")" + $colors[:reset]
  else
    print $colors[:failure] + '.' + $colors[:reset]
  end
end

#pend ⇒ Object 



36
37
38
39
40
41
42
43
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 36

def pend
  $pendings << {
    class_and_method: $current_class_and_method,
    path: @information[:path].to_s,
    line: @information[:line].to_s,
  }
  print $colors[:pending] + '.' + $colors[:reset]
end

#setup ⇒ Object 



113
114
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 113

def setup
end

#stub(object) ⇒ Object 



117
118
119
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 117

def stub(object)
  object
end

#success(assertion, expected, actual) ⇒ Object 



9
10
11
12
13
14
15
16
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 9

def success(assertion, expected, actual)
  $success_count += 1
  if @puts_success_message
    puts $colors[:success] + '  ' + actual.to_ss + " (:" + assertion.to_s + ")" + $colors[:reset]
  else
    print $colors[:success] + '.' + $colors[:reset]
  end
end

#teardown ⇒ Object 



115
116
 
# File 'lib/mrubyc-ext/mrubyc_test_case.rb', line 115

def teardown
end