Adds map tests to ensure encoding/decoding

Author: NeedleInAJayStack

Sources/GraphQL/Type/Definition.swift

@@ -1352,7 +1352,7 @@ extension InputObjectFieldDefinition : KeySubscriptable {
     }
 }
 
-public typealias InputObjectFieldDefinitionMap = OrderedDictionary<String, InputObjectFieldDefinition>
+public typealias InputObjectFieldDefinitionMap = [String: InputObjectFieldDefinition]
 
 /**
  * List Modifier

Tests/GraphQLTests/MapTests/MapTests.swift

@@ -8,7 +8,6 @@ class MapTests: XCTestCase {
         XCTAssertEqual(try Map.bool(false).boolValue(), false)
         XCTAssertEqual(try Map.bool(true).boolValue(), true)
         XCTAssertEqual(try Map.string("Hello world").stringValue(), "Hello world")
-
     }
 
     func testOptionalConversion() {
@@ -36,16 +35,117 @@ class MapTests: XCTestCase {
             [
                 "first": .number(1),
                 "second": .number(4),
-                "third": .number(9)
+                "third": .number(9),
+                "fourth": .null,
+                "fifth": .undefined
             ]
         )
-        XCTAssertEqual(map.dictionary?.count, 3)
+        XCTAssertEqual(map.dictionary?.count, 5)
 
         let dictionary = try map.dictionaryValue()
 
-        XCTAssertEqual(dictionary.count, 3)
+        XCTAssertEqual(dictionary.count, 5)
         XCTAssertEqual(try dictionary["first"]?.intValue(), 1)
         XCTAssertEqual(try dictionary["second"]?.intValue(), 4)
         XCTAssertEqual(try dictionary["third"]?.intValue(), 9)
+        XCTAssertEqual(dictionary["fourth"]?.isNull, true)
+        XCTAssertEqual(dictionary["fifth"]?.isUndefined, true)
+    }
+    
+    // Ensure that default decoding preserves undefined becoming nil
+    func testNilAndUndefinedDecodeToNilByDefault() throws {
+        struct DecodableTest : Codable {
+            let first: Int?
+            let second: Int?
+            let third: Int?
+            let fourth: Int?
+        }
+        
+        let map = Map.dictionary(
+            [
+                "first": .number(1),
+                "second": .null,
+                "third": .undefined
+                // fourth not included
+            ]
+        )
+        
+        let decodable = try MapDecoder().decode(DecodableTest.self, from: map)
+        XCTAssertEqual(decodable.first, 1)
+        XCTAssertEqual(decodable.second, nil)
+        XCTAssertEqual(decodable.third, nil)
+        XCTAssertEqual(decodable.fourth, nil)
+    }
+    
+    // Ensure that, if custom decoding is defined, provided nulls and unset values can be differentiated.
+    // This should match JSON in that values set to `null` should be 'contained' by the container, but
+    // values expected by the result that are undefined or not present should not be.
+    func testNilAndUndefinedDecoding() throws {
+        struct DecodableTest : Codable {
+            let first: Int?
+            let second: Int?
+            let third: Int?
+            let fourth: Int?
+            
+            init(
+                first: Int?,
+                second: Int?,
+                third: Int?,
+                fourth: Int?
+            ) {
+                self.first = first
+                self.second = second
+                self.third = third
+                self.fourth = fourth
+            }
+            
+            init(from decoder: Decoder) throws {
+                let container = try decoder.container(keyedBy: CodingKeys.self)
+                
+                XCTAssertTrue(container.contains(.first))
+                // Null value should be contained, but decode to nil
+                XCTAssertTrue(container.contains(.second))
+                // Undefined value should not be contained
+                XCTAssertFalse(container.contains(.third))
+                // Missing value should operate the same as undefined
+                XCTAssertFalse(container.contains(.fourth))
+                
+                first = try container.decodeIfPresent(Int.self, forKey: .first)
+                second = try container.decodeIfPresent(Int.self, forKey: .second)
+                third = try container.decodeIfPresent(Int.self, forKey: .third)
+                fourth = try container.decodeIfPresent(Int.self, forKey: .fourth)
+            }
+        }
+        
+        let map = Map.dictionary(
+            [
+                "first": .number(1),
+                "second": .null,
+                "third": .undefined
+                // fourth not included
+            ]
+        )
+        
+        _ = try MapDecoder().decode(DecodableTest.self, from: map)
+    }
+    
+    // Ensure that map encoding includes defined nulls, but skips undefined values
+    func testMapEncoding() throws {
+        let map = Map.dictionary(
+            [
+                "first": .number(1),
+                "second": .null,
+                "third": .undefined
+            ]
+        )
+        
+        let data = try JSONEncoder().encode(map)
+        let json = String(data: data, encoding: .utf8)
+        XCTAssertEqual(
+            json,
+            """
+            {"first":1,"second":null}
+            """
+        )
     }
 }