From 77eb15527ecae907b9941b2053c56e8f2ebb41fd Mon Sep 17 00:00:00 2001 From: 7000pctAUTO Date: Fri, 6 Feb 2026 01:09:50 +0000 Subject: [PATCH] Initial upload: regex-humanizer-cli with CI/CD workflow --- tests/test_translator.py | 221 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 221 insertions(+) create mode 100644 tests/test_translator.py diff --git a/tests/test_translator.py b/tests/test_translator.py new file mode 100644 index 0000000..346f9be --- /dev/null +++ b/tests/test_translator.py @@ -0,0 +1,221 @@ +"""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("(?Ptest)") + 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("(? 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)