Module: TUITD::Minitest::Assertions

Defined in:
lib/tui_td/minitest/assertions.rb

Overview

Assertions for TUI testing with Minitest.

Include this module in your Minitest test class:

require "tui_td/minitest/assertions"

class MyTUITest < Minitest::Test
  include TUITD::Minitest::Assertions

  def 
    driver = TUITD::Driver.new("my_tui", rows: 24, cols: 80)
    driver.start
    assert_text(driver, "Welcome")
    assert_button(driver, "OK")
    refute_text(driver, "Error")
  ensure
    driver&.close
  end
end

Auto-wait: When given a Driver, assertions wait up to 3 seconds. When given a State, assertions check immediately.

Constant Summary collapse

AUTO_WAIT_TIMEOUT = 
3

Instance Method Summary collapse

Instance Method Details

#assert_bg(actual, expected, row:, col:) ⇒ Object 



90
91
92
93
94
 
# File 'lib/tui_td/minitest/assertions.rb', line 90

def assert_bg(actual, expected, row:, col:)
  result = auto_wait(actual) { |s| s.background_at(row, col) == expected }
  actual_bg = state_from(actual).background_at(row, col)
  assert(result, "Expected BG at [#{row},#{col}] to be #{expected.inspect}, but was #{actual_bg.inspect}")
end

#assert_button(actual, expected) ⇒ Object

— Selector-based —



113
114
115
116
 
# File 'lib/tui_td/minitest/assertions.rb', line 113

def assert_button(actual, expected)
  result = auto_wait(actual) { |s| TUITD::Selector.new(s).button(text: expected) }
  assert(result, "Expected terminal to have a button #{expected.inspect}")
end

#assert_checkbox(actual, expected, checked: nil, unchecked: nil) ⇒ Object 



133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/tui_td/minitest/assertions.rb', line 133

def assert_checkbox(actual, expected, checked: nil, unchecked: nil)
  checked = false if unchecked
  result = auto_wait(actual) do |s|
    filters = { text: expected }
    filters[:checked] = checked unless checked.nil?
    TUITD::Selector.new(s).checkbox(**filters)
  end
  msg = "Expected terminal to have checkbox #{expected.inspect}"
  msg += " (checked)" if checked == true
  msg += " (unchecked)" if checked == false
  assert(result, msg)
end

#assert_dialog(actual) ⇒ Object 



123
124
125
126
 
# File 'lib/tui_td/minitest/assertions.rb', line 123

def assert_dialog(actual)
  result = auto_wait(actual) { |s| TUITD::Selector.new(s).dialogs.any? }
  assert(result, "Expected terminal to have a dialog")
end

#assert_exit_status(actual, expected) ⇒ Object 



106
107
108
109
 
# File 'lib/tui_td/minitest/assertions.rb', line 106

def assert_exit_status(actual, expected)
  status = actual.exitstatus
  assert(status == expected, "Expected exit status #{expected}, but was #{status}")
end

#assert_fg(actual, expected, row:, col:) ⇒ Object 



84
85
86
87
88
 
# File 'lib/tui_td/minitest/assertions.rb', line 84

def assert_fg(actual, expected, row:, col:)
  result = auto_wait(actual) { |s| s.foreground_at(row, col) == expected }
  actual_fg = state_from(actual).foreground_at(row, col)
  assert(result, "Expected FG at [#{row},#{col}] to be #{expected.inspect}, but was #{actual_fg.inspect}")
end

#assert_input(actual, expected = nil) ⇒ Object 



159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'lib/tui_td/minitest/assertions.rb', line 159

def assert_input(actual, expected = nil)
  result = auto_wait(actual) do |s|
    if expected
      TUITD::Selector.new(s).input(text: expected)
    else
      TUITD::Selector.new(s).inputs.any?
    end
  end
  msg = "Expected terminal to have an input field"
  msg += " #{expected.inspect}" if expected
  assert(result, msg)
end

#assert_label(actual, expected = nil) ⇒ Object 



172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/tui_td/minitest/assertions.rb', line 172

def assert_label(actual, expected = nil)
  result = auto_wait(actual) do |s|
    if expected
      TUITD::Selector.new(s).label(text: expected)
    else
      TUITD::Selector.new(s).labels.any?
    end
  end
  msg = "Expected terminal to have a label"
  msg += " #{expected.inspect}" if expected
  assert(result, msg)
end

#assert_menu(actual, expected = nil) ⇒ Object 



185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/tui_td/minitest/assertions.rb', line 185

def assert_menu(actual, expected = nil)
  result = auto_wait(actual) do |s|
    if expected
      TUITD::Selector.new(s).menu(text: expected)
    else
      TUITD::Selector.new(s).menus.any?
    end
  end
  msg = "Expected terminal to have a menu"
  msg += " #{expected.inspect}" if expected
  assert(result, msg)
end

#assert_progress_bar(actual, expected = nil) ⇒ Object 



224
225
226
227
228
229
230
231
232
233
234
235
 
# File 'lib/tui_td/minitest/assertions.rb', line 224

def assert_progress_bar(actual, expected = nil)
  result = auto_wait(actual) do |s|
    if expected
      TUITD::Selector.new(s).progress_bar(text: expected)
    else
      TUITD::Selector.new(s).progress_bars.any?
    end
  end
  msg = "Expected terminal to have a progress bar"
  msg += " #{expected.inspect}" if expected
  assert(result, msg)
end

#assert_regex(actual, pattern) ⇒ Object 



72
73
74
75
76
 
# File 'lib/tui_td/minitest/assertions.rb', line 72

def assert_regex(actual, pattern)
  regex = pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern.to_s)
  result = auto_wait(actual) { |s| s.find_text(regex).any? }
  assert(result, "Expected terminal to match #{pattern.inspect}")
end

#assert_role(actual, role, text: nil, checked: nil, disabled: nil) ⇒ Object 



146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/tui_td/minitest/assertions.rb', line 146

def assert_role(actual, role, text: nil, checked: nil, disabled: nil)
  result = auto_wait(actual) do |s|
    filters = {}
    filters[:text] = text if text
    filters[:checked] = checked unless checked.nil?
    filters[:disabled] = disabled unless disabled.nil?
    TUITD::Selector.new(s).get_by_role(role, **filters).any?
  end
  msg = "Expected terminal to have role :#{role}"
  msg += " with text #{text.inspect}" if text
  assert(result, msg)
end

#assert_snapshot(actual, name, type: :text, wait: false, region: nil, ignore_rows: nil) ⇒ Object

— Snapshot —



239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'lib/tui_td/minitest/assertions.rb', line 239

def assert_snapshot(actual, name, type: :text, wait: false, region: nil, ignore_rows: nil)
  snap = TUITD::Snapshot.new(name.to_s, type: type)

  state_data = if actual.respond_to?(:state_data)
                 actual.wait_for_stable if wait && actual.respond_to?(:wait_for_stable)
                 actual.state_data
               elsif actual.respond_to?(:to_h)
                 actual.to_h
               else
                 actual
               end

  if TUITD.configuration.update_snapshots? || !snap.exists?
    snap.save(state_data)
    pass
  else
    result = snap.compare(state_data, ignore_rows: ignore_rows, region: region)
    msg = result.passed? ? nil : "Snapshot '#{name}' does not match.\n#{result.message}"
    assert(result.passed?, msg)
  end
end

#assert_statusbar(actual, expected = nil) ⇒ Object 



211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/tui_td/minitest/assertions.rb', line 211

def assert_statusbar(actual, expected = nil)
  result = auto_wait(actual) do |s|
    if expected
      TUITD::Selector.new(s).statusbar(text: expected)
    else
      TUITD::Selector.new(s).statusbars.any?
    end
  end
  msg = "Expected terminal to have a status bar"
  msg += " #{expected.inspect}" if expected
  assert(result, msg)
end

#assert_style(actual, row:, col:, **expected_styles) ⇒ Object 



96
97
98
99
100
101
102
103
104
 
# File 'lib/tui_td/minitest/assertions.rb', line 96

def assert_style(actual, row:, col:, **expected_styles)
  result = auto_wait(actual) do |s|
    style = s.style_at(row, col)
    expected_styles.all? { |k, v| style[k] == v }
  end
  actual_style = state_from(actual).style_at(row, col)
  assert(result,
         "Expected style at [#{row},#{col}] to be #{expected_styles.inspect}, but was #{actual_style.inspect}",)
end

#assert_tab(actual, expected = nil) ⇒ Object 



198
199
200
201
202
203
204
205
206
207
208
209
 
# File 'lib/tui_td/minitest/assertions.rb', line 198

def assert_tab(actual, expected = nil)
  result = auto_wait(actual) do |s|
    if expected
      TUITD::Selector.new(s).tab(text: expected)
    else
      TUITD::Selector.new(s).tabs.any?
    end
  end
  msg = "Expected terminal to have a tab"
  msg += " #{expected.inspect}" if expected
  assert(result, msg)
end

#assert_text(actual, expected) ⇒ Object

— Text / Regex / Color / Style —



62
63
64
65
 
# File 'lib/tui_td/minitest/assertions.rb', line 62

def assert_text(actual, expected)
  result = auto_wait(actual) { |s| s.find_text(expected).any? }
  assert(result, "Expected terminal to contain #{expected.inspect}")
end

#refute_button(actual, expected) ⇒ Object 



118
119
120
121
 
# File 'lib/tui_td/minitest/assertions.rb', line 118

def refute_button(actual, expected)
  result = auto_wait(actual) { |s| TUITD::Selector.new(s).button(text: expected).nil? }
  assert(result, "Expected terminal NOT to have a button #{expected.inspect}")
end

#refute_dialog(actual) ⇒ Object 



128
129
130
131
 
# File 'lib/tui_td/minitest/assertions.rb', line 128

def refute_dialog(actual)
  result = auto_wait(actual) { |s| TUITD::Selector.new(s).dialogs.empty? }
  assert(result, "Expected terminal NOT to have a dialog")
end

#refute_regex(actual, pattern) ⇒ Object 



78
79
80
81
82
 
# File 'lib/tui_td/minitest/assertions.rb', line 78

def refute_regex(actual, pattern)
  regex = pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern.to_s)
  result = auto_wait(actual) { |s| s.find_text(regex).empty? }
  assert(result, "Expected terminal NOT to match #{pattern.inspect}")
end

#refute_text(actual, expected) ⇒ Object 



67
68
69
70
 
# File 'lib/tui_td/minitest/assertions.rb', line 67

def refute_text(actual, expected)
  result = auto_wait(actual) { |s| s.find_text(expected).empty? }
  assert(result, "Expected terminal NOT to contain #{expected.inspect}")
end