tui-td 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b74325984554c843a191d5affcf77472229000da6f14551c26ca2e6f1b0425cd
-  data.tar.gz: 2ddeb1aaedfc23ca62e3e791bb254950ef4432a32f0031e0a144f7567e2a3785
+  metadata.gz: 739ccd98a6d9a5ee8f29eadfdaaaa86cde8ee67cebf7bd9c293a20e1785f4bdb
+  data.tar.gz: bbeb1b4fcc9def290a68ee73df31d63d4fb3cb5a7a9a55b8d8cf5b8a57394885
 SHA512:
-  metadata.gz: b02944c10ed90a607ccfadd80fe80237a1bd5d50bba8e92320875c3cc71181f04057d2cad78648f5ddefee7a149b179c215c12b0ed61a19af7363b658090e36a
-  data.tar.gz: fe0f2b747cc15fe39da0195c83371ef44c457194f1648aa5e4e03f525ac856a60f3561a482012009054158350d354ea7cf28a04ab75eb9d660c1712203364373
+  metadata.gz: 6bb830eee8c25605c0cc1ecf7e5692fe5db1144c5c7cc2a6144367139056c6a2aa8650390429647d51b263058c21e78b46ee01c085fd0662ef3879ca551184e3
+  data.tar.gz: cbefe0d9f7483787190763563d5a1919aa8c476c1b57cddd704b981974b652b3b1734c59c60031ffd12e59d940a4a07f1abe937ab35012249a88a7303ca29073

data/CHANGELOG.md

@@ -1,8 +1,15 @@
 # CHANGELOG
 
+## 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:

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.
@@ -428,6 +444,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

@@ -68,5 +68,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")
@@ -165,7 +182,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 +193,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 +203,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.3"
 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.3
 platform: ruby
 authors:
 - Haluk Durmus