feat: Negative testing

Signed-off-by: Dmitry Dygalo <dmitry@dygalo.dev>

Author: Stranger6667

.pre-commit-config.yaml

@@ -35,8 +35,5 @@ repos:
     rev: v0.15.0
     hooks:
       - id: ruff-format
-
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.0
-    hooks:
-      - id: ruff
+      - id: ruff-check
+        args: [--fix]

CHANGELOG.md

@@ -5,12 +5,13 @@
 ### Added
 
 - Support for Python 3.13 and 3.14.
+- Negative testing mode for generating invalid queries.
 
 ## [0.11.1] - 2024-08-06
 
 ### Added
 
-- The `allow_null` option that controls if optional arguments may be `null`. `True` by default. 
+- The `allow_null` option that controls if optional arguments may be `null`. `True` by default.
 
 ## [0.11.0] - 2023-11-29
 

README.md

@@ -143,6 +143,46 @@ The `hypothesis_graphql.nodes` module includes a few helpers to generate various
 
 They exist because classes like `graphql.StringValueNode` can't be directly used in `map` calls due to kwarg-only arguments.
 
+### Negative Testing
+
+`hypothesis-graphql` supports generating **invalid** GraphQL queries for negative testing. This is useful for testing error handling and validation logic in your GraphQL server.
+
+Use the `mode=Mode.NEGATIVE` parameter to generate queries that should be rejected:
+
+```python
+from hypothesis import given
+from hypothesis_graphql import queries, mode
+import requests
+
+SCHEMA = """
+type Query {
+    getUser(id: Int!, name: String!): User
+}
+
+type User {
+    id: Int!
+    name: String!
+}
+"""
+
+
+@given(queries(SCHEMA, mode=Mode.NEGATIVE))
+def test_server_rejects_invalid_queries(query):
+    # Generates queries with violations like:
+    # - Wrong types (String where Int expected)
+    # - Missing required arguments
+    # - Out-of-range integers
+    # - Null for non-null fields
+    # - Invalid enum values
+    response = requests.post("http://127.0.0.1/graphql", json={"query": query})
+
+    # Server should reject with 400 or return errors
+    if response.status_code == 200:
+        assert "errors" in response.json()
+```
+
+The `negative` parameter works with `queries()`, `mutations()`, and `from_schema()`.
+
 ## License
 
 The code in this project is licensed under [MIT license](https://opensource.org/licenses/MIT).

src/hypothesis_graphql/__init__.py

@@ -1,2 +1,3 @@
+from ._strategies.mode import Mode  # noqa: F401
 from ._strategies.validation import validate_scalar_strategy  # noqa: F401
 from .strategies import from_schema, mutations, queries  # noqa: F401

src/hypothesis_graphql/_strategies/mode.py

@@ -0,0 +1,14 @@
+import enum
+
+
+class Mode(enum.Enum):
+    """Generation mode for GraphQL queries.
+
+    POSITIVE: Generate valid queries that pass schema validation.
+    NEGATIVE: Generate invalid queries with intentional violations
+              (wrong types, missing required args, invalid enums, etc.)
+              for testing error handling.
+    """
+
+    POSITIVE = enum.auto()
+    NEGATIVE = enum.auto()

src/hypothesis_graphql/_strategies/negative.py

@@ -0,0 +1,19 @@
+from hypothesis import strategies as st
+
+
+class ViolationTracker:
+    """Tracks violation injection state to guarantee at least one per query."""
+
+    def __init__(self) -> None:
+        self.has_injected = False
+
+    def should_inject(self, draw: st.DrawFn) -> bool:
+        """Decide whether to inject a violation."""
+        if self.has_injected:
+            return draw(st.booleans())
+        draw(st.just(True))
+        return True
+
+    def mark_injected(self) -> None:
+        """Mark that a violation was actually injected."""
+        self.has_injected = True

src/hypothesis_graphql/_strategies/primitives.py

@@ -24,9 +24,25 @@ def _string(
 
 INTEGER_STRATEGY = st.integers(min_value=MIN_INT, max_value=MAX_INT).map(nodes.Int)
 FLOAT_STRATEGY = st.floats(allow_infinity=False, allow_nan=False).map(nodes.Float)
+STRING_STRATEGY = st.text().map(_string)
 BOOLEAN_STRATEGY = st.booleans().map(nodes.Boolean)
 NULL_STRATEGY = st.just(nodes.Null)
 
+# Mapping of type names to their strategies for exclusion logic
+_PRIMITIVE_STRATEGIES = {
+    "Int": INTEGER_STRATEGY,
+    "Float": FLOAT_STRATEGY,
+    "String": STRING_STRATEGY,
+    "Boolean": BOOLEAN_STRATEGY,
+    "Null": NULL_STRATEGY,
+}
+
+
+def _except(*exclude: str) -> st.SearchStrategy[graphql.ValueNode]:
+    # Exclude Null from wrong type violations - null is valid for nullable fields
+    exclude_with_null = set(exclude) | {"Null"}
+    return st.one_of(*(strategy for name, strategy in _PRIMITIVE_STRATEGIES.items() if name not in exclude_with_null))
+
 
 @lru_cache(maxsize=16)
 def scalar(
@@ -121,3 +137,60 @@ def list_(
     default: Optional[graphql.ValueNode] = None,
 ) -> st.SearchStrategy[graphql.ListValueNode]:
     return maybe_default(maybe_null(strategy.map(nodes.List), nullable), default=default)
+
+
+def invalid_int() -> st.SearchStrategy[graphql.ValueNode]:
+    return _except("Int")
+
+
+def invalid_string() -> st.SearchStrategy[graphql.ValueNode]:
+    return _except("String")
+
+
+def invalid_float() -> st.SearchStrategy[graphql.ValueNode]:
+    # Int coerces to Float in GraphQL, so exclude both
+    return _except("Float", "Int")
+
+
+def invalid_boolean() -> st.SearchStrategy[graphql.ValueNode]:
+    return _except("Boolean")
+
+
+def invalid_id() -> st.SearchStrategy[graphql.ValueNode]:
+    return st.one_of(FLOAT_STRATEGY, BOOLEAN_STRATEGY)
+
+
+def wrong_type_for(ty: str) -> st.SearchStrategy[graphql.ValueNode]:
+    if ty == "Int":
+        return invalid_int()
+    if ty == "String":
+        return invalid_string()
+    if ty == "Float":
+        return invalid_float()
+    if ty == "Boolean":
+        return invalid_boolean()
+    return invalid_id()
+
+
+def out_of_range_int() -> st.SearchStrategy[graphql.IntValueNode]:
+    return st.one_of(
+        st.integers(max_value=MIN_INT - 1),  # Too small
+        st.integers(min_value=MAX_INT + 1),  # Too large
+    ).map(nodes.Int)
+
+
+def invalid_enum(valid_values: Tuple[str, ...]) -> st.SearchStrategy[graphql.EnumValueNode]:
+    # Use only ASCII letters, digits, and underscore to match GraphQL enum syntax
+    # Enum values must match /[_A-Za-z][_0-9A-Za-z]*/ pattern
+    alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"
+    first_char_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_"
+
+    return (
+        st.builds(
+            lambda first, rest: first + rest,
+            st.sampled_from(first_char_alphabet),
+            st.text(alphabet=alphabet, max_size=10),
+        )
+        .filter(lambda x: x not in valid_values)
+        .map(nodes.Enum)
+    )