如何测试具备交互与文件执行模式的Python命令行应用？

Hey there! Let's break down the best tools and practices for testing your custom Python CLI app—since you're not using frameworks like Click or Clint, we'll focus on solutions that play well with hand-built command-line interfaces, covering both unit and integration testing.

Unit Testing: Test Core Logic in Isolation #

Your interactive mode uses Python's built-in cmd module, which makes unit testing straightforward—you don't need to spin up a full shell to test individual commands. Instead, you can directly instantiate your CMD subclass and call its do_* methods to validate core functionality.

Using pytest (No Extra Libraries Needed) #

Here's how to test a command method directly, capturing its output:

import pytest
from io import StringIO
import sys
from your_app import YourCLICmd  # Replace with your actual CMD subclass

def test_do_x_command():
    # Redirect stdout to capture the command's output
    original_stdout = sys.stdout
    captured_output = StringIO()
    sys.stdout = captured_output

    # Create an instance of your CLI
    cli = YourCLICmd()
    # Call the command method directly with arguments
    cli.do_x("sample_argument")

    # Restore stdout and extract the captured text
    sys.stdout = original_stdout
    output = captured_output.getvalue().strip()

    # Assert the expected result
    assert output == "Expected output from do_x with sample_argument"

You can also use pytest fixtures to reduce boilerplate for repeated setup/teardown:

@pytest.fixture
def cli_with_captured_output():
    original_stdout = sys.stdout
    captured_output = StringIO()
    sys.stdout = captured_output
    cli = YourCLICmd()
    yield cli, captured_output
    # Teardown: reset stdout
    sys.stdout = original_stdout

def test_do_y_command(cli_with_captured_output):
    cli, output = cli_with_captured_output
    cli.do_y("another_arg")
    assert output.getvalue().strip() == "Success: do_y executed"

Integration Testing: Validate Full CLI Behavior #

For testing the actual end-to-end behavior—like running plcli to enter interactive mode, or executing commands via an input file—these tools are your best bets:

1. subprocess (Built-in, No Extra Dependencies) #

This is the most flexible, native way to test full CLI invocations. You can spawn child processes to run your command and capture stdout/stderr.

Testing File Execution Mode:

import subprocess

def test_file_execution():
    # Run your CLI with an input file
    result = subprocess.run(
        ["plcli", "test_commands.txt"],  # Or ["python", "-m", "your_app", ...] if using a module
        capture_output=True,
        text=True
    )

    # Verify the command succeeded
    assert result.returncode == 0
    # Check that the expected output was produced
    assert "Result of command 1" in result.stdout
    assert "Result of command 2" in result.stdout

Testing Interactive Mode:

Use subprocess.Popen to send commands to the interactive shell:

def test_interactive_shell():
    proc = subprocess.Popen(
        ["plcli"],
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True
    )

    # Send commands to the shell: run do_x, then quit
    stdout, stderr = proc.communicate(input="do_x test_arg\nquit\n")

    assert proc.returncode == 0
    assert "Expected output from do_x" in stdout
    assert stderr == ""  # Ensure no errors were thrown

2. pexpect (For Complex Interactive Flows) #

If your CLI has more involved interactions—like prompts, confirmations, or multi-step workflows—pexpect simplifies waiting for specific prompts and sending inputs.

First install it: pip install pexpect

Example test for a flow with prompts:

import pexpect

def test_interactive_prompt_flow():
    # Spawn the CLI process
    child = pexpect.spawn("plcli")
    
    # Wait for the (cmd)> prompt to appear
    child.expect(r"\(cmd\)> ")
    
    # Send a command that triggers a prompt
    child.sendline("delete_item")
    # Wait for the confirmation prompt
    child.expect("Are you sure? (y/n): ")
    # Send confirmation
    child.sendline("y")
    
    # Verify the success message appears
    child.expect("Item deleted successfully")
    # Wait for the next prompt
    child.expect(r"\(cmd\)> ")
    
    # Exit the shell
    child.sendline("quit")
    child.expect(pexpect.EOF)
    
    # Ensure the process exited cleanly
    assert child.exitstatus == 0

3. unittest.mock (Mock External Dependencies) #

When testing file execution mode, avoid relying on real test files—use unittest.mock to patch file reading logic instead. This makes tests faster and more reliable.

from unittest.mock import mock_open, patch
from your_app import process_input_file  # Replace with your file-processing function

def test_process_input_file():
    # Mock the content of an input file
    mock_file_content = "do_x\n do_y --option\n"
    
    # Patch the built-in open function to return our mock content
    with patch("builtins.open", mock_open(read_data=mock_file_content)):
        # Call the function that reads and executes the file
        execution_results = process_input_file("fake_input.txt")
        
        # Assert that both commands were executed correctly
        assert execution_results["do_x"] == "Success"
        assert execution_results["do_y"] == "Success with option"

Key Best Practices #

• Split unit and integration tests: Keep unit tests fast by testing individual do_* methods in isolation, and reserve integration tests for full CLI workflows.
• Capture and validate all output: Always check stdout/stderr to ensure commands produce the expected results and handle errors properly.
• Mock external resources: Use mocks for file systems, APIs, or other external dependencies to avoid flaky tests.
• Test edge cases: Validate empty input files, invalid commands, malformed arguments, and error scenarios to ensure your CLI handles them gracefully.

内容的提问来源于stack exchange，提问作者riser101