Module: TTYtest::Matchers

Included in:
Capture
Defined in:
lib/ttytest/matchers.rb

Overview

Assertions for ttytest2.

Constant Summary collapse

METHODS = 
public_instance_methods

Instance Method Summary collapse

Instance Method Details

#assert_contents(expected) ⇒ Object Also known as: assert_matches, assert_screen

Asserts the full contents of the terminal

Parameters:

  • expected (String) —

    the full expected contents of the terminal. Trailing whitespace on each line is ignored

Raises:

  • (MatchError) —

    if the terminal doesn’t match the expected content



176
177
178
179
180
181
182
183
 
# File 'lib/ttytest/matchers.rb', line 176

def assert_contents(expected)
  matched, diff = matched(expected, rows)

  return if matched

  raise MatchError,
        "screen did not match expected content:\n--- expected\n+++ actual\n#{diff.join("\n")}"
end

#assert_contents_at(row_start, row_end, expected) ⇒ Object Also known as: assert_matches_at, assert_rows

Asserts the contents of the terminal at specified rows

Parameters:

  • expected (String) —

    the expected contents of the terminal at specified rows. Trailing whitespace on each line is ignored

Raises:

  • (MatchError) —

    if the terminal doesn’t match the expected content



190
191
192
193
194
195
196
197
198
199
 
# File 'lib/ttytest/matchers.rb', line 190

def assert_contents_at(row_start, row_end, expected)
  row_end += 1 if row_end.zero?

  matched, diff = matched(expected, rows.slice(row_start, row_end))

  return if matched

  raise MatchError,
        "screen did not match expected content:\n--- expected\n+++ actual\n#{diff.join("\n")}"
end

#assert_cursor_hidden ⇒ Object

Raises:



149
150
151
152
153
 
# File 'lib/ttytest/matchers.rb', line 149

def assert_cursor_hidden
  return if cursor_hidden?

  raise MatchError, "expected cursor to be hidden was visible\nEntire screen:\n#{self}"
end

#assert_cursor_position(x, y) ⇒ Object

Asserts that the cursor is in the expected position

Parameters:

  • x (Integer) —

    cursor x (row) position, starting from 0

  • y (Integer) —

    cursor y (column) position, starting from 0

Raises:

  • (MatchError) —

    if the cursor position doesn’t match



131
132
133
134
135
136
137
138
139
 
# File 'lib/ttytest/matchers.rb', line 131

def assert_cursor_position(x, y)
  expected = [x, y]
  actual = [cursor_x, cursor_y]

  return if actual == expected

  raise MatchError,
        "expected cursor to be at #{expected.inspect} but was at #{actual.inspect}\nEntire screen:\n#{self}"
end

#assert_cursor_visible ⇒ Object

Raises:



142
143
144
145
146
 
# File 'lib/ttytest/matchers.rb', line 142

def assert_cursor_visible
  return if cursor_visible?

  raise MatchError, "expected cursor to be visible was hidden\nEntire screen:\n#{self}"
end

#assert_last_row(expected) ⇒ Object 



20
21
 
# File 'lib/ttytest/matchers.rb', line 20

def assert_last_row(expected)
end

#assert_row(row_number, expected) ⇒ Object

Asserts the contents of a single row match the value expected

Parameters:

  • row_number (Integer) —

    the row (starting from 0) to test against

  • expected (String) —

    the expected value of the row. Any trailing whitespace is ignored

Raises:

  • (MatchError) —

    if the row doesn’t match exactly



10
11
12
13
14
15
16
17
18
 
# File 'lib/ttytest/matchers.rb', line 10

def assert_row(row_number, expected)
  expected = expected.rstrip
  actual = row(row_number)

  return if actual == expected

  raise MatchError,
        "expected row #{row_number} to be #{expected.inspect} but got #{actual.inspect}\nEntire screen:\n#{self}"
end

#assert_row_at(row_number, column_start, column_end, expected) ⇒ Object

Asserts the contents of a single row contains the expected string at a specific position

Parameters:

  • row_number (Integer) —

    the row (starting from 0) to test against

  • column_start (Integer) —

    the column position to start comparing expected against

  • columns_end (Integer) —

    the column position to end comparing expected against

  • expected (String) —

    the expected value that the row starts with. Any trailing whitespace is ignored

Raises:



40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/ttytest/matchers.rb', line 40

def assert_row_at(row_number, column_start, column_end, expected)
  expected = expected.rstrip
  actual = row(row_number)
  column_end += 1

  return if actual[column_start, column_end].eql?(expected)

  raise MatchError,
        "expected row #{row_number} to contain #{expected[column_start,
                                                          column_end]} at #{column_start}-#{column_end} and got #{actual[column_start,
                                                                                                                         column_end]}\nEntire screen:\n#{self}"
end

#assert_row_ends_with(row_number, expected) ⇒ Object

Asserts the contents of a single row end with expected

Parameters:

  • row_number (Integer) —

    the row (starting from 0) to test against

  • expected (String) —

    the expected value that the row starts with. Any trailing whitespace is ignored

Raises:



86
87
88
89
90
91
92
93
94
 
# File 'lib/ttytest/matchers.rb', line 86

def assert_row_ends_with(row_number, expected)
  expected = expected.rstrip
  actual = row(row_number)

  return if actual.end_with?(expected)

  raise MatchError,
        "expected row #{row_number} to end with #{expected.inspect} and got #{actual.inspect}\nEntire screen:\n#{self}"
end

#assert_row_is_empty(row_number) ⇒ Object

Asserts the specified row is empty

Parameters:

  • row_number (Integer) —

    the row (starting from 0) to test against

Raises:



26
27
28
29
30
31
32
 
# File 'lib/ttytest/matchers.rb', line 26

def assert_row_is_empty(row_number)
  actual = row(row_number)

  return if actual == ''

  raise MatchError, "expected row #{row_number} to be empty but got #{actual.inspect}\nEntire screen:\n#{self}"
end

#assert_row_like(row_number, expected) ⇒ Object Also known as: assert_row_contains

Asserts the contents of a single row contains the value expected

Parameters:

  • row_number (Integer) —

    the row (starting from 0) to test against

  • expected (String) —

    the expected value contained in the row. Any trailing whitespace is ignored

Raises:



57
58
59
60
61
62
63
64
65
 
# File 'lib/ttytest/matchers.rb', line 57

def assert_row_like(row_number, expected)
  expected = expected.rstrip
  actual = row(row_number)

  return if actual.include?(expected)

  raise MatchError,
        "expected row #{row_number} to be like #{expected.inspect} but got #{actual.inspect}\nEntire screen:\n#{self}"
end

#assert_row_regexp(row_number, regexp_str) ⇒ Object

Asserts the contents of a single row match against the passed in regular expression

Parameters:

  • row_number (Integer) —

    the row (starting from 0) to test against

  • regexp_str (String) —

    the regular expression as a string that will be used to match with.

Raises:

  • (MatchError) —

    if the row doesn’t match against the regular expression



100
101
102
103
104
105
106
107
108
 
# File 'lib/ttytest/matchers.rb', line 100

def assert_row_regexp(row_number, regexp_str)
  regexp = Regexp.new(regexp_str)
  actual = row(row_number)

  return if actual.match?(regexp)

  raise MatchError,
        "expected row #{row_number} to match regexp #{regexp_str} but it did not. Row value #{actual.inspect}\nEntire screen:\n#{self}"
end

#assert_row_starts_with(row_number, expected) ⇒ Object

Asserts the contents of a single row starts with expected string

Parameters:

  • row_number (Integer) —

    the row (starting from 0) to test against

  • expected (String) —

    the expected value that the row starts with. Any trailing whitespace is ignored

Raises:



72
73
74
75
76
77
78
79
80
 
# File 'lib/ttytest/matchers.rb', line 72

def assert_row_starts_with(row_number, expected)
  expected = expected.rstrip
  actual = row(row_number)

  return if actual.start_with?(expected)

  raise MatchError,
        "expected row #{row_number} to start with #{expected.inspect} and got #{actual.inspect}\nEntire screen:\n#{self}"
end

#assert_rows_each_match_regexp(row_start, row_end, regexp_str) ⇒ Object

Asserts the contents of a multiple rows each match against the passed in regular expression

Parameters:

  • row_start (Integer) —

    the row (starting from 0) to test against

  • row_end (Integer) —

    the last row to test against

  • regexp_str (String) —

    the regular expression as a string that will be used to match with.

Raises:

  • (MatchError) —

    if the row doesn’t match against the regular expression



115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/ttytest/matchers.rb', line 115

def assert_rows_each_match_regexp(row_start, row_end, regexp_str)
  regexp = Regexp.new(regexp_str)
  row_end += 1 if row_end.zero?

  rows.slice(row_start, row_end).each_with_index do |actual_row, index|
    next if actual_row.match?(regexp)

    raise MatchError,
          "expected row #{index} to match regexp #{regexp_str} but it did not. Row value #{actual_row.inspect}\nEntire screen:\n#{self}"
  end
end

#matched(expected, actual) ⇒ Object 



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'lib/ttytest/matchers.rb', line 155

def matched(expected, actual)
  expected_rows = expected.split("\n")
  diff = []
  matched = true
  actual.each_with_index do |actual_row, index|
    expected_row = (expected_rows[index] || '').rstrip
    if actual_row != expected_row
      diff << "-#{expected_row}"
      diff << "+#{actual_row}"
      matched = false
    else
      diff << " #{actual_row}".rstrip
    end
  end

  [matched, diff]
end