test_block_string: add fuzzing test for 'print_block_string'

Replicates graphql/graphql-js@541a449

Author: Cito

tests/language/test_block_string.py

@@ -1,9 +1,15 @@
+from typing import Optional
+
+from graphql.error import GraphQLSyntaxError
+from graphql.language import Source, Lexer, TokenKind
 from graphql.language.block_string import (
     dedent_block_string_value,
     print_block_string,
     get_block_string_indentation,
 )
 
+from ..utils import dedent, gen_fuzz_strings
+
 
 def join_lines(*args):
     return "\n".join(args)
@@ -132,3 +138,43 @@ def correctly_prints_string_with_a_first_line_indentation():
         assert print_block_string(s) == join_lines(
             '"""', "    first  ", "  line     ", "indentation", "     string", '"""'
         )
+
+    def correctly_print_random_strings():
+        def lex_value(s: str) -> Optional[str]:
+            lexer = Lexer(Source(s))
+            value = lexer.advance().value
+            assert lexer.advance().kind == TokenKind.EOF, "Expected EOF"
+            return value
+
+        # Testing with length >5 is taking exponentially more time. However it is
+        # highly recommended to test with increased limit if you make any change.
+        for fuzz_str in gen_fuzz_strings(allowed_chars='\n\t "a\\', max_length=5):
+            test_str = f'"""{fuzz_str}"""'
+
+            try:
+                test_value = lex_value(test_str)
+            except (AssertionError, GraphQLSyntaxError):
+                continue  # skip invalid values
+            assert isinstance(test_value, str)
+
+            printed_value = lex_value(print_block_string(test_value))
+
+            assert test_value == printed_value, dedent(
+                f"""
+                Expected lex_value(print_block_string({test_value!r})
+                  to equal {test_value!r}
+                  but got {printed_value!r}
+                """
+            )
+
+            printed_multiline_string = lex_value(
+                print_block_string(test_value, " ", True)
+            )
+
+            assert test_value == printed_multiline_string, dedent(
+                f"""
+                Expected lex_value(print_block_string({test_value!r}, ' ', True)
+                  to equal {test_value!r}
+                  but got {printed_multiline_string!r}
+                """
+            )

tests/utilities/test_strip_ignored_characters.py

@@ -8,7 +8,7 @@
 from graphql.utilities import strip_ignored_characters
 
 from ..fixtures import kitchen_sink_query, kitchen_sink_sdl  # noqa: F401
-from ..utils import dedent
+from ..utils import dedent, gen_fuzz_strings
 
 ignored_tokens = [
     # UnicodeBOM
@@ -374,39 +374,26 @@ def expect_stripped_string(block_str: str):
         expect_stripped_string('"""\n a\n b"""').to_equal('"""a\nb"""')
         expect_stripped_string('"""\na\n b\nc"""').to_equal('"""a\n b\nc"""')
 
+    def strips_ignored_characters_inside_random_block_strings():
         # Testing with length >5 is taking exponentially more time. However it is
         # highly recommended to test with increased limit if you make any change.
-        max_combination_length = 5
-        possible_chars = ["\n", " ", '"', "a", "\\"]
-        num_possible_chars = len(possible_chars)
-        num_combinations = 1
-        for length in range(1, max_combination_length):
-            num_combinations *= num_possible_chars
-            for combination in range(num_combinations):
-                test_str = '"""'
-
-                left_over = combination
-                for i in range(length):
-                    reminder = left_over % num_possible_chars
-                    test_str += possible_chars[reminder]
-                    left_over = (left_over - reminder) // num_possible_chars
-
-                test_str += '"""'
-
-                try:
-                    test_value = lex_value(test_str)
-                except (AssertionError, GraphQLSyntaxError):
-                    continue  # skip invalid values
-
-                stripped_value = lex_value(strip_ignored_characters(test_str))
-
-                assert test_value == stripped_value, dedent(
-                    f"""
-                    Expected lexValue(stripIgnoredCharacters({test_str!r})
-                      to equal {test_value!r}
-                      but got {stripped_value!r}
-                    """
-                )
+        for fuzz_str in gen_fuzz_strings(allowed_chars='\n\t "a\\', max_length=5):
+            test_str = f'"""{fuzz_str}"""'
+
+            try:
+                test_value = lex_value(test_str)
+            except (AssertionError, GraphQLSyntaxError):
+                continue  # skip invalid values
+
+            stripped_value = lex_value(strip_ignored_characters(test_str))
+
+            assert test_value == stripped_value, dedent(
+                f"""
+                Expected lexValue(stripIgnoredCharacters({test_str!r})
+                  to equal {test_value!r}
+                  but got {stripped_value!r}
+                """
+            )
 
     # noinspection PyShadowingNames
     def strips_kitchen_sink_query_but_maintains_the_exact_same_ast(

tests/utils/__init__.py

@@ -1,5 +1,6 @@
 """Test utilities"""
 
 from .dedent import dedent
+from .gen_fuzz_strings import gen_fuzz_strings
 
-__all__ = ["dedent"]
+__all__ = ["dedent", "gen_fuzz_strings"]

tests/utils/gen_fuzz_strings.py

@@ -0,0 +1,24 @@
+from typing import Generator
+
+__all__ = ["gen_fuzz_strings"]
+
+
+def gen_fuzz_strings(allowed_chars: str, max_length: int) -> Generator[str, None, None]:
+    """Generator that produces all possible combinations of allowed characters."""
+    num_allowed_chars = len(allowed_chars)
+
+    num_combinations = 0
+    for length in range(1, max_length + 1):
+        num_combinations += num_allowed_chars ** length
+
+    yield ""  # special case for empty string
+    for combination in range(num_combinations):
+        permutation = ""
+
+        left_over = combination
+        while left_over >= 0:
+            reminder = left_over % num_allowed_chars
+            permutation = allowed_chars[reminder] + permutation
+            left_over = (left_over - reminder) // num_allowed_chars - 1
+
+        yield permutation

tests/utils/test_dedent.py

@@ -1,4 +1,4 @@
-from ..utils import dedent
+from . import dedent
 
 
 def describe_dedent():

tests/utils/test_gen_fuzz_strings.py

@@ -0,0 +1,59 @@
+from . import gen_fuzz_strings
+
+
+def describe_gen_fuzz_strings():
+    def always_provide_empty_string():
+        assert list(gen_fuzz_strings(allowed_chars="", max_length=0)) == [""]
+        assert list(gen_fuzz_strings(allowed_chars="", max_length=1)) == [""]
+        assert list(gen_fuzz_strings(allowed_chars="a", max_length=0)) == [""]
+
+    def generate_strings_with_single_character():
+        assert list(gen_fuzz_strings(allowed_chars="a", max_length=1)) == ["", "a"]
+        assert list(gen_fuzz_strings(allowed_chars="abc", max_length=1)) == [
+            "",
+            "a",
+            "b",
+            "c",
+        ]
+
+    def generate_strings_with_multiple_character():
+        assert list(gen_fuzz_strings(allowed_chars="a", max_length=2)) == [
+            "",
+            "a",
+            "aa",
+        ]
+
+        assert list(gen_fuzz_strings(allowed_chars="abc", max_length=2)) == [
+            "",
+            "a",
+            "b",
+            "c",
+            "aa",
+            "ab",
+            "ac",
+            "ba",
+            "bb",
+            "bc",
+            "ca",
+            "cb",
+            "cc",
+        ]
+
+    def generate_strings_longer_than_possible_number_of_characters():
+        assert list(gen_fuzz_strings(allowed_chars="ab", max_length=3)) == [
+            "",
+            "a",
+            "b",
+            "aa",
+            "ab",
+            "ba",
+            "bb",
+            "aaa",
+            "aab",
+            "aba",
+            "abb",
+            "baa",
+            "bab",
+            "bba",
+            "bbb",
+        ]