222 lines
8.1 KiB
Python
222 lines
8.1 KiB
Python
"""Tests for the regex translator."""
|
|
|
|
import pytest
|
|
from regex_humanizer.translator import RegexTranslator, translate_regex
|
|
|
|
|
|
class TestRegexTranslator:
|
|
"""Test cases for RegexTranslator."""
|
|
|
|
def test_translate_simple_literal(self):
|
|
"""Test translating a simple literal."""
|
|
result = translate_regex("hello")
|
|
assert "hello" in result.lower() or "hello" in result
|
|
|
|
def test_translate_character_class(self):
|
|
"""Test translating a character class."""
|
|
result = translate_regex("[a-z]")
|
|
assert "any" in result.lower() and ("a" in result.lower() or "z" in result.lower())
|
|
|
|
def test_translate_negated_class(self):
|
|
"""Test translating a negated character class."""
|
|
result = translate_regex("[^0-9]")
|
|
assert "except" in result.lower() or "not" in result.lower()
|
|
|
|
def test_translate_digit_class(self):
|
|
"""Test translating digit shorthand."""
|
|
result = translate_regex("\\d")
|
|
assert "digit" in result.lower()
|
|
|
|
def test_translate_non_digit_class(self):
|
|
"""Test translating non-digit shorthand."""
|
|
result = translate_regex("\\D")
|
|
assert "non-digit" in result.lower() or "non digit" in result.lower()
|
|
|
|
def test_translate_word_class(self):
|
|
"""Test translating word character shorthand."""
|
|
result = translate_regex("\\w")
|
|
assert "word" in result.lower()
|
|
|
|
def test_translate_whitespace_class(self):
|
|
"""Test translating whitespace shorthand."""
|
|
result = translate_regex("\\s")
|
|
assert "whitespace" in result.lower()
|
|
|
|
def test_translate_plus_quantifier(self):
|
|
"""Test translating plus quantifier."""
|
|
result = translate_regex("a+")
|
|
assert "one or more" in result.lower() or "1 or more" in result.lower()
|
|
|
|
def test_translate_star_quantifier(self):
|
|
"""Test translating star quantifier."""
|
|
result = translate_regex("b*")
|
|
assert "zero or more" in result.lower() or "0 or more" in result.lower()
|
|
|
|
def test_translate_question_quantifier(self):
|
|
"""Test translating question mark quantifier."""
|
|
result = translate_regex("c?")
|
|
assert "optional" in result.lower() or "0 or 1" in result.lower()
|
|
|
|
def test_translate_range_quantifier(self):
|
|
"""Test translating range quantifier."""
|
|
result = translate_regex("a{2,5}")
|
|
assert "between" in result.lower() and ("2" in result or "2" in result.lower())
|
|
|
|
def test_translate_exact_quantifier(self):
|
|
"""Test translating exact count quantifier."""
|
|
result = translate_regex("x{3}")
|
|
assert "exactly" in result.lower() and "3" in result
|
|
|
|
def test_translate_lazy_quantifier(self):
|
|
"""Test translating lazy quantifier."""
|
|
result = translate_regex(".+?")
|
|
assert "lazy" in result.lower()
|
|
|
|
def test_translate_capturing_group(self):
|
|
"""Test translating a capturing group."""
|
|
result = translate_regex("(test)")
|
|
assert "capturing" in result.lower() or "group" in result.lower()
|
|
|
|
def test_translate_non_capturing_group(self):
|
|
"""Test translating a non-capturing group."""
|
|
result = translate_regex("(?:test)")
|
|
assert "non-capturing" in result.lower()
|
|
|
|
def test_translate_named_group(self):
|
|
"""Test translating a named group."""
|
|
result = translate_regex("(?P<name>test)")
|
|
assert "name" in result.lower() or "named" in result.lower()
|
|
|
|
def test_translate_lookahead(self):
|
|
"""Test translating a positive lookahead."""
|
|
result = translate_regex("(?=test)")
|
|
assert "followed" in result.lower()
|
|
|
|
def test_translate_negative_lookahead(self):
|
|
"""Test translating a negative lookahead."""
|
|
result = translate_regex("(?!test)")
|
|
assert "not followed" in result.lower() or "not" in result.lower()
|
|
|
|
def test_translate_lookbehind(self):
|
|
"""Test translating a lookbehind."""
|
|
result = translate_regex("(?<=test)")
|
|
assert "preceded" in result.lower()
|
|
|
|
def test_translate_negative_lookbehind(self):
|
|
"""Test translating a negative lookbehind."""
|
|
result = translate_regex("(?<!test)")
|
|
assert "not preceded" in result.lower()
|
|
|
|
def test_translate_anchor_start(self):
|
|
"""Test translating a start anchor."""
|
|
result = translate_regex("^start")
|
|
assert "start" in result.lower()
|
|
|
|
def test_translate_anchor_end(self):
|
|
"""Test translating an end anchor."""
|
|
result = translate_regex("end$")
|
|
assert "end" in result.lower()
|
|
|
|
def test_translate_word_boundary(self):
|
|
"""Test translating a word boundary."""
|
|
result = translate_regex("\\bword\\b")
|
|
assert "word boundary" in result.lower()
|
|
|
|
def test_translate_dot(self):
|
|
"""Test translating a dot."""
|
|
result = translate_regex(".")
|
|
assert "any" in result.lower() and "character" in result.lower()
|
|
|
|
def test_translate_alternation(self):
|
|
"""Test translating alternation."""
|
|
result = translate_regex("cat|dog")
|
|
assert "cat" in result.lower() or "dog" in result.lower()
|
|
|
|
def test_translate_complex_pattern(self):
|
|
"""Test translating a complex pattern."""
|
|
pattern = r"^\d{3}-\d{4}$"
|
|
result = translate_regex(pattern)
|
|
|
|
assert len(result) > 0
|
|
assert "digit" in result.lower() or "3" in result
|
|
|
|
def test_translate_email_pattern(self):
|
|
"""Test translating an email pattern."""
|
|
pattern = r"[a-z]+@[a-z]+\.[a-z]+"
|
|
result = translate_regex(pattern)
|
|
|
|
assert "any" in result.lower() or "@" in result
|
|
|
|
def test_translate_url_pattern(self):
|
|
"""Test translating a URL pattern."""
|
|
pattern = r"https?://[^\\s]+"
|
|
result = translate_regex(pattern)
|
|
|
|
assert len(result) > 0
|
|
|
|
def test_translate_escaped_char(self):
|
|
"""Test translating an escaped character."""
|
|
result = translate_regex("\\.")
|
|
assert "." in result or "period" in result.lower()
|
|
|
|
def test_translate_whitespace_literal(self):
|
|
"""Test translating a literal space."""
|
|
result = translate_regex(" ")
|
|
assert "space" in result.lower()
|
|
|
|
def test_translate_tab_literal(self):
|
|
"""Test translating a tab character."""
|
|
result = translate_regex("\\t")
|
|
assert "escape" in result.lower() or "\\t" in result or "tab" in result.lower()
|
|
|
|
def test_translate_backreference(self):
|
|
"""Test translating a backreference."""
|
|
result = translate_regex(r"(a)\\1")
|
|
assert "same as" in result.lower() or "capture" in result.lower() or "\\1" in result
|
|
|
|
def test_translate_empty_pattern(self):
|
|
"""Test translating an empty pattern."""
|
|
result = translate_regex("")
|
|
assert len(result) >= 0
|
|
|
|
def test_translate_with_js_flavor(self):
|
|
"""Test translating with JavaScript flavor."""
|
|
result = translate_regex("test", flavor="javascript")
|
|
assert len(result) > 0
|
|
|
|
def test_translate_with_python_flavor(self):
|
|
"""Test translating with Python flavor."""
|
|
result = translate_regex("test", flavor="python")
|
|
assert len(result) > 0
|
|
|
|
|
|
class TestRegexTranslatorClass:
|
|
"""Test the RegexTranslator class directly."""
|
|
|
|
def test_translator_initialization(self):
|
|
"""Test translator initialization with default flavor."""
|
|
translator = RegexTranslator()
|
|
assert translator.flavor == "pcre"
|
|
|
|
def test_translator_custom_flavor(self):
|
|
"""Test translator initialization with custom flavor."""
|
|
translator = RegexTranslator("javascript")
|
|
assert translator.flavor == "javascript"
|
|
|
|
def test_translate_returns_string(self):
|
|
"""Test that translate returns a string."""
|
|
translator = RegexTranslator()
|
|
result = translator.translate("test")
|
|
assert isinstance(result, str)
|
|
|
|
def test_translate_empty_sequence(self):
|
|
"""Test translating an empty sequence node."""
|
|
from regex_humanizer.parser import RegexParser, NodeType, RegexNode
|
|
|
|
parser = RegexParser("")
|
|
ast = parser.parse()
|
|
translator = RegexTranslator()
|
|
|
|
result = translator._translate_node(ast)
|
|
assert isinstance(result, str)
|