fix coverage and add overloads

Author: kasbaker

gql/dsl.py

@@ -7,7 +7,19 @@
 import re
 from abc import ABC, abstractmethod
 from math import isfinite
-from typing import Any, Dict, Iterable, Mapping, Optional, Set, Tuple, Union, cast
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    Literal,
+    Mapping,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+    cast,
+    overload,
+)
 
 from graphql import (
     ArgumentNode,
@@ -297,28 +309,48 @@ def __init__(self, schema: GraphQLSchema):
 
         self._schema: GraphQLSchema = schema
 
-    def __call__(self, name: str) -> "DSLDirective":
+    @overload
+    def __call__(
+        self, shortcut: Literal["__typename", "__schema", "__type"]
+    ) -> "DSLMetaField": ...  # pragma: no cover
+
+    @overload
+    def __call__(
+        self, shortcut: Literal["..."]
+    ) -> "DSLInlineFragment": ...  # pragma: no cover
+
+    @overload
+    def __call__(
+        self, shortcut: Literal["fragment"], name: str
+    ) -> "DSLFragment": ...  # pragma: no cover
+
+    @overload
+    def __call__(self, shortcut: Any) -> "DSLDirective": ...  # pragma: no cover
+
+    def __call__(
+        self, shortcut: str, name: Optional[str] = None
+    ) -> Union["DSLMetaField", "DSLInlineFragment", "DSLFragment", "DSLDirective"]:
         """Factory method for creating DSL objects.
 
         Currently, supports creating DSLDirective instances when name starts with '@'.
         Future support planned for meta-fields (__typename), inline fragments (...),
         and fragment definitions (fragment).
 
-        :param name: the name of the object to create
-        :type name: str
+        :param shortcut: the name of the object to create
+        :type shortcut: LiteralString
 
         :return: DSLDirective instance
 
-        :raises ValueError: if name format is not supported
+        :raises ValueError: if shortcut format is not supported
         """
-        if name.startswith("@"):
-            return DSLDirective(name=name[1:], dsl_schema=self)
+        if shortcut.startswith("@"):
+            return DSLDirective(name=shortcut[1:], dsl_schema=self)
         # Future support:
         # if name.startswith("__"): return DSLMetaField(name)
         # if name == "...": return DSLInlineFragment()
         # if name.startswith("fragment "): return DSLFragment(name[9:])
 
-        raise ValueError(f"Unsupported name: {name}")
+        raise ValueError(f"Unsupported shortcut: {shortcut}")
 
     def __getattr__(self, name: str) -> "DSLType":
 
@@ -549,7 +581,7 @@ def is_valid_directive(self, directive: "DSLDirective") -> bool:
         """
         raise NotImplementedError(
             "Any DSLDirectable concrete class must have an is_valid_directive method"
-        )
+        )  # pragma: no cover
 
     def directives(self, *directives: DSLDirective) -> Any:
         r"""Add directives to this DSL element.

tests/starwars/test_dsl.py

@@ -1297,6 +1297,11 @@ def test_legacy_fragment_with_variables(ds):
     assert print_ast(query.document) == expected
 
 
+def test_dsl_schema_call_validation(ds):
+    with pytest.raises(ValueError, match="(?i)unsupported shortcut"):
+        ds("foo")
+
+
 def test_executable_directives(ds, var):
     """Test ALL executable directive locations and types in one document"""
 
@@ -1424,14 +1429,26 @@ def test_directive_error_handling(ds):
     with pytest.raises(TypeError, match="Expected DSLDirective"):
         ds.Query.hero.directives(123)
 
-    # Invalid directive name
+    # Invalid directive name from `__call__
     with pytest.raises(GraphQLError, match="Directive '@nonexistent' not found"):
         ds("@nonexistent")
 
     # Invalid directive argument
     with pytest.raises(GraphQLError, match="Argument 'invalid' does not exist"):
         ds("@include")(invalid=True)
 
+    # Tried to set arguments twice
+    with pytest.raises(
+        AttributeError, match="Arguments for directive @field already set."
+    ):
+        ds("@field").args(value="foo").args(value="bar")
+
+    with pytest.raises(
+        GraphQLError,
+        match="(?i)Directive '@deprecated' is not a valid request executable directive",
+    ):
+        ds("@deprecated")
+
     with pytest.raises(GraphQLError, match="unexpected variable"):
         # variable definitions must be static, literal values defined in the query!
         var = DSLVariableDefinitions()
@@ -1442,8 +1459,7 @@ def test_directive_error_handling(ds):
             ds("@variableDefinition").args(value=var.nonStatic),
         )
         query.variable_definitions = var
-        invalid = print_ast(dsl_gql(query).document)
-        print(invalid)
+        _ = dsl_gql(query).document
 
 
 # Parametrized tests for comprehensive directive location validation