Detect directive argument changes

Replicates graphql/graphql-js@2ed951c

Author: Cito

src/graphql/utilities/find_schema_changes.py

@@ -223,7 +223,66 @@ def find_directive_changes(
             for arg_name in args_diff.removed
         )
 
-        for old_arg, new_arg in args_diff.persisted.values():
+        for arg_name, (old_arg, new_arg) in args_diff.persisted.items():
+            is_safe = is_change_safe_for_input_object_field_or_field_arg(
+                old_arg.type, new_arg.type
+            )
+            if not is_safe:
+                schema_changes.append(
+                    BreakingChange(
+                        BreakingChangeType.ARG_CHANGED_KIND,
+                        f"Argument @{old_directive.name}({arg_name}:)"
+                        f" has changed type from"
+                        f" {old_arg.type} to {new_arg.type}.",
+                    )
+                )
+            elif old_arg.default_value is not Undefined:
+                if new_arg.default_value is Undefined:
+                    schema_changes.append(
+                        DangerousChange(
+                            DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,
+                            f"@{old_directive.name}({arg_name}:)"
+                            f" defaultValue was removed.",
+                        )
+                    )
+                else:
+                    # Since we are looking only for client's observable changes
+                    # we should compare default values in the same representation
+                    # as they are represented inside introspection.
+                    old_value_str = stringify_value(old_arg.default_value, old_arg.type)
+                    new_value_str = stringify_value(new_arg.default_value, new_arg.type)
+
+                    if old_value_str != new_value_str:
+                        schema_changes.append(
+                            DangerousChange(
+                                DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,
+                                f"@{old_directive.name}({arg_name}:)"
+                                f" has changed defaultValue"
+                                f" from {old_value_str} to {new_value_str}.",
+                            )
+                        )
+            elif (
+                new_arg.default_value is not Undefined
+                and old_arg.default_value is Undefined
+            ):
+                new_value_str = stringify_value(new_arg.default_value, new_arg.type)
+                schema_changes.append(
+                    SafeChange(
+                        SafeChangeType.ARG_DEFAULT_VALUE_ADDED,
+                        f"@{old_directive.name}({arg_name}:)"
+                        f" added a defaultValue {new_value_str}.",
+                    )
+                )
+            elif str(old_arg.type) != str(new_arg.type):
+                schema_changes.append(
+                    SafeChange(
+                        SafeChangeType.ARG_CHANGED_KIND_SAFE,
+                        f"Argument @{old_directive.name}({arg_name}:)"
+                        f" has changed type from"
+                        f" {old_arg.type} to {new_arg.type}.",
+                    )
+                )
+
             if old_arg.description != new_arg.description:
                 schema_changes.append(
                     SafeChange(

tests/utilities/test_find_schema_changes.py

@@ -1,4 +1,6 @@
 from graphql.utilities import (
+    BreakingChangeType,
+    DangerousChangeType,
     SafeChangeType,
     build_schema,
     find_schema_changes,
@@ -185,6 +187,163 @@ def should_detect_if_a_directive_was_added():
             (SafeChangeType.DIRECTIVE_ADDED, "Directive @Foo was added."),
         ]
 
+    def should_detect_if_a_changes_argument_safely():
+        old_schema = build_schema(
+            """
+            directive @Foo(foo: String!) on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+
+        new_schema = build_schema(
+            """
+            directive @Foo(foo: String) on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+        assert find_schema_changes(old_schema, new_schema) == [
+            (
+                SafeChangeType.ARG_CHANGED_KIND_SAFE,
+                "Argument @Foo(foo:) has changed type from String! to String.",
+            ),
+        ]
+
+    def should_detect_if_a_default_value_is_added_to_an_argument():
+        old_schema = build_schema(
+            """
+            directive @Foo(foo: String) on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+
+        new_schema = build_schema(
+            """
+            directive @Foo(foo: String = "Foo") on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+        assert find_schema_changes(old_schema, new_schema) == [
+            (
+                SafeChangeType.ARG_DEFAULT_VALUE_ADDED,
+                '@Foo(foo:) added a defaultValue "Foo".',
+            ),
+        ]
+
+    def should_detect_if_a_default_value_is_removed_from_an_argument():
+        new_schema = build_schema(
+            """
+            directive @Foo(foo: String) on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+
+        old_schema = build_schema(
+            """
+            directive @Foo(foo: String = "Foo") on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+        assert find_schema_changes(old_schema, new_schema) == [
+            (
+                DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,
+                "@Foo(foo:) defaultValue was removed.",
+            ),
+        ]
+
+    def should_detect_if_a_default_value_is_changed_in_an_argument():
+        old_schema = build_schema(
+            """
+            directive @Foo(foo: String = "Bar") on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+
+        new_schema = build_schema(
+            """
+            directive @Foo(foo: String = "Foo") on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+        assert find_schema_changes(old_schema, new_schema) == [
+            (
+                DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,
+                '@Foo(foo:) has changed defaultValue from "Bar" to "Foo".',
+            ),
+        ]
+
+    def should_detect_if_a_directive_argument_does_a_breaking_change():
+        old_schema = build_schema(
+            """
+            directive @Foo(foo: String) on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+
+        new_schema = build_schema(
+            """
+            directive @Foo(foo: String!) on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+        assert find_schema_changes(old_schema, new_schema) == [
+            (
+                BreakingChangeType.ARG_CHANGED_KIND,
+                "Argument @Foo(foo:) has changed type from String to String!.",
+            ),
+        ]
+
+    def should_not_detect_if_a_directive_argument_default_value_does_not_change():
+        old_schema = build_schema(
+            """
+            directive @Foo(foo: String = "FOO") on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+
+        new_schema = build_schema(
+            """
+            directive @Foo(foo: String = "FOO") on FIELD_DEFINITION
+
+            type Query {
+              foo: String
+            }
+            """
+        )
+        assert find_schema_changes(old_schema, new_schema) == []
+
     def should_detect_if_a_directive_changes_description():
         old_schema = build_schema(
             """