254 lines
7.9 KiB
Python
254 lines
7.9 KiB
Python
"""Tests for the CLI interface."""
|
|
|
|
import json
|
|
import pytest
|
|
from click.testing import CliRunner
|
|
from regex_humanizer.cli import main, explain, test, flavors, validate, convert
|
|
|
|
|
|
class TestCLIMain:
|
|
"""Test the main CLI entry point."""
|
|
|
|
def test_main_help(self):
|
|
"""Test that main help works."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(main, ["--help"])
|
|
|
|
assert result.exit_code == 0
|
|
assert "Regex Humanizer" in result.output
|
|
assert "explain" in result.output
|
|
assert "test" in result.output
|
|
assert "interactive" in result.output
|
|
|
|
|
|
class TestCLIExplain:
|
|
"""Test the explain command."""
|
|
|
|
def test_explain_simple_literal(self):
|
|
"""Test explaining a simple literal."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(explain, ["hello"])
|
|
|
|
assert result.exit_code == 0
|
|
assert "Pattern" in result.output or "hello" in result.output
|
|
|
|
def test_explain_with_flavor_option(self):
|
|
"""Test explaining with a flavor option."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(explain, ["--flavor", "javascript", "test"])
|
|
|
|
assert result.exit_code == 0
|
|
assert "Flavor" in result.output or "javascript" in result.output
|
|
|
|
def test_explain_with_json_output(self):
|
|
"""Test explaining with JSON output."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(explain, ["--output", "json", "\\d+"])
|
|
|
|
assert result.exit_code == 0
|
|
assert "{", "}" in result.output
|
|
|
|
def test_explain_with_verbose(self):
|
|
"""Test explaining with verbose flag."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(explain, ["--verbose", "\\d+"])
|
|
|
|
assert result.exit_code == 0
|
|
assert "Features" in result.output or "digit" in result.output.lower()
|
|
|
|
def test_explain_complex_pattern(self):
|
|
"""Test explaining a complex pattern."""
|
|
runner = CliRunner()
|
|
pattern = r"^(?:http|https)://[\w.-]+\.(?:com|org|net)$"
|
|
result = runner.invoke(explain, [pattern])
|
|
|
|
assert result.exit_code == 0
|
|
assert "Pattern" in result.output
|
|
|
|
def test_explain_phone_pattern(self):
|
|
"""Test explaining a phone pattern."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(explain, [r"\d{3}-\d{4}"])
|
|
|
|
assert result.exit_code == 0
|
|
|
|
def test_explain_character_class(self):
|
|
"""Test explaining a character class."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(explain, ["[a-zA-Z]+"])
|
|
|
|
assert result.exit_code == 0
|
|
|
|
|
|
class TestCLITest:
|
|
"""Test the test command."""
|
|
|
|
def test_test_simple_literal(self):
|
|
"""Test generating test cases for a simple literal."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(test, ["hello"])
|
|
|
|
assert result.exit_code == 0
|
|
assert "Matching" in result.output or "hello" in result.output
|
|
assert "Non-matching" in result.output
|
|
|
|
def test_test_with_count_option(self):
|
|
"""Test generating a specific number of test cases."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(test, ["--count", "3", "a"])
|
|
|
|
assert result.exit_code == 0
|
|
|
|
def test_test_with_json_output(self):
|
|
"""Test generating test cases with JSON output."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(test, ["--output", "json", "test"])
|
|
|
|
assert result.exit_code == 0
|
|
data = json.loads(result.output)
|
|
assert "matching" in data
|
|
assert "non_matching" in data
|
|
|
|
def test_test_phone_pattern(self):
|
|
"""Test generating test cases for a phone pattern."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(test, [r"\d{3}-\d{4}"])
|
|
|
|
assert result.exit_code == 0
|
|
assert "Matching" in result.output
|
|
|
|
def test_test_email_pattern(self):
|
|
"""Test generating test cases for an email pattern."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(test, [r"[a-z]+@[a-z]+\.[a-z]+"])
|
|
|
|
assert result.exit_code == 0
|
|
|
|
def test_test_quantifier_pattern(self):
|
|
"""Test generating test cases for a quantifier pattern."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(test, ["a{2,4}"])
|
|
|
|
assert result.exit_code == 0
|
|
|
|
|
|
class TestCLIFlavors:
|
|
"""Test the flavors command."""
|
|
|
|
def test_flavors_list(self):
|
|
"""Test listing available flavors."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(flavors)
|
|
|
|
assert result.exit_code == 0
|
|
assert "pcre" in result.output.lower()
|
|
assert "javascript" in result.output.lower()
|
|
assert "python" in result.output.lower()
|
|
|
|
|
|
class TestCLIValidate:
|
|
"""Test the validate command."""
|
|
|
|
def test_validate_valid_pattern(self):
|
|
"""Test validating a valid pattern."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(validate, ["hello"])
|
|
|
|
assert result.exit_code == 0
|
|
assert "PASSED" in result.output or "Validation" in result.output
|
|
|
|
def test_validate_with_flavor(self):
|
|
"""Test validating with a specific flavor."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(validate, ["--flavor", "javascript", "test"])
|
|
|
|
assert result.exit_code == 0
|
|
|
|
def test_validate_complex_pattern(self):
|
|
"""Test validating a complex pattern."""
|
|
runner = CliRunner()
|
|
pattern = r"^(?:http|https)://[\w.-]+\.(?:com|org|net)$"
|
|
result = runner.invoke(validate, [pattern])
|
|
|
|
assert result.exit_code == 0
|
|
|
|
|
|
class TestCLIConvert:
|
|
"""Test the convert command."""
|
|
|
|
def test_convert_pcre_to_js(self):
|
|
"""Test converting a pattern from PCRE to JavaScript."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(convert, ["(?P<test>hello)", "--from-flavor", "pcre", "--to-flavor", "javascript"])
|
|
|
|
assert result.exit_code == 0
|
|
assert "Converted" in result.output
|
|
|
|
def test_convert_with_defaults(self):
|
|
"""Test converting with default flavors."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(convert, ["test"])
|
|
|
|
assert result.exit_code == 0
|
|
assert "Original" in result.output
|
|
assert "Converted" in result.output
|
|
|
|
|
|
class TestCLIInteractive:
|
|
"""Test the interactive command."""
|
|
|
|
def test_interactive_command_exists(self):
|
|
"""Test that interactive command is available."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(main, ["interactive", "--help"])
|
|
|
|
assert result.exit_code == 0
|
|
assert "interactive" in result.output.lower()
|
|
|
|
def test_interactive_with_flavor(self):
|
|
"""Test interactive mode with a specific flavor."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(main, ["interactive", "--flavor", "python"])
|
|
|
|
assert result.exit_code == 0
|
|
|
|
|
|
class TestCLIIntegration:
|
|
"""Integration tests for CLI."""
|
|
|
|
def test_flavor_option_global(self):
|
|
"""Test that global flavor option works."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(main, ["--flavor", "python", "explain", "test"])
|
|
|
|
assert result.exit_code == 0
|
|
|
|
def test_error_handling_invalid_pattern(self):
|
|
"""Test error handling for invalid patterns."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(explain, ["["])
|
|
|
|
assert result.exit_code == 0
|
|
|
|
def test_output_json_structure(self):
|
|
"""Test JSON output has correct structure."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(explain, ["--output", "json", "\\d+"])
|
|
|
|
assert result.exit_code == 0
|
|
data = json.loads(result.output)
|
|
assert "pattern" in data
|
|
assert "flavor" in data
|
|
assert "explanation" in data
|
|
|
|
def test_output_test_json_structure(self):
|
|
"""Test JSON test output has correct structure."""
|
|
runner = CliRunner()
|
|
result = runner.invoke(test, ["--output", "json", "\\d"])
|
|
|
|
assert result.exit_code == 0
|
|
data = json.loads(result.output)
|
|
assert "pattern" in data
|
|
assert "matching" in data
|
|
assert "non_matching" in data
|