tui-td 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b74325984554c843a191d5affcf77472229000da6f14551c26ca2e6f1b0425cd
-  data.tar.gz: 2ddeb1aaedfc23ca62e3e791bb254950ef4432a32f0031e0a144f7567e2a3785
+  metadata.gz: 97ed62eebe255ca568235b0ffe8bb428812d0dbc0408e24e768d76e8b11beb8a
+  data.tar.gz: 8b66334f5408398dab8dcf02535e8473c2d9af7357f4fc1db45bc67ca792706c
 SHA512:
-  metadata.gz: b02944c10ed90a607ccfadd80fe80237a1bd5d50bba8e92320875c3cc71181f04057d2cad78648f5ddefee7a149b179c215c12b0ed61a19af7363b658090e36a
-  data.tar.gz: fe0f2b747cc15fe39da0195c83371ef44c457194f1648aa5e4e03f525ac856a60f3561a482012009054158350d354ea7cf28a04ab75eb9d660c1712203364373
+  metadata.gz: 404c5b2c0c411b25846855d0d5ad297493be90672ee3eba53980df429ec1263170b605d023983a4fbc17c2b4563b10ff91c98324a08651cf0997d4a9cde21667
+  data.tar.gz: 5b73ca7cccaa81b434ca418e5f246573033ac5abd6c18b7094adad6f65d8fa453be2e8c84d842f2ba82e182a9189989a2389599874e1ab9448606db30677d901

data/CHANGELOG.md

@@ -1,8 +1,23 @@
 # CHANGELOG
 
+## 0.2.4
+
+- `assert_regex` JSON test step — match terminal output against a Ruby regex
+- `assert_not_text` JSON test step — fail if text IS present (inverse of assert_text)
+- `have_regex` RSpec matcher — regex assertions in spec files
+- `have_text` negation in RSpec: `expect(state).not_to have_text("Error")`
+- README step reference table updated (all 13 step types listed)
+
+## 0.2.3
+
+- `have_exit_status` RSpec matcher and `exitstatus` drive command — exit code testing on all three levels (JSON + RSpec + drive)
+- `env` in start step — inject environment variables per test run
+- Per-step `timeout` override
+- `before_all` / `after_all` hooks for setup and teardown steps
+
 ## 0.2.2
 
-- `wait_for_exit` and `assert_exit` test steps — test process exit codes
+- `wait_for_exit` and `assert_exit` JSON test steps — test process exit codes
 
 ## 0.2.1
 

data/README.md

@@ -120,6 +120,7 @@ Interactive commands (drive mode):
   key <name>         Send keystroke (enter, tab, escape, up, down, left, right,
                      backspace, ctrl_c, ctrl_d)
   <text>             Send text to the TUI
+  exitstatus         Show process exit status (nil if running)
   exit               Quit drive mode
 
 Global options:
@@ -291,9 +292,13 @@ tui-td test examples/echo_test.json
 | `wait_for_text` | `"text"` | Wait until text appears |
 | `wait_for_stable` | — | Wait until output is stable |
 | `assert_text` | `"text"` | Assert that text exists on screen |
+| `assert_not_text` | `"text"` | Assert that text does NOT exist on screen |
+| `assert_regex` | `"pattern"` | Assert that regex pattern matches (e.g. `"error\|fail"`) |
 | `assert_fg` | `[row, col], "is": "color"` | Assert foreground color |
 | `assert_bg` | `[row, col], "is": "color"` | Assert background color |
 | `assert_style` | `[row, col], "bold": true` | Assert cell style (bold, italic, underline) |
+| `wait_for_exit` | — | Wait until the process exits |
+| `assert_exit` | `N` | Assert the process exit code equals N |
 | `screenshot` | `"path"` | Save PNG screenshot |
 | `html` | `"path"` | Save HTML render for browser viewing |
 | `close` | — | Close the TUI |

data/lib/tui_td/cli.rb

@@ -41,6 +41,7 @@ module TUITD
         opts.separator "  key <name>         Send keystroke (enter, tab, escape, up, down, left, right,"
         opts.separator "                     backspace, ctrl_c, ctrl_d)"
         opts.separator "  <text>             Send text to the TUI"
+        opts.separator "  exitstatus         Show process exit status (nil if running)"
         opts.separator "  exit               Quit drive mode"
         opts.separator ""
         opts.separator "Global options:"
@@ -188,6 +189,9 @@ module TUITD
             puts driver.state_json(pretty: true)
           elsif input == "raw"
             puts driver.raw_output[0..2000]
+          elsif input == "exitstatus"
+            status = driver.exitstatus
+            puts status ? "Exit status: #{status}" : "Process still running"
           elsif input.start_with?("key ")
             driver.send_keys(input.split(" ", 2).last.to_sym)
           else
@@ -327,12 +331,24 @@ module TUITD
         A test is a Hash or JSON string: {"name": "...", "steps": [...]}
 
         Top-level keys: name, steps, rows (default 40), cols (default 120),
-                        timeout (default 30), chdir
+                        timeout (default 30), chdir, before_all, after_all
+
+        before_all / after_all are arrays of steps that run before and
+        after the main steps list. Useful for setup/teardown:
+
+          "before_all": [{"start": "my_tui"}, {"wait_for_text": "> "}],
+          "steps": [{"send": "hello\\n"}],
+          "after_all": [{"close": true}]
+
+        Each step can also set a per-step "timeout" (in seconds):
+
+          {"wait_for_text": "Slow", "timeout": 60}
 
         Each step is an object with a single action key:
 
           {"start": "<command>"}
-              Start a TUI process in a PTY.
+              Start a TUI process in a PTY. Environment variables can be
+              passed via "env": {"FOO": "bar", "BAZ": "qux"}.
 
           {"send": "<text>"}
               Send text to the TUI. Use "\\n" for Enter.
@@ -350,6 +366,13 @@ module TUITD
           {"assert_text": "<substring>"}
               Fail if the text is not found in the current state.
 
+          {"assert_not_text": "<substring>"}
+              Fail if the text IS found in the current state.
+
+          {"assert_regex": "<pattern>"}
+              Fail if the regex pattern does not match anywhere.
+              Pattern syntax is Ruby regex (e.g. "error|fail|warn").
+
           {"assert_fg": [row, col], "is": "<color>"}
               Assert foreground color at cell. Colors: "default",
               named ANSI (red, green, blue, cyan, ...), "bright_*",
@@ -416,6 +439,13 @@ module TUITD
         have_text(expected)
             Passes if expected text appears anywhere in the terminal state.
             Usage: expect(state).to have_text("Hello")
+            Negate: expect(state).not_to have_text("Error")
+
+        have_regex(pattern)
+            Passes if the regex pattern matches anywhere. Accepts a Regexp
+            or a string (parsed as Ruby regex).
+            Usage: expect(state).to have_regex(/error|fail/)
+            Usage: expect(state).to have_regex("\\d{3}")
 
         have_fg(expected).at(row, col)
             Assert foreground color at [row, col] matches expected.
@@ -428,6 +458,13 @@ module TUITD
         have_style.at(row, col).with(bold: true, italic: false, ...)
             Assert style attributes at [row, col] match the given hash.
             Usage: expect(state).to have_style.at(0, 0).with(bold: true)
+
+        Driver matchers (work on TUITD::Driver, not State)
+        --------------------------------------------------
+
+        have_exit_status(expected)
+            Assert the process exit status matches expected.
+            Usage: expect(driver).to have_exit_status(0)
       HELP
       exit 0
     end

data/lib/tui_td/driver.rb

@@ -19,12 +19,13 @@ module TUITD
   class Driver
     attr_reader :command, :state
 
-    def initialize(command, rows: 40, cols: 120, timeout: 30, chdir: nil)
+    def initialize(command, rows: 40, cols: 120, timeout: 30, chdir: nil, env: {})
       @command = command
       @rows = rows
       @cols = cols
       @timeout = timeout
       @chdir = chdir
+      @env = env
       @state = nil
       @stdin = nil
       @stdout = nil
@@ -37,7 +38,7 @@ module TUITD
 
     # Start the TUI application in a PTY
     def start
-      env = { "TERM" => "xterm-256color", "COLUMNS" => @cols.to_s, "LINES" => @rows.to_s }
+      env = { "TERM" => "xterm-256color", "COLUMNS" => @cols.to_s, "LINES" => @rows.to_s }.merge(@env.transform_keys(&:to_s))
       spawn_opts = {}
       spawn_opts[:chdir] = @chdir if @chdir
 

data/lib/tui_td/matchers.rb

@@ -23,6 +23,17 @@ module TUITD
       failure_message_when_negated { |state| "expected terminal NOT to contain #{expected.inspect}" }
     end
 
+    RSpec::Matchers.define :have_regex do |pattern|
+      match do |state|
+        @regex = pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern.to_s)
+        state.find_text(@regex).any?
+      end
+
+      description { "match regex #{pattern.inspect}" }
+      failure_message { |state| "expected terminal to match #{pattern.inspect}" }
+      failure_message_when_negated { |state| "expected terminal NOT to match #{pattern.inspect}" }
+    end
+
     RSpec::Matchers.define :have_fg do |expected|
       chain(:at) { |row, col| @row, @col = row, col }
 
@@ -68,5 +79,21 @@ module TUITD
         "expected style at [#{@row},#{@col}] to be #{@expected.inspect}, but was #{@actual.inspect}"
       end
     end
+
+    # Works on a Driver instance, not State
+    RSpec::Matchers.define :have_exit_status do |expected|
+      match do |driver|
+        @actual = driver.exitstatus
+        @actual == expected
+      end
+
+      description { "have exit status #{expected}" }
+      failure_message do |driver|
+        "expected exit status #{expected}, but was #{@actual}"
+      end
+      failure_message_when_negated do |driver|
+        "expected exit status not to be #{expected}"
+      end
+    end
   end
 end

data/lib/tui_td/test_runner.rb

@@ -13,16 +13,20 @@ module TUITD
   #   {
   #     "name": "My test",
   #     "rows": 24, "cols": 80, "timeout": 10,
+  #     "chdir": "/path/to/workdir",
+  #     "before_all": [{"start": "my_tui", "env": {"FOO": "bar"}}],
   #     "steps": [
-  #       {"start": "my_tui"},
   #       {"wait_for_text": "> "},
   #       {"send": "hello\n"},
   #       {"assert_text": "hello"},
-  #       {"assert_fg": [0, 0], "is": "cyan"},
-  #       {"close": true}
-  #     ]
+  #       {"assert_fg": [0, 0], "is": "cyan"}
+  #     ],
+  #     "after_all": [{"close": true}]
   #   }
   #
+  # Per-step "timeout" overrides the top-level default:
+  #   {"wait_for_text": "Slow", "timeout": 60}
+  #
   class TestRunner
     Result = Struct.new(:step, :passed, :message, keyword_init: true)
 
@@ -30,47 +34,60 @@ module TUITD
       raw = source.is_a?(String) ? JSON.parse(source) : source
       @plan = raw.transform_keys(&:to_sym)
       @plan[:steps] = @plan[:steps].map { |s| s.transform_keys(&:to_sym) }
+      @plan[:before_all] = @plan[:before_all]&.map { |s| s.transform_keys(&:to_sym) }
+      @plan[:after_all] = @plan[:after_all]&.map { |s| s.transform_keys(&:to_sym) }
       @on_step = on_step
     end
 
     def run
-      results = []
-      all_passed = true
       driver = nil
       rows = @plan[:rows] || 40
       cols = @plan[:cols] || 120
       timeout = @plan[:timeout] || 30
       chdir = @plan[:chdir]
 
-      @plan[:steps].each do |step|
-        action = step.keys.first.to_s
-        value = step.values.first
-        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-        begin
-          r = case action
-              when "start"
-                driver&.close
-                driver = Driver.new(value.to_s, rows: rows, cols: cols, timeout: timeout, chdir: chdir)
-                driver.start
-                Result.new(step: action, passed: true, message: "Started: #{value}")
-
-              when "send"
-                ensure_driver!(driver)
-                driver.send(value.to_s)
-                Result.new(step: action, passed: true, message: "Sent #{value.to_s.length} characters")
+      hooks = [
+        { label: :before_all, steps: @plan[:before_all] || [] },
+        { label: :main, steps: @plan[:steps] },
+        { label: :after_all, steps: @plan[:after_all] || [] }
+      ]
 
-              when "send_key"
-                ensure_driver!(driver)
-                driver.send_keys(value.to_s.to_sym)
-                Result.new(step: action, passed: true, message: "Sent key: #{value}")
+      all_results = []
+      all_passed = true
+      total_steps = hooks.sum { |p| p[:steps].size }
 
-              when "wait_for_text"
-                ensure_driver!(driver)
-                driver.wait_for_text(value.to_s)
-                Result.new(step: action, passed: true, message: "Found: #{value}")
+      hooks.each do |phase|
+        phase[:steps].each do |step|
+          action = step.keys.first.to_s
+          value = step.values.first
 
-              when "wait_for_stable"
+          begin
+            step_timeout = step[:timeout] || timeout
+            r = case action
+                when "start"
+                  driver&.close
+                  env = step[:env] || {}
+                  env = env.transform_keys(&:to_sym).transform_values(&:to_s) if env.is_a?(Hash)
+                  driver = Driver.new(value.to_s, rows: rows, cols: cols, timeout: step_timeout, chdir: chdir, env: env)
+                  driver.start
+                  Result.new(step: action, passed: true, message: "Started: #{value}")
+
+                when "send"
+                  ensure_driver!(driver)
+                  driver.send(value.to_s)
+                  Result.new(step: action, passed: true, message: "Sent #{value.to_s.length} characters")
+
+                when "send_key"
+                  ensure_driver!(driver)
+                  driver.send_keys(value.to_s.to_sym)
+                  Result.new(step: action, passed: true, message: "Sent key: #{value}")
+
+                when "wait_for_text"
+                  ensure_driver!(driver)
+                  driver.wait_for_text(value.to_s)
+                  Result.new(step: action, passed: true, message: "Found: #{value}")
+
+                when "wait_for_stable"
                 ensure_driver!(driver)
                 driver.wait_for_stable
                 Result.new(step: action, passed: true, message: "Stable")
@@ -84,6 +101,25 @@ module TUITD
                   Result.new(step: action, passed: false, message: "Text NOT found: #{value}")
                 end
 
+              when "assert_not_text"
+                ensure_driver!(driver)
+                state = State.new(driver.state_data)
+                if state.find_text(value.to_s).any?
+                  Result.new(step: action, passed: false, message: "Text found but should not be: #{value}")
+                else
+                  Result.new(step: action, passed: true, message: "Text not found: #{value}")
+                end
+
+              when "assert_regex"
+                ensure_driver!(driver)
+                state = State.new(driver.state_data)
+                pattern = Regexp.new(value.to_s)
+                if state.find_text(pattern).any?
+                  Result.new(step: action, passed: true, message: "Regex matched: #{value}")
+                else
+                  Result.new(step: action, passed: false, message: "Regex did not match: #{value}")
+                end
+
               when "assert_fg"
                 ensure_driver!(driver)
                 row, col = coords(step)
@@ -165,7 +201,7 @@ module TUITD
           r = Result.new(step: action, passed: false, message: "#{e.class}: #{e.message}")
         end
 
-        results << r
+        all_results << r
         all_passed &&= r.passed
 
         if @on_step
@@ -176,8 +212,8 @@ module TUITD
             # ignore — state retrieval is best-effort
           end
           @on_step.call(
-            index: results.size - 1,
-            total: @plan[:steps].size,
+            index: all_results.size - 1,
+            total: total_steps,
             action: action,
             value: value,
             result: r,
@@ -186,13 +222,14 @@ module TUITD
           )
         end
       end
+      end
 
       driver&.close
 
       {
         name: @plan[:name] || "(unnamed)",
         passed: all_passed,
-        results: results.map(&:to_h)
+        results: all_results.map(&:to_h)
       }
     end
 

data/lib/tui_td/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TUITD
-  VERSION = "0.2.2"
+  VERSION = "0.2.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tui-td
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Haluk Durmus