chore: Expose validate_scalar_strategy in the public API

Author: Stranger6667

docs/changelog.rst

@@ -4,6 +4,10 @@ Changelog
 `Unreleased`_ - TBD
 -------------------
 
+**Added**
+
+- Expose ``validate_scalar_strategy`` in the public API.
+
 `0.8.0`_ - 2022-04-27
 ---------------------
 

src/hypothesis_graphql/__init__.py

@@ -0,0 +1 @@
+from ._strategies.validation import validate_scalar_strategy

src/hypothesis_graphql/_strategies/strategy.py

@@ -11,11 +11,10 @@
 from hypothesis.strategies._internal.utils import cacheable
 
 from .. import nodes
-from ..types import AstPrinter, CustomScalars, Field, InputTypeNode, InterfaceOrObject, SelectionNodes
-from . import factories, primitives
+from ..types import AstPrinter, CustomScalarStrategies, Field, InputTypeNode, InterfaceOrObject, SelectionNodes
+from . import factories, primitives, validation
 from .ast import make_mutation, make_query
 from .containers import flatten
-from .validation import maybe_parse_schema, validate_custom_scalars, validate_fields
 
 BY_NAME = operator.attrgetter("name")
 EMPTY_LISTS_STRATEGY = st.builds(list)
@@ -45,7 +44,7 @@ class GraphQLStrategy:
     """Strategy for generating various GraphQL nodes."""
 
     schema: graphql.GraphQLSchema = attr.ib()
-    custom_scalars: CustomScalars = attr.ib(factory=dict)
+    custom_scalars: CustomScalarStrategies = attr.ib(factory=dict)
     # As the schema is assumed to be immutable, there are a few strategy caches possible for internal components
     # This is a per-method cache without limits as they are proportionate to the schema size
     _cache: Dict[str, Dict] = attr.ib(factory=dict)
@@ -341,13 +340,13 @@ def _make_strategy(
     *,
     type_: graphql.GraphQLObjectType,
     fields: Optional[Iterable[str]] = None,
-    custom_scalars: Optional[CustomScalars] = None,
+    custom_scalars: Optional[CustomScalarStrategies] = None,
 ) -> st.SearchStrategy[List[graphql.FieldNode]]:
     if fields is not None:
         fields = tuple(fields)
-        validate_fields(fields, type_.fields)
+        validation.validate_fields(fields, type_.fields)
     if custom_scalars:
-        validate_custom_scalars(custom_scalars)
+        validation.validate_custom_scalars(custom_scalars)
     return GraphQLStrategy(schema, custom_scalars or {}).selections(type_, fields=fields)
 
 
@@ -356,7 +355,7 @@ def queries(
     schema: Union[str, graphql.GraphQLSchema],
     *,
     fields: Optional[Iterable[str]] = None,
-    custom_scalars: Optional[CustomScalars] = None,
+    custom_scalars: Optional[CustomScalarStrategies] = None,
     print_ast: AstPrinter = graphql.print_ast,
 ) -> st.SearchStrategy[str]:
     """A strategy for generating valid queries for the given GraphQL schema.
@@ -368,7 +367,7 @@ def queries(
     :param custom_scalars: Strategies for generating custom scalars.
     :param print_ast: A function to convert the generated AST to a string.
     """
-    parsed_schema = maybe_parse_schema(schema)
+    parsed_schema = validation.maybe_parse_schema(schema)
     if parsed_schema.query_type is None:
         raise ValueError("Query type is not defined in the schema")
     return (
@@ -383,7 +382,7 @@ def mutations(
     schema: Union[str, graphql.GraphQLSchema],
     *,
     fields: Optional[Iterable[str]] = None,
-    custom_scalars: Optional[CustomScalars] = None,
+    custom_scalars: Optional[CustomScalarStrategies] = None,
     print_ast: AstPrinter = graphql.print_ast,
 ) -> st.SearchStrategy[str]:
     """A strategy for generating valid mutations for the given GraphQL schema.
@@ -395,7 +394,7 @@ def mutations(
     :param custom_scalars: Strategies for generating custom scalars.
     :param print_ast: A function to convert the generated AST to a string.
     """
-    parsed_schema = maybe_parse_schema(schema)
+    parsed_schema = validation.maybe_parse_schema(schema)
     if parsed_schema.mutation_type is None:
         raise ValueError("Mutation type is not defined in the schema")
     return (

src/hypothesis_graphql/_strategies/validation.py

@@ -5,7 +5,7 @@
 from hypothesis.errors import InvalidArgument
 
 from ..cache import cached_build_schema
-from ..types import CustomScalars
+from ..types import CustomScalarStrategies
 
 
 def maybe_parse_schema(schema: Union[str, graphql.GraphQLSchema]) -> graphql.GraphQLSchema:
@@ -14,21 +14,25 @@ def maybe_parse_schema(schema: Union[str, graphql.GraphQLSchema]) -> graphql.Gra
     return schema
 
 
-def validate_fields(fields: Tuple[str, ...], available_fields: Dict[str, graphql.GraphQLField]) -> None:
-    if not fields:
+def validate_fields(fields_: Tuple[str, ...], available_fields: Dict[str, graphql.GraphQLField]) -> None:
+    if not fields_:
         raise ValueError("If you pass `fields`, it should not be empty")
-    invalid_fields = tuple(field for field in fields if field not in available_fields)
+    invalid_fields = tuple(field for field in fields_ if field not in available_fields)
     if invalid_fields:
         raise ValueError(f"Unknown fields: {', '.join(invalid_fields)}")
 
 
-def validate_custom_scalars(custom_scalars: CustomScalars) -> None:
-    assert isinstance(custom_scalars, dict)
-    for name, strategy in custom_scalars.items():
-        if not isinstance(name, str):
-            raise InvalidArgument(f"scalar name {name!r} must be a string")
-        if not isinstance(strategy, st.SearchStrategy):
-            raise InvalidArgument(
-                f"custom_scalars[{name!r}]={strategy!r} must be a Hypothesis "
-                "strategy which generates AST nodes matching this scalar."
-            )
+def validate_custom_scalars(strategies: CustomScalarStrategies) -> None:
+    assert isinstance(strategies, dict)
+    for name, strategy in strategies.items():
+        validate_scalar_strategy(name, strategy)
+
+
+def validate_scalar_strategy(name: str, strategy: st.SearchStrategy) -> None:
+    if not isinstance(name, str):
+        raise InvalidArgument(f"scalar name {name!r} must be a string")
+    if not isinstance(strategy, st.SearchStrategy):
+        raise InvalidArgument(
+            f"custom_scalars[{name!r}]={strategy!r} must be a Hypothesis "
+            "strategy which generates AST nodes matching this scalar."
+        )

src/hypothesis_graphql/types.py

@@ -10,4 +10,4 @@
 InterfaceOrObject = Union[graphql.GraphQLObjectType, graphql.GraphQLInterfaceType]
 SelectionNodes = List[graphql.SelectionNode]
 AstPrinter = Callable[[graphql.Node], str]
-CustomScalars = Dict[str, st.SearchStrategy[graphql.ValueNode]]
+CustomScalarStrategies = Dict[str, st.SearchStrategy[graphql.ValueNode]]