ttytest2 1.0.7 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ec86d17bfe3b3a9c9485f0b53c14f4dcfebd5e875dd2ba1de7f26c7ef4b1a87
-  data.tar.gz: 2b53db154e9c680b89897bc46cffe087d415ce22049727ec1b3ff698ce80aba0
+  metadata.gz: ba5f1abfa44480c3955c2c0ff48e724ea09f060aa90417caa72cdcf2b15a29bc
+  data.tar.gz: 904200415a856ad8e9b077ea30f5bc9dea085f966ec896e5e19d328b39039000
 SHA512:
-  metadata.gz: 5db41e82f2c81e5df9e8305f51431b58fafac9abe95b23eaf64f7e7f8e13c64ca5b1be21784b67438938579dd503cbd430128c6984e94b8fa69990c9d9e7b0cf
-  data.tar.gz: 22e3f4c4609432321cf5c7abe0f061e15f52816f89f1d8dd87283aef6d9d78dd661fe991edc074dbfd354024aaa59278799d332b29d3cd32460ef0d2bf665d4d
+  metadata.gz: 8d117e8a03132b3a0dd0c93bc0c8a864ffce023d286c98e495a7b8ddafccbdff49d7f2db49c864ceae9f88fd4529322294ec7c7b2e925806e7af721d94ba12e0
+  data.tar.gz: 1809000f0fea428a053449c07b7b94ca93028dfe3c91d815f0d903bb052c48736f542edb2493cd4fde39bed3c0fa495adca1bd14afccbe186c4cdf9735f54cf5

data/README.md

@@ -1,5 +1,9 @@
 # ttytest2
 
+<a href="https://rubygems.org/gems/ttytest2">
+<img src="images/ttytest2.png" alt="ttytest2 logo" style="width:70%; height:auto;">
+</a>
+
 ttytest2 is a user acceptance test framework for CLI & shell applications.
 
 ttytest2 is a fork and a drop-in replacement for [ttytest](https://github.com/jhawthorn/ttytest).
@@ -31,6 +35,7 @@ The assertions will wait a specified amount of time (configurable, default 2 sec
 
 ## Usage
 
+* Download the [gem](https://rubygems.org/gems/ttytest2) here.
 * More documentation available at [ttytest2 docs](https://www.rubydoc.info/gems/ttytest2).
 * There are more examples in the examples folder.
 
@@ -121,6 +126,8 @@ If you are reading this on github, the ruby docs accessible from [RubyDoc.Info](
 
 * `assert_row_regexp(row_number, regexp_str)`
 
+* `assert_rows_each_match_regexp(row_start, row_end, regexp_str)`
+
 * `assert_cursor_position(x: x, y: y)`
 
 * `assert_cursor_visible`
@@ -131,6 +138,22 @@ If you are reading this on github, the ruby docs accessible from [RubyDoc.Info](
 
 * `assert_contents_at(row_start, row_end, expected_text)`
 
+* `assert_contents_include(expected)`
+
+* `assert_contents_empty`
+
+* `assert_contents_match_regexp(regexp_str)`
+
+* `assert_file_exists(file_path)`
+
+* `assert_file_doesnt_exist(file_path)`
+
+* `assert_file_contains(file_path, needle)`
+
+* `assert_file_has_permissions(file_path, permissions)`
+
+* `assert_file_has_line_count(file_path, expected_count)`
+
 ## Output
 
 You can send output to the terminal with the following calls.

data/lib/ttytest/assertions/column_assertions.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module TTYtest
+  # Column Assertions for ttytest2.
+  module ColumnAssertions
+    # Asserts the contents of a single column match the value expected
+    # @param [Integer] col_number the column (starting from 0) to test against
+    # @param [String] expected the expected value of the column. Any trailing whitespace is ignored
+    # @raise [MatchError] if the column doesn't match exactly
+    def assert_column(col_number, expected)
+      validate(col_number)
+      expected = expected.rstrip
+
+      rows.each_with_index do |row, i|
+        break if row.nil?
+
+        next if row[col_number] == expected[i]
+
+        raise MatchError,
+              "expected column #{col_number} to be #{expected.inspect}\n
+            Entire screen:\n#{self}"
+      end
+    end
+
+    # Asserts the specified column is empty
+    # @param [Integer] col_number the column (starting from 0) to test against
+    # @raise [MatchError] if the column isn't empty
+    def assert_column_is_empty(col_number)
+      validate(col_number)
+
+      rows.each do |row|
+        break if row.nil?
+
+        next if row == '' || row.length < col_number + 1 || row[col_number] == ' '
+
+        raise MatchError,
+              "expected column #{col_number} to be empty\nEntire screen:\n#{self}"
+      end
+    end
+  end
+end

data/lib/ttytest/assertions/cursor_assertions.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module TTYtest
+  # Cursor Assertions for ttytest2.
+  module CursorAssertions
+    # Asserts that the cursor is in the expected position
+    # @param [Integer] x cursor x (row) position, starting from 0
+    # @param [Integer] y cursor y (column) position, starting from 0
+    # @raise [MatchError] if the cursor position doesn't match
+    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 #{get_inspection(actual)}\nEntire screen:\n#{self}"
+    end
+
+    # Asserts the cursor is currently visible
+    # @raise [MatchError] if the cursor is hidden
+    def assert_cursor_visible
+      return if cursor_visible?
+
+      raise MatchError, "expected cursor to be visible was hidden\nEntire screen:\n#{self}"
+    end
+
+    # Asserts the cursor is currently hidden
+    # @raise [MatchError] if the cursor is visible
+    def assert_cursor_hidden
+      return if cursor_hidden?
+
+      raise MatchError, "expected cursor to be hidden was visible\nEntire screen:\n#{self}"
+    end
+  end
+end

data/lib/ttytest/assertions/file_assertions.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module TTYtest
+  # File Assertions for ttytest2.
+  module FileAssertions
+    # Asserts the specified file exists
+    # @param [String] file_path the path to the file
+    # @raise [MatchError] if the file is not found or is a directory/symlink
+    def assert_file_exists(file_path)
+      raise file_not_found_error(file_path) unless File.exist?(file_path)
+      raise file_is_dir_error(file_path) unless File.file?(file_path)
+    end
+
+    # Asserts the specified file does not exists
+    # @param [String] file_path the path to the file
+    # @raise [MatchError] if the file is found or is a directory/symlink
+    def assert_file_doesnt_exist(file_path)
+      return unless File.exist?(file_path) || File.file?(file_path)
+
+      raise MatchError,
+            "File with path #{file_path} was found or is a directory when it was asserted it did not exist.\nEntire screen:\n#{self}"
+    end
+
+    # Asserts the specified file contains the passed in string value
+    # @param [String] file_path the path to the file
+    # @param [String] needle the value to search for in the file
+    # @raise [MatchError] if the file does not contain value in variable needle
+    def assert_file_contains(file_path, needle)
+      raise file_not_found_error(file_path) unless File.exist?(file_path)
+      raise file_is_dir_error(file_path) unless File.file?(file_path)
+
+      file_contains = false
+      File.foreach(file_path) do |line|
+        if line.include?(needle)
+          file_contains = true
+          break
+        end
+      end
+      return if file_contains
+
+      raise MatchError,
+            "File with path #{file_path} did not contain #{needle}.\nEntire screen:\n#{self}"
+    end
+    alias assert_file_like assert_file_contains
+
+    # Asserts the specified file has the permissions specified
+    # @param [String] file_path the path to the file
+    # @param [String] permissions the expected permissions of the file (in form '644' or '775')
+    # @raise [MatchError] if the file has different permissions than specified
+    def assert_file_has_permissions(file_path, permissions)
+      raise file_not_found_error(file_path) unless File.exist?(file_path)
+      raise file_is_dir_error(file_path) unless File.file?(file_path)
+
+      file_mode = File.stat(file_path).mode
+      perms_octal = format('%o', file_mode)[-3...]
+      return if perms_octal == permissions
+
+      raise MatchError,
+            "File had permissions #{perms_octal}, not #{permissions} as expected.\n Entire screen:\n#{self}"
+    end
+
+    # Asserts the specified file has line count specified
+    # @param [String] file_path the path to the file
+    # @param [String] expected_count the expected line count of the file
+    # @raise [MatchError] if the file has a different line count than specified
+    def assert_file_has_line_count(file_path, expected_count)
+      raise file_not_found_error(file_path) unless File.exist?(file_path)
+      raise file_is_dir_error(file_path) unless File.file?(file_path)
+
+      actual_count = File.foreach(file_path).count
+      return if actual_count == expected_count
+
+      raise MatchError,
+            "File had #{actual_count} lines, not #{expected_count} lines as expected.\nEntire screen:\n#{self}"
+    end
+
+    private
+
+    def file_not_found_error(file_path)
+      raise MatchError,
+            "File with path #{file_path} was not found when asserted it did exist.\nEntire screen:\n#{self}"
+    end
+
+    def file_is_dir_error(file_path)
+      raise MatchError,
+            "File with path #{file_path} is a directory.\nEntire screen:\n#{self}"
+    end
+  end
+end

data/lib/ttytest/assertions/row_assertions.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module TTYtest
+  # Row Assertions for ttytest2.
+  module RowAssertions
+    # Asserts the contents of a single row match the value expected
+    # @param [Integer] row_number the row (starting from 0) to test against
+    # @param [String] expected the expected value of the row. Any trailing whitespace is ignored
+    # @raise [MatchError] if the row doesn't match exactly
+    def assert_row(row_number, expected)
+      validate(row_number)
+      expected = expected.rstrip
+      actual = row(row_number)
+
+      return if !actual.nil? && actual == expected
+
+      raise MatchError,
+            "expected row #{row_number} to be #{expected.inspect} but got #{get_inspection(actual)}\n
+            Entire screen:\n#{self}"
+    end
+    alias assert_line assert_row
+
+    # Asserts the specified row is empty
+    # @param [Integer] row_number the row (starting from 0) to test against
+    # @raise [MatchError] if the row isn't empty
+    def assert_row_is_empty(row_number)
+      validate(row_number)
+      actual = row(row_number)
+
+      return if actual == ''
+
+      raise MatchError,
+            "expected row #{row_number} to be empty but got #{get_inspection(actual)}\nEntire screen:\n#{self}"
+    end
+    alias assert_line_is_empty assert_row_is_empty
+
+    # Asserts the contents of a single row contains the expected string at a specific position
+    # @param [Integer] row_number the row (starting from 0) to test against
+    # @param [Integer] column_start the column position to start comparing expected against
+    # @param [Integer] columns_end the column position to end comparing expected against
+    # @param [String] expected the expected value that the row starts with. Any trailing whitespace is ignored
+    # @raise [MatchError] if the row doesn't match
+    def assert_row_at(row_number, column_start, column_end, expected)
+      validate(row_number)
+      expected = expected.rstrip
+      actual = row(row_number)
+      column_end += 1
+
+      return if !actual.nil? && actual[column_start, column_end].eql?(expected)
+
+      inspection = get_inspection_bounded(actual, column_start, column_end)
+
+      raise MatchError,
+            "expected row #{row_number} to contain #{expected[column_start,
+                                                              column_end]} at #{column_start}-#{column_end} and got #{inspection}\nEntire screen:\n#{self}"
+    end
+    alias assert_line_at assert_row_at
+
+    # Asserts the contents of a single row contains the value expected
+    # @param [Integer] row_number the row (starting from 0) to test against
+    # @param [String] expected the expected value contained in the row. Any trailing whitespace is ignored
+    # @raise [MatchError] if the row doesn't match
+    def assert_row_like(row_number, expected)
+      validate(row_number)
+      expected = expected.rstrip
+      actual = row(row_number)
+
+      return if !actual.nil? && actual.include?(expected)
+
+      raise MatchError,
+            "expected row #{row_number} to be like #{expected.inspect} but got #{get_inspection(actual)}\nEntire screen:\n#{self}"
+    end
+    alias assert_row_contains assert_row_like
+    alias assert_line_contains assert_row_like
+    alias assert_line_like assert_row_like
+
+    # Asserts the contents of a single row starts with expected string
+    # @param [Integer] row_number the row (starting from 0) to test against
+    # @param [String] expected the expected value that the row starts with. Any trailing whitespace is ignored
+    # @raise [MatchError] if the row doesn't match
+    def assert_row_starts_with(row_number, expected)
+      validate(row_number)
+      expected = expected.rstrip
+      actual = row(row_number)
+
+      return if !actual.nil? && actual.start_with?(expected)
+
+      raise MatchError,
+            "expected row #{row_number} to start with #{expected.inspect} and got #{get_inspection(actual)}\nEntire screen:\n#{self}"
+    end
+    alias assert_line_starts_with assert_row_starts_with
+
+    # Asserts the contents of a single row end with expected
+    # @param [Integer] row_number the row (starting from 0) to test against
+    # @param [String] expected the expected value that the row starts with. Any trailing whitespace is ignored
+    # @raise [MatchError] if the row doesn't match
+    def assert_row_ends_with(row_number, expected)
+      validate(row_number)
+      expected = expected.rstrip
+      actual = row(row_number)
+
+      return if !actual.nil? && actual.end_with?(expected)
+
+      raise MatchError,
+            "expected row #{row_number} to end with #{expected.inspect} and got #{get_inspection(actual)}\nEntire screen:\n#{self}"
+    end
+    alias assert_line_ends_with assert_row_ends_with
+
+    # Asserts the contents of a single row match against the passed in regular expression
+    # @param [Integer] row_number the row (starting from 0) to test against
+    # @param [String] regexp_str the regular expression as a string that will be used to match with.
+    # @raise [MatchError] if the row doesn't match against the regular expression
+    def assert_row_regexp(row_number, regexp_str)
+      validate(row_number)
+      regexp = Regexp.new(regexp_str)
+      actual = row(row_number)
+
+      return if !actual.nil? && actual.match?(regexp)
+
+      raise MatchError,
+            "expected row #{row_number} to match regexp #{regexp_str} but it did not. Row value #{get_inspection(actual)}\nEntire screen:\n#{self}"
+    end
+    alias assert_line_regexp assert_row_regexp
+
+    # Asserts the contents of a multiple rows each match against the passed in regular expression
+    # @param [Integer] row_start the row (starting from 0) to test against
+    # @param [Integer] row_end the last row to test against
+    # @param [String] regexp_str the regular expression as a string that will be used to match with.
+    # @raise [MatchError] if the row doesn't match against the regular expression
+    def assert_rows_each_match_regexp(row_start, row_end, regexp_str)
+      validate(row_end)
+      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.nil? && actual_row.match?(regexp)
+
+        raise MatchError,
+              "expected row #{index} to match regexp #{regexp_str} but it did not. Row value #{get_inspection(actual_row)}\nEntire screen:\n#{self}"
+      end
+    end
+    alias assert_lines_each_match_regexp assert_rows_each_match_regexp
+  end
+end

data/lib/ttytest/assertions/screen_assertions.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module TTYtest
+  # Screen Assertions for ttytest2.
+  module ScreenAssertions
+    # Asserts the full contents of the terminal
+    # @param [String] expected the full expected contents of the terminal. Trailing whitespace on each line is ignored
+    # @raise [MatchError] if the terminal doesn't match the expected content
+    def assert_contents(expected)
+      matched, diff = get_diff(expected, rows)
+
+      return if matched
+
+      raise MatchError,
+            "screen did not match expected content:\n--- expected\n+++ actual\n#{diff.join("\n")}"
+    end
+    alias assert_matches assert_contents
+    alias assert_screen assert_contents
+
+    # Asserts the contents of the terminal at specified rows
+    # @param [String] expected the expected contents of the terminal at specified rows. Trailing whitespace on each line is ignored
+    # @raise [MatchError] if the terminal doesn't match the expected content
+    def assert_contents_at(row_start, row_end, expected)
+      validate(row_end)
+      row_end += 1 if row_end.zero?
+
+      matched, diff = get_diff(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
+    alias assert_matches_at assert_contents_at
+    alias assert_rows assert_contents_at
+
+    # Asserts the contents of the screen include the passed in string
+    # @param [String] expected the string value expected to be found in the screen contents
+    # @raise [MatchError] if the screen does not contain the expected value
+    def assert_contents_include(expected)
+      found = false
+      rows.each do |row|
+        found = true if row.include?(expected)
+      end
+      return if found
+
+      raise MatchError,
+            "Expected screen contents to include #{expected}, but it was not found.\nEntire screen:\n#{self}"
+    end
+    alias assert_screen_includes assert_contents_include
+
+    # Asserts the contents of the screen are empty
+    # @raise [MatchError] if the screen is not empty
+    def assert_contents_empty
+      return if rows.all? { |s| s.to_s.empty? }
+
+      raise MatchError,
+            "Expected screen to be empty, but found content.\nEntire screen:\n#{self}"
+    end
+    alias assert_screen_empty assert_contents_empty
+
+    # Asserts the contents of the screen as a single string match the passed in regular expression
+    # @param [String] regexp_str the regular expression as a string that will be used to match with
+    # @raise [MatchError] if the screen as a string doesn't match against the regular expression
+    def assert_contents_match_regexp(regexp_str)
+      regexp = Regexp.new(regexp_str)
+      screen = capture.to_s
+
+      return if !screen.nil? && screen.match?(regexp)
+
+      raise MatchError,
+            "Expected screen contents to match regexp #{regexp_str} but they did not\nEntire screen:\n#{self}"
+    end
+    alias assert_screen_matches_regexp assert_contents_match_regexp
+  end
+end

data/lib/ttytest/assertions.rb

@@ -1,257 +1,19 @@
 # frozen_string_literal: true
 
+require 'ttytest/assertions/file_assertions'
+require 'ttytest/assertions/row_assertions'
+require 'ttytest/assertions/column_assertions'
+require 'ttytest/assertions/screen_assertions'
+require 'ttytest/assertions/cursor_assertions'
+
 module TTYtest
   # Assertions for ttytest2.
   module Assertions
-    # Asserts the contents of a single row match the value expected
-    # @param [Integer] row_number the row (starting from 0) to test against
-    # @param [String] expected the expected value of the row. Any trailing whitespace is ignored
-    # @raise [MatchError] if the row doesn't match exactly
-    def assert_row(row_number, expected)
-      validate(row_number)
-      expected = expected.rstrip
-      actual = row(row_number)
-
-      return if !actual.nil? && actual == expected
-
-      raise MatchError,
-            "expected row #{row_number} to be #{expected.inspect} but got #{get_inspection(actual)}\n
-            Entire screen:\n#{self}"
-    end
-    alias assert_line assert_row
-
-    # Asserts the specified row is empty
-    # @param [Integer] row_number the row (starting from 0) to test against
-    # @raise [MatchError] if the row isn't empty
-    def assert_row_is_empty(row_number)
-      validate(row_number)
-      actual = row(row_number)
-
-      return if actual == ''
-
-      raise MatchError,
-            "expected row #{row_number} to be empty but got #{get_inspection(actual)}\nEntire screen:\n#{self}"
-    end
-    alias assert_line_is_empty assert_row_is_empty
-
-    # Asserts the contents of a single row contains the expected string at a specific position
-    # @param [Integer] row_number the row (starting from 0) to test against
-    # @param [Integer] column_start the column position to start comparing expected against
-    # @param [Integer] columns_end the column position to end comparing expected against
-    # @param [String] expected the expected value that the row starts with. Any trailing whitespace is ignored
-    # @raise [MatchError] if the row doesn't match
-    def assert_row_at(row_number, column_start, column_end, expected)
-      validate(row_number)
-      expected = expected.rstrip
-      actual = row(row_number)
-      column_end += 1
-
-      return if !actual.nil? && actual[column_start, column_end].eql?(expected)
-
-      inspection = get_inspection_bounded(actual, column_start, column_end)
-
-      raise MatchError,
-            "expected row #{row_number} to contain #{expected[column_start,
-                                                              column_end]} at #{column_start}-#{column_end} and got #{inspection}\nEntire screen:\n#{self}"
-    end
-    alias assert_line_at assert_row_at
-
-    # Asserts the contents of a single row contains the value expected
-    # @param [Integer] row_number the row (starting from 0) to test against
-    # @param [String] expected the expected value contained in the row. Any trailing whitespace is ignored
-    # @raise [MatchError] if the row doesn't match
-    def assert_row_like(row_number, expected)
-      validate(row_number)
-      expected = expected.rstrip
-      actual = row(row_number)
-
-      return if !actual.nil? && actual.include?(expected)
-
-      raise MatchError,
-            "expected row #{row_number} to be like #{expected.inspect} but got #{get_inspection(actual)}\nEntire screen:\n#{self}"
-    end
-    alias assert_row_contains assert_row_like
-    alias assert_line_contains assert_row_like
-    alias assert_line_like assert_row_like
-
-    # Asserts the contents of a single row starts with expected string
-    # @param [Integer] row_number the row (starting from 0) to test against
-    # @param [String] expected the expected value that the row starts with. Any trailing whitespace is ignored
-    # @raise [MatchError] if the row doesn't match
-    def assert_row_starts_with(row_number, expected)
-      validate(row_number)
-      expected = expected.rstrip
-      actual = row(row_number)
-
-      return if !actual.nil? && actual.start_with?(expected)
-
-      raise MatchError,
-            "expected row #{row_number} to start with #{expected.inspect} and got #{get_inspection(actual)}\nEntire screen:\n#{self}"
-    end
-    alias assert_line_starts_with assert_row_starts_with
-
-    # Asserts the contents of a single row end with expected
-    # @param [Integer] row_number the row (starting from 0) to test against
-    # @param [String] expected the expected value that the row starts with. Any trailing whitespace is ignored
-    # @raise [MatchError] if the row doesn't match
-    def assert_row_ends_with(row_number, expected)
-      validate(row_number)
-      expected = expected.rstrip
-      actual = row(row_number)
-
-      return if !actual.nil? && actual.end_with?(expected)
-
-      raise MatchError,
-            "expected row #{row_number} to end with #{expected.inspect} and got #{get_inspection(actual)}\nEntire screen:\n#{self}"
-    end
-    alias assert_line_ends_with assert_row_ends_with
-
-    # Asserts the contents of a single row match against the passed in regular expression
-    # @param [Integer] row_number the row (starting from 0) to test against
-    # @param [String] regexp_str the regular expression as a string that will be used to match with.
-    # @raise [MatchError] if the row doesn't match against the regular expression
-    def assert_row_regexp(row_number, regexp_str)
-      validate(row_number)
-      regexp = Regexp.new(regexp_str)
-      actual = row(row_number)
-
-      return if !actual.nil? && actual.match?(regexp)
-
-      raise MatchError,
-            "expected row #{row_number} to match regexp #{regexp_str} but it did not. Row value #{get_inspection(actual)}\nEntire screen:\n#{self}"
-    end
-    alias assert_line_regexp assert_row_regexp
-
-    # Asserts the contents of a multiple rows each match against the passed in regular expression
-    # @param [Integer] row_start the row (starting from 0) to test against
-    # @param [Integer] row_end the last row to test against
-    # @param [String] regexp_str the regular expression as a string that will be used to match with.
-    # @raise [MatchError] if the row doesn't match against the regular expression
-    def assert_rows_each_match_regexp(row_start, row_end, regexp_str)
-      validate(row_end)
-      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.nil? && actual_row.match?(regexp)
-
-        raise MatchError,
-              "expected row #{index} to match regexp #{regexp_str} but it did not. Row value #{get_inspection(actual_row)}\nEntire screen:\n#{self}"
-      end
-    end
-    alias assert_line_each_match_regexp assert_rows_each_match_regexp
-
-    # Asserts that the cursor is in the expected position
-    # @param [Integer] x cursor x (row) position, starting from 0
-    # @param [Integer] y cursor y (column) position, starting from 0
-    # @raise [MatchError] if the cursor position doesn't match
-    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 #{get_inspection(actual)}\nEntire screen:\n#{self}"
-    end
-
-    # @raise [MatchError] if the cursor is hidden
-    def assert_cursor_visible
-      return if cursor_visible?
-
-      raise MatchError, "expected cursor to be visible was hidden\nEntire screen:\n#{self}"
-    end
-
-    # @raise [MatchError] if the cursor is visible
-    def assert_cursor_hidden
-      return if cursor_hidden?
-
-      raise MatchError, "expected cursor to be hidden was visible\nEntire screen:\n#{self}"
-    end
-
-    # Asserts the full contents of the terminal
-    # @param [String] expected the full expected contents of the terminal. Trailing whitespace on each line is ignored
-    # @raise [MatchError] if the terminal doesn't match the expected content
-    def assert_contents(expected)
-      matched, diff = get_diff(expected, rows)
-
-      return if matched
-
-      raise MatchError,
-            "screen did not match expected content:\n--- expected\n+++ actual\n#{diff.join("\n")}"
-    end
-    alias assert_matches assert_contents
-    alias assert_screen assert_contents
-
-    # Asserts the contents of the terminal at specified rows
-    # @param [String] expected the expected contents of the terminal at specified rows. Trailing whitespace on each line is ignored
-    # @raise [MatchError] if the terminal doesn't match the expected content
-    def assert_contents_at(row_start, row_end, expected)
-      validate(row_end)
-      row_end += 1 if row_end.zero?
-
-      matched, diff = get_diff(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
-    alias assert_matches_at assert_contents_at
-    alias assert_rows assert_contents_at
-
-    def assert_file_exists(file_path)
-      raise file_not_found_error(file_path) unless File.exist?(file_path)
-      raise file_is_dir_error(file_path) unless File.file?(file_path)
-    end
-
-    def assert_file_doesnt_exist(file_path)
-      return unless File.exist?(file_path) || File.file?(file_path)
-
-      raise MatchError,
-            "File with path #{file_path} was found or is a directory when it was asserted it did not exist.\nEntire screen:\n#{self}"
-    end
-
-    def assert_file_contains(file_path, needle)
-      raise file_not_found_error(file_path) unless File.exist?(file_path)
-      raise file_is_dir_error(file_path) unless File.file?(file_path)
-
-      file_contains = false
-      File.foreach(file_path) do |line|
-        if line.include?(needle)
-          file_contains = true
-          break
-        end
-      end
-      return if file_contains
-
-      raise MatchError,
-            "File with path #{file_path} did not contain #{needle}.\nEntire screen:\n#{self}"
-    end
-    alias assert_file_like assert_file_contains
-
-    def assert_file_has_permissions(file_path, permissions)
-      raise file_not_found_error(file_path) unless File.exist?(file_path)
-      raise file_is_dir_error(file_path) unless File.file?(file_path)
-
-      file_mode = File.stat(file_path).mode
-      perms_octal = format('%o', file_mode)[-3...]
-      return if perms_octal == permissions
-
-      raise MatchError,
-            "File had permissions #{perms_octal}, not #{permissions} as expected.\n Entire screen:\n#{self}"
-    end
-
-    def assert_file_has_line_count(file_path, expected_count)
-      raise file_not_found_error(file_path) unless File.exist?(file_path)
-      raise file_is_dir_error(file_path) unless File.file?(file_path)
-
-      actual_count = File.foreach(file_path).count
-      return if actual_count == expected_count
-
-      raise MatchError,
-            "File had #{actual_count} lines, not #{expected_count} lines as expected.\nEntire screen:\n#{self}"
-    end
+    include TTYtest::FileAssertions
+    include TTYtest::RowAssertions
+    include TTYtest::ColumnAssertions
+    include TTYtest::ScreenAssertions
+    include TTYtest::CursorAssertions
 
     METHODS = public_instance_methods
 
@@ -299,15 +61,5 @@ module TTYtest
 
       [matched, diff]
     end
-
-    def file_not_found_error(file_path)
-      raise MatchError,
-            "File with path #{file_path} was not found when asserted it did exist.\nEntire screen:\n#{self}"
-    end
-
-    def file_is_dir_error(file_path)
-      raise MatchError,
-            "File with path #{file_path} is a directory.\nEntire screen:\n#{self}"
-    end
   end
 end

data/lib/ttytest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TTYtest
-  VERSION = '1.0.7'
+  VERSION = '1.2.0'
 end

data/notes.txt

@@ -1,7 +1,7 @@
 to push new version to github
-git tag v1.0.7
+git tag v1.2.0
 git push origin --tags
 
 to push new version to rubygems.org
 gem build ttytest2.gemspec
-gem push ttytest2-1.0.7.gem
+gem push ttytest2-1.2.0.gem

data/todo.txt

@@ -1,2 +1,6 @@
 assert_exit_code(0)            # For success
 assert_exit_code(1)            # For expected failure
+assert_variable_equals
+assert_prompt
+assert_prompt_after("command failed")
+assert_style(row, col, style)

data/ttytest2.gemspec

@@ -10,8 +10,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Alex Eski']
   spec.email         = ['alexeski@gmail.com']
 
-  spec.summary       = 'ttytest2 is an integration test framework for interactive console (tty) applications'
-  spec.description   = 'ttytest2 runs shell/cli applications inside of tmux and allows you to make assertions on what the output should be'
+  spec.summary       = 'ttytest2 is for integration/acceptance testing your shells/CLIs/REPLs.'
+  spec.description   = 'ttytest2 is an integration test framework for interactive console (tty) applications'
   spec.homepage      = 'https://github.com/a-eski/ttytest2'
   spec.license       = 'MIT'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ttytest2
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.2.0
 platform: ruby
 authors:
 - Alex Eski
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-01 00:00:00.000000000 Z
+date: 2025-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,8 +80,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: ttytest2 runs shell/cli applications inside of tmux and allows you to
-  make assertions on what the output should be
+description: ttytest2 is an integration test framework for interactive console (tty)
+  applications
 email:
 - alexeski@gmail.com
 executables: []
@@ -95,8 +95,14 @@ files:
 - README.md
 - Rakefile
 - examples/integration_tests.rb
+- images/ttytest2.png
 - lib/ttytest.rb
 - lib/ttytest/assertions.rb
+- lib/ttytest/assertions/column_assertions.rb
+- lib/ttytest/assertions/cursor_assertions.rb
+- lib/ttytest/assertions/file_assertions.rb
+- lib/ttytest/assertions/row_assertions.rb
+- lib/ttytest/assertions/screen_assertions.rb
 - lib/ttytest/capture.rb
 - lib/ttytest/constants.rb
 - lib/ttytest/terminal.rb
@@ -129,5 +135,5 @@ requirements: []
 rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
-summary: ttytest2 is an integration test framework for interactive console (tty) applications
+summary: ttytest2 is for integration/acceptance testing your shells/CLIs/REPLs.
 test_files: []