225 lines
8.0 KiB
Python
225 lines
8.0 KiB
Python
"""Tests for the test case generator."""
|
|
|
|
import re
|
|
import pytest
|
|
from regex_humanizer.test_generator import (
|
|
TestCaseGenerator,
|
|
generate_test_cases,
|
|
)
|
|
|
|
|
|
class TestTestCaseGenerator:
|
|
"""Test cases for TestCaseGenerator."""
|
|
|
|
def test_generate_simple_literal(self):
|
|
"""Test generating test cases for a simple literal."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("hello", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert "hello" in matching or len(matching[0]) > 0
|
|
|
|
def test_generate_character_class(self):
|
|
"""Test generating test cases for a character class."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("[abc]", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert len(matching[0]) == 1
|
|
assert matching[0] in ["a", "b", "c"]
|
|
|
|
def test_generate_quantifier_plus(self):
|
|
"""Test generating test cases for plus quantifier."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("a+", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert "a" in matching[0]
|
|
|
|
def test_generate_quantifier_star(self):
|
|
"""Test generating test cases for star quantifier."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("b*", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert all("b" in m for m in matching)
|
|
|
|
def test_generate_quantifier_question(self):
|
|
"""Test generating test cases for question quantifier."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("c?", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert len(matching[0]) <= 1
|
|
|
|
def test_generate_digit_class(self):
|
|
"""Test generating test cases for digit class."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("\\d+", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert matching[0].isdigit()
|
|
|
|
def test_generate_word_class(self):
|
|
"""Test generating test cases for word class."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("\\w+", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
|
|
def test_generate_non_matching_simple(self):
|
|
"""Test generating non-matching test cases."""
|
|
generator = TestCaseGenerator("pcre")
|
|
non_matching = generator.generate_non_matching("hello", count=3)
|
|
|
|
assert len(non_matching) >= 1
|
|
pattern = re.compile("hello")
|
|
for test_str in non_matching:
|
|
assert pattern.search(test_str) is None
|
|
|
|
def test_generate_non_matching_character_class(self):
|
|
"""Test generating non-matching cases for character class."""
|
|
generator = TestCaseGenerator("pcre")
|
|
non_matching = generator.generate_non_matching("[abc]", count=3)
|
|
|
|
assert len(non_matching) >= 1
|
|
for test_str in non_matching:
|
|
if len(test_str) > 0:
|
|
assert test_str[0] not in ["a", "b", "c"]
|
|
|
|
def test_generate_phone_pattern(self):
|
|
"""Test generating test cases for phone pattern."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("\\d{3}-\\d{4}", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert "-" in matching[0]
|
|
parts = matching[0].split("-")
|
|
assert len(parts) == 2
|
|
assert len(parts[0]) == 3
|
|
assert len(parts[1]) == 4
|
|
|
|
def test_generate_with_flavor_js(self):
|
|
"""Test generating test cases with JavaScript flavor."""
|
|
generator = TestCaseGenerator("javascript")
|
|
matching = generator.generate_matching("test", count=2)
|
|
|
|
assert len(matching) >= 1
|
|
|
|
def test_generate_with_flavor_python(self):
|
|
"""Test generating test cases with Python flavor."""
|
|
generator = TestCaseGenerator("python")
|
|
matching = generator.generate_matching("test", count=2)
|
|
|
|
assert len(matching) >= 1
|
|
|
|
def test_generate_matching_count(self):
|
|
"""Test that correct number of matching cases are generated."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("a", count=10)
|
|
|
|
assert len(matching) <= 10
|
|
|
|
def test_generate_non_matching_count(self):
|
|
"""Test that correct number of non-matching cases are generated."""
|
|
generator = TestCaseGenerator("pcre")
|
|
non_matching = generator.generate_non_matching("a", count=10)
|
|
|
|
assert len(non_matching) <= 10
|
|
|
|
def test_generate_complex_pattern(self):
|
|
"""Test generating test cases for a complex pattern."""
|
|
pattern = r"^(?:http|https)://[\\w.-]+\\.(?:com|org|net)$"
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching(pattern, count=3)
|
|
|
|
assert len(matching) >= 1
|
|
|
|
def test_generate_test_cases_function(self):
|
|
"""Test the generate_test_cases convenience function."""
|
|
result = generate_test_cases("test", flavor="pcre", matching_count=2, non_matching_count=2)
|
|
|
|
assert "pattern" in result
|
|
assert "flavor" in result
|
|
assert "matching" in result
|
|
assert "non_matching" in result
|
|
assert len(result["matching"]) >= 1
|
|
assert len(result["non_matching"]) >= 1
|
|
|
|
def test_generate_group_pattern(self):
|
|
"""Test generating test cases for a pattern with groups."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("(hello)\\s+(world)", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert " " in matching[0] or len(matching[0]) > 5
|
|
|
|
def test_generate_alternation(self):
|
|
"""Test generating test cases for alternation."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("cat|dog", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert matching[0] in ["cat", "dog"]
|
|
|
|
def test_generate_empty_pattern(self):
|
|
"""Test generating test cases for an empty pattern."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("", count=3)
|
|
|
|
assert len(matching) >= 0
|
|
|
|
def test_generate_anchored_pattern(self):
|
|
"""Test generating test cases for anchored patterns."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("^start", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert matching[0].startswith("start")
|
|
|
|
def test_generate_dotted_pattern(self):
|
|
"""Test generating test cases for a pattern with dots."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("a.b", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert len(matching[0]) == 3
|
|
assert matching[0][0] == "a"
|
|
assert matching[0][1] != "."
|
|
|
|
|
|
class TestTestCaseGeneratorEdgeCases:
|
|
"""Test edge cases for TestCaseGenerator."""
|
|
|
|
def test_generate_with_max_length(self):
|
|
"""Test that max_length is respected."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("a+", count=5, max_length=5)
|
|
|
|
for m in matching:
|
|
if len(m) > 0:
|
|
assert len(m) <= 5
|
|
|
|
def test_generate_nested_groups(self):
|
|
"""Test generating test cases for nested groups."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("((a)(b))", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
|
|
def test_generate_quantifier_range(self):
|
|
"""Test generating test cases for range quantifier."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("a{2,4}", count=3)
|
|
|
|
assert len(matching) >= 1
|
|
assert 2 <= len(matching[0]) <= 4
|
|
assert matching[0] == "a" * len(matching[0])
|
|
|
|
def test_generate_lookahead_pattern(self):
|
|
"""Test generating test cases for a lookahead pattern."""
|
|
generator = TestCaseGenerator("pcre")
|
|
matching = generator.generate_matching("(?=test)", count=3)
|
|
|
|
assert len(matching) >= 0
|