more crappy tests

Author: bitplane

tests/integration/conftest.py

@@ -2,41 +2,87 @@
 
 import subprocess
 import pytest
+import os
 
 
-@pytest.fixture
-def demo_terminal():
-    """Run demo/terminal.py with pre-written input and capture output."""
-    import os
-    import tempfile
+class DemoTimeoutError(Exception):
+    """Custom exception for demo timeouts with screen debugging."""
+
+    def __init__(self, message, stdout="", stderr="", height=24):
+        super().__init__(message)
+        self.stdout = stdout
+        self.stderr = stderr
+
+        # Extract last `height` rows from stdout for screen debugging
+        if stdout:
+            lines = stdout.split("\n")
+            last_lines = lines[-height:] if len(lines) > height else lines
+            screen_content = "\n".join(last_lines)
+            enhanced_message = f"{message}\n\nLast {len(last_lines)} rows of screen:\n{screen_content}"
+        else:
+            enhanced_message = f"{message}\n\nNo stdout captured"
+
+        self.args = (enhanced_message,)
+
 
-    # Path to demo script relative to project root
+def _run_demo(input_commands, timeout=2.0):
+    """Internal function to run demo and return output."""
     demo_path = os.path.join(os.path.dirname(__file__), "..", "..", "demo", "terminal.py")
 
-    # Create a temporary file for output
-    with tempfile.NamedTemporaryFile(mode="w+", delete=False) as output_file:
-        output_path = output_file.name
+    try:
+        result = subprocess.run(
+            ["python3", demo_path],
+            input=input_commands,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd=os.path.dirname(demo_path),
+        )
+        return result.stdout
+    except subprocess.TimeoutExpired as e:
+        # Convert to our custom exception with screen debugging
+        stdout = e.stdout.decode("utf-8") if e.stdout else ""
+        stderr = e.stderr.decode("utf-8") if e.stderr else ""
+        raise DemoTimeoutError(f"Demo timed out after {timeout}s", stdout=stdout, stderr=stderr) from e
+
+
+@pytest.fixture
+def assert_demo_output():
+    """Assert that demo output contains expected text, with nice screen dump on failure."""
+
+    def _assert(commands, expected, timeout=2.0):
+        """Run demo with commands and assert output contains expected text.
+
+        Args:
+            commands: Commands to send to demo (include \r\n for newlines)
+            expected: String or list of strings that should appear in output
+            timeout: Timeout in seconds (default 2.0)
+        """
+        # Ensure commands end with exit
+        if not commands.strip().endswith("exit"):
+            commands = commands.rstrip() + "\r\nexit\r\n"
 
-    class DemoRunner:
-        def __init__(self, demo_path, output_path):
-            self.demo_path = demo_path
-            self.output_path = output_path
+        output = _run_demo(commands, timeout)
 
-        def run_with_input(self, input_commands):
-            """Run demo with given input commands and return output."""
-            process = subprocess.Popen(
-                f"printf '{input_commands}' | python3 {self.demo_path} > {self.output_path}",
-                shell=True,
-                cwd=os.path.dirname(self.demo_path),
-            )
-            process.wait()
+        # Handle both string and list expectations
+        if isinstance(expected, str):
+            expected = [expected]
 
-            with open(self.output_path, "r") as f:
-                return f.read()
+        # Check each expected string
+        for exp in expected:
+            if exp not in output:
+                # Pretty screen dump on failure
+                lines = output.split("\n")
+                screen_display = "\n".join(lines[-24:] if len(lines) > 24 else lines)
 
-    runner = DemoRunner(demo_path, output_path)
+                pytest.fail(
+                    f"Expected '{exp}' not found in output\n\n"
+                    f"=== Last {min(24, len(lines))} rows of screen ===\n"
+                    f"{screen_display}\n"
+                    f"=== End of screen ===\n\n"
+                    f"Full output ({len(output)} chars):\n{repr(output)}"
+                )
 
-    yield runner
+        return output  # Return for additional checks if needed
 
-    # Cleanup
-    os.unlink(output_path)
+    return _assert

tests/integration/test_demo_integration.py

@@ -6,49 +6,22 @@
 
 @pytest.mark.integration
 @pytest.mark.skipif(sys.platform == "win32", reason="Demo uses Unix terminal features")
-def test_demo_basic_command(demo_terminal):
+def test_demo_basic_command(assert_demo_output):
     """Test that demo terminal can execute basic commands."""
-    # Run demo with a simple command
-    output = demo_terminal.run_with_input("echo hello world\\r\\nexit\\r\\n")
-
-    # Should contain the command output
-    assert "hello world" in output, f"Expected 'hello world' in output: {repr(output)}"
-
-
-@pytest.mark.integration
-@pytest.mark.slow
-@pytest.mark.skipif(sys.platform == "win32", reason="Demo uses Unix terminal features")
-def test_demo_utf8_support(demo_terminal):
-    """Test that demo terminal handles UTF-8 correctly."""
-    # Run demo with UTF-8 command
-    output = demo_terminal.run_with_input("echo 'UTF-8: 🚽🪠💩 世界'\\r\\nexit\\r\\n")
-
-    # Should contain UTF-8 characters without corruption
-    assert "🚽" in output or "世界" in output, f"Expected UTF-8 chars in output: {repr(output)}"
-    # Should not contain replacement characters
-    assert "�" not in output, f"Found replacement character in output: {repr(output)}"
+    assert_demo_output("echo hello world", "hello world")
 
 
 @pytest.mark.integration
 @pytest.mark.skipif(sys.platform == "win32", reason="Demo uses Unix terminal features")
-def test_demo_multiple_commands(demo_terminal):
+def test_demo_multiple_commands(assert_demo_output):
     """Test demo terminal with multiple commands."""
-    # Run demo with multiple commands
-    commands = "echo first\\r\\necho second\\r\\npwd\\r\\nexit\\r\\n"
-    output = demo_terminal.run_with_input(commands)
-
-    # Should contain output from both commands
-    assert "first" in output, f"Expected 'first' in output: {repr(output)}"
-    assert "second" in output, f"Expected 'second' in output: {repr(output)}"
+    assert_demo_output("echo first\r\necho second\r\npwd", ["first", "second"])
 
 
 @pytest.mark.integration
 @pytest.mark.skipif(sys.platform == "win32", reason="Demo uses Unix terminal features")
-def test_demo_clean_exit(demo_terminal):
+def test_demo_clean_exit(assert_demo_output):
     """Test that demo exits cleanly."""
-    # Run demo with just exit command
-    output = demo_terminal.run_with_input("exit\\r\\n")
-
-    # Should produce some output (shell prompt, etc.) and exit cleanly
+    # Just verify exit works - fixture auto-adds exit if missing
+    output = assert_demo_output("", [])  # Empty commands, no expected output
     assert isinstance(output, str), "Should return string output"
-    # The fact that run_with_input returns means the process exited