feature: Adds UniqueArgumentNamesRule

Author: NeedleInAJayStack

Sources/GraphQL/Validation/Rules/UniqueArgumentNamesRule.swift

@@ -0,0 +1,37 @@
+
+/**
+ * Unique argument names
+ *
+ * A GraphQL field or directive is only valid if all supplied arguments are
+ * uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Argument-Names
+ */
+func UniqueArgumentNamesRule(context: ValidationContext) -> Visitor {
+    return Visitor(
+        enter: { node, _, _, _, _ in
+            let argumentNodes: [Argument]
+            if let field = node as? Field {
+                argumentNodes = field.arguments
+            } else if let directive = node as? Directive {
+                argumentNodes = directive.arguments
+            } else {
+                return .continue
+            }
+
+            let seenArgs = Dictionary(grouping: argumentNodes) { $0.name.value }
+
+            for (argName, argNodes) in seenArgs {
+                if argNodes.count > 1 {
+                    context.report(
+                        error: GraphQLError(
+                            message: "There can be only one argument named \"\(argName)\".",
+                            nodes: argNodes.map { $0.name }
+                        )
+                    )
+                }
+            }
+            return .continue
+        }
+    )
+}

Sources/GraphQL/Validation/SpecifiedRules.swift

@@ -25,7 +25,7 @@ public let specifiedRules: [(ValidationContext) -> Visitor] = [
 //    DeferStreamDirectiveOnValidOperationsRule,
 //    DeferStreamDirectiveLabelRule,
     KnownArgumentNamesRule,
-//    UniqueArgumentNamesRule,
+    UniqueArgumentNamesRule,
 //    ArgumentsOfCorrectTypeRule,
 //    ValuesOfCorrectTypeRule,
 //    ProvidedRequiredArgumentsRule,

Tests/GraphQLTests/ValidationTests/UniqueArgumentNamesRuleTests.swift

@@ -0,0 +1,181 @@
+@testable import GraphQL
+import XCTest
+
+class UniqueArgumentNamesRuleTests: ValidationTestCase {
+    override func setUp() {
+        rule = UniqueArgumentNamesRule
+    }
+
+    func testNoArgumentsOnField() throws {
+        try assertValid(
+            """
+            {
+              field
+            }
+            """
+        )
+    }
+
+    func testNoArgumentsOnDirective() throws {
+        try assertValid(
+            """
+            {
+              field @directive
+            }
+            """
+        )
+    }
+
+    func testArgumentOnField() throws {
+        try assertValid(
+            """
+            {
+              field(arg: "value")
+            }
+            """
+        )
+    }
+
+    func testArgumentOnDirective() throws {
+        try assertValid(
+            """
+            {
+              field @directive(arg: "value")
+            }
+            """
+        )
+    }
+
+    func testSameArgumentOnTwoFields() throws {
+        try assertValid(
+            """
+            {
+              one: field(arg: "value")
+              two: field(arg: "value")
+            }
+            """
+        )
+    }
+
+    func testSameArgumentOnFieldAndDirective() throws {
+        try assertValid(
+            """
+            {
+              field(arg: "value") @directive(arg: "value")
+            }
+            """
+        )
+    }
+
+    func testSameArgumentOnTwoDirectives() throws {
+        try assertValid(
+            """
+            {
+              field @directive1(arg: "value") @directive2(arg: "value")
+            }
+            """
+        )
+    }
+
+    func testMultipleFieldArguments() throws {
+        try assertValid(
+            """
+            {
+              field(arg1: "value", arg2: "value", arg3: "value")
+            }
+            """
+        )
+    }
+
+    func testMultipleDirectiveArguments() throws {
+        try assertValid(
+            """
+            {
+              field @directive(arg1: "value", arg2: "value", arg3: "value")
+            }
+            """
+        )
+    }
+
+    func testDuplicateFieldArguments() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            {
+              field(arg1: "value", arg1: "value")
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [
+                (line: 2, column: 9),
+                (line: 2, column: 24),
+            ],
+            message: "There can be only one argument named \"arg1\"."
+        )
+    }
+
+    func testManyDuplicateFieldArguments() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            {
+              field(arg1: "value", arg1: "value", arg1: "value")
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [
+                (line: 2, column: 9),
+                (line: 2, column: 24),
+                (line: 2, column: 39),
+            ],
+            message: "There can be only one argument named \"arg1\"."
+        )
+    }
+
+    func testDuplicateDirectiveArguments() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            {
+              field @directive(arg1: "value", arg1: "value")
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [
+                (line: 2, column: 20),
+                (line: 2, column: 35),
+            ],
+            message: "There can be only one argument named \"arg1\"."
+        )
+    }
+
+    func testManyDuplicateDirectiveArguments() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            {
+              field @directive(arg1: "value", arg1: "value", arg1: "value")
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [
+                (line: 2, column: 20),
+                (line: 2, column: 35),
+                (line: 2, column: 50),
+            ],
+            message: "There can be only one argument named \"arg1\"."
+        )
+    }
+}