Build out vendor extendable tests

Author: mattpolzin

Sources/OpenAPIKit/VendorExtendable.swift

@@ -43,21 +43,36 @@ protocol VendorExtendable {
 }
 
 enum VendorExtensionDecodingError: Swift.Error {
+    case selfIsArrayNotDict
     case foundNonStringKeys
+    case foundExtensionsWithoutXPrefix
 }
 
 extension VendorExtendable {
 
     public static func extensions(from decoder: Decoder) throws -> VendorExtensions {
-        guard let decodedAny = (try AnyCodable(from: decoder)).value as? [String: Any] else {
+
+        let decoded = try AnyCodable(from: decoder).value
+
+        guard (decoded as? [Any]) == nil else {
+            throw VendorExtensionDecodingError.selfIsArrayNotDict
+        }
+
+        guard let decodedAny = decoded as? [String: Any] else {
             throw VendorExtensionDecodingError.foundNonStringKeys
         }
 
-        return decodedAny.filter {
+        let extensions = decodedAny.filter {
             let key = CodingKeys.key(for: $0.key)
 
             return !CodingKeys.allBuiltinKeys.contains(key)
-        }.mapValues(AnyCodable.init)
+        }
+
+        guard extensions.keys.allSatisfy({ $0.lowercased().starts(with: "x-") }) else {
+            throw VendorExtensionDecodingError.foundExtensionsWithoutXPrefix
+        }
+
+        return extensions.mapValues(AnyCodable.init)
     }
 
     public func encodeExtensions<T: KeyedEncodingContainerProtocol>(to container: inout T) throws where T.Key == Self.CodingKeys {

Tests/OpenAPIKitTests/VendorExtendableTests.swift

@@ -0,0 +1,169 @@
+//
+//  VendorExtendableTests.swift
+//  
+//
+//  Created by Mathew Polzin on 11/3/19.
+//
+
+import XCTest
+@testable import OpenAPIKit
+
+final class VendorExtendableTests: XCTestCase {
+    func test_decode() throws {
+        let data =
+"""
+{
+    "x-tension": "hello",
+    "x-two": [ "cool", "beans" ],
+    "x-three": {
+        "nested": 10
+    },
+    "one": "world",
+    "two": "!"
+}
+""".data(using: .utf8)!
+
+        let test = try JSONDecoder().decode(TestStruct.self, from: data)
+        XCTAssertEqual(test.vendorExtensions.count, 3)
+
+        XCTAssertEqual(test.vendorExtensions["x-tension"]?.value as? String, "hello")
+
+        XCTAssert((test.vendorExtensions["x-two"]?.value as? [String])!.contains("cool"))
+        XCTAssert((test.vendorExtensions["x-two"]?.value as? [String])!.contains("beans"))
+        XCTAssertEqual((test.vendorExtensions["x-two"]?.value as? [String])?.count, 2)
+
+        XCTAssertEqual((test.vendorExtensions["x-three"]?.value as? [String: Int])?.count, 1)
+        XCTAssertEqual((test.vendorExtensions["x-three"]?.value as? [String: Int])?["nested"], 10)
+    }
+
+    func test_encodeSuccess() throws {
+        let test = TestStruct(vendorExtensions: [
+            "x-tension": "hello",
+            "x-two": [
+                "cool",
+                "beans"
+            ],
+            "x-three": [
+                "nested": 10
+            ]
+        ])
+
+        let _ = try JSONEncoder().encode(test)
+    }
+
+    func test_arrayDecodeFailure() {
+        let data =
+"""
+[
+    "cool",
+    "beans"
+]
+""".data(using: .utf8)!
+
+        XCTAssertThrowsError(try JSONDecoder().decode(TestStruct.self, from: data)) { error in
+            XCTAssert(error as? VendorExtensionDecodingError == VendorExtensionDecodingError.selfIsArrayNotDict)
+        }
+    }
+
+    func test_nonXPrefixDecodeFailure() {
+        let data =
+"""
+{
+    "x-tension": "hello",
+    "invalid": "world"
+}
+""".data(using: .utf8)!
+
+        XCTAssertThrowsError(try JSONDecoder().decode(TestStruct.self, from: data)) { error in
+            XCTAssert(error as? VendorExtensionDecodingError == VendorExtensionDecodingError.foundExtensionsWithoutXPrefix)
+        }
+    }
+}
+
+@available(OSX 10.13, *)
+extension VendorExtendableTests {
+    func test_encode() throws {
+        let test = TestStruct(vendorExtensions: [
+            "x-tension": "hello",
+            "x-two": [
+                "cool",
+                "beans"
+            ],
+            "x-three": [
+                "nested": 10
+            ]
+        ])
+
+        let encoded = try testStringFromEncoding(of: test)
+
+        XCTAssertEqual(encoded,
+"""
+{
+  "one" : "world",
+  "two" : "!",
+  "x-tension" : "hello",
+  "x-three" : {
+    "nested" : 10
+  },
+  "x-two" : [
+    "cool",
+    "beans"
+  ]
+}
+"""
+        )
+    }
+}
+
+private struct TestStruct: Codable, VendorExtendable {
+    enum CodingKeys: ExtendableCodingKey {
+        case one
+        case two
+        case other(String)
+
+        static let allBuiltinKeys: [Self] = [.one, .two]
+
+        static func extendedKey(for value: String) -> Self {
+            return .other(value)
+        }
+
+        var stringValue: String {
+            switch self {
+            case .one: return "one"
+            case .two: return "two"
+            case .other(let val): return val
+            }
+        }
+
+        init?(stringValue: String) {
+            switch stringValue {
+            case "one": self = .one
+            case "two": self = .two
+            default: return nil
+            }
+        }
+
+        var intValue: Int? { return nil }
+
+        init?(intValue: Int) {
+            return nil
+        }
+    }
+
+    public let vendorExtensions: Self.VendorExtensions
+
+    init(vendorExtensions: Self.VendorExtensions) {
+        self.vendorExtensions = vendorExtensions
+    }
+
+    public init(from decoder: Decoder) throws {
+        vendorExtensions = try Self.extensions(from: decoder)
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode("world", forKey: .one)
+        try container.encode("!", forKey: .two)
+        try encodeExtensions(to: &container)
+    }
+}

Tests/OpenAPIKitTests/XCTestManifests.swift

@@ -348,6 +348,19 @@ extension TagTests {
     ]
 }
 
+extension VendorExtendableTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__VendorExtendableTests = [
+        ("test_arrayDecodeFailure", test_arrayDecodeFailure),
+        ("test_decode", test_decode),
+        ("test_encode", test_encode),
+        ("test_encodeSuccess", test_encodeSuccess),
+        ("test_nonXPrefixDecodeFailure", test_nonXPrefixDecodeFailure),
+    ]
+}
+
 public func __allTests() -> [XCTestCaseEntry] {
     return [
         testCase(AnyJSONCaseIterableTests.__allTests__AnyJSONCaseIterableTests),
@@ -365,6 +378,7 @@ public func __allTests() -> [XCTestCaseEntry] {
         testCase(ServerTests.__allTests__ServerTests),
         testCase(SwiftPrimitiveTypesTests.__allTests__SwiftPrimitiveTypesTests),
         testCase(TagTests.__allTests__TagTests),
+        testCase(VendorExtendableTests.__allTests__VendorExtendableTests),
     ]
 }
 #endif