[Runtime] Multiple content types support

Sources/OpenAPIRuntime/Conversion/Converter+Common.swift

@@ -17,31 +17,68 @@ extension Converter {
 
     // MARK: Miscs
 
-    /// Validates that the Content-Type header field (if present)
-    /// is compatible with the provided content-type substring.
+    /// Returns the content-type header from the provided header fields, if
+    /// present.
+    /// - Parameter headerFields: The header fields to inspect for the content
+    /// type header.
+    /// - Returns: The content type value, or nil if not found.
+    public func extractContentTypeIfPresent(in headerFields: [HeaderField]) -> String? {
+        headerFields.firstValue(name: "content-type")
+    }
+
+    /// Checks whether a concrete content type matches an expected content type.
     ///
-    /// Succeeds if no Content-Type header is found in the response headers.
+    /// The concrete content type can contain parameters, such as `charset`, but
+    /// they are ignored in the equality comparison.
     ///
+    /// The expected content type can contain wildcards, such as */* and text/*.
     /// - Parameters:
-    ///   - headerFields: Header fields to inspect for a content type.
-    ///   - substring: Expected content type.
-    /// - Throws: If the response's Content-Type value is not compatible with the provided substring.
-    public func validateContentTypeIfPresent(
-        in headerFields: [HeaderField],
-        substring: String
-    ) throws {
+    ///   - received: The concrete content type to validate against the other.
+    ///   - expected: The expected content type, can be a wildcard.
+    /// - Returns: A Boolean value representing whether the concrete content
+    /// type matches the expected one.
+    public func isValidContentType(received: String?, expected: String) -> Bool {
+        guard let received else {
+            return false
+        }
+        func parseContentType(_ value: String) -> (main: String, sub: String)? {
+            let components =
+                value
+                // Normalize to lowercase.
+                .lowercased()
+                // Drop any charset and other parameters.
+                .split(separator: ";")[0]
+                // Parse out main type and subtype.
+                .split(separator: "/")
+                .map(String.init)
+            guard components.count == 2 else {
+                return nil
+            }
+            return (components[0], components[1])
+        }
         guard
-            let contentType = try getOptionalHeaderFieldAsText(
-                in: headerFields,
-                name: "content-type",
-                as: String.self
-            )
+            let receivedContentType = parseContentType(received),
+            let expectedContentType = parseContentType(expected)
         else {
-            return
+            return false
+        }
+        if expectedContentType.main == "*" {
+            return true
+        }
+        if expectedContentType.main != receivedContentType.main {
+            return false
         }
-        guard contentType.localizedCaseInsensitiveContains(substring) else {
-            throw RuntimeError.unexpectedContentTypeHeader(contentType)
+        if expectedContentType.sub == "*" {
+            return true
         }
+        return expectedContentType.sub == receivedContentType.sub
+    }
+
+    /// Returns an error to be thrown when an unexpected content type is
+    /// received.
+    /// - Parameter contentType: The content type that was received.
+    public func makeUnexpectedContentTypeError(contentType: String?) -> any Error {
+        RuntimeError.unexpectedContentTypeHeader(contentType ?? "")
     }
 
     // MARK: - Converter helper methods

Sources/OpenAPIRuntime/Deprecated/Deprecated.swift

@@ -729,6 +729,29 @@ extension Converter {
 
 extension Converter {
 
+    /// Validates that the Content-Type header field (if present)
+    /// is compatible with the provided content-type substring.
+    ///
+    /// Succeeds if no Content-Type header is found in the response headers.
+    ///
+    /// - Parameters:
+    ///   - headerFields: Header fields to inspect for a content type.
+    ///   - substring: Expected content type.
+    /// - Throws: If the response's Content-Type value is not compatible with
+    /// the provided substring.
+    @available(*, deprecated, message: "Use isValidContentType instead.")
+    public func validateContentTypeIfPresent(
+        in headerFields: [HeaderField],
+        substring: String
+    ) throws {
+        guard let contentType = extractContentTypeIfPresent(in: headerFields) else {
+            return
+        }
+        guard isValidContentType(received: contentType, expected: substring) else {
+            throw RuntimeError.unexpectedContentTypeHeader(contentType)
+        }
+    }
+
     //    | client | set | request body | text | string-convertible | optional | setOptionalRequestBodyAsText |
     @available(*, deprecated)
     public func setOptionalRequestBodyAsText<T: _StringConvertible, C>(

Tests/OpenAPIRuntimeTests/Conversion/Test_Converter+Common.swift

@@ -18,61 +18,33 @@ final class Test_CommonConverterExtensions: Test_Runtime {
 
     // MARK: Miscs
 
-    func testValidateContentType_match() throws {
-        let headerFields: [HeaderField] = [
-            .init(name: "content-type", value: "application/json")
-        ]
-        XCTAssertNoThrow(
-            try converter.validateContentTypeIfPresent(
-                in: headerFields,
-                substring: "application/json"
-            )
-        )
-    }
+    func testContentTypeMatching() throws {
+        let cases: [(received: String, expected: String, isMatch: Bool)] = [
+            ("application/json", "application/json", true),
+            ("APPLICATION/JSON", "application/json", true),
+            ("application/json", "application/*", true),
+            ("application/json", "*/*", true),
+            ("application/json", "text/*", false),
+            ("application/json", "application/xml", false),
+            ("application/json", "text/plain", false),
 
-    func testValidateContentType_match_substring() throws {
-        let headerFields: [HeaderField] = [
-            .init(name: "content-type", value: "application/json; charset=utf-8")
+            ("text/plain; charset=UTF-8", "text/plain", true),
+            ("TEXT/PLAIN; CHARSET=UTF-8", "text/plain", true),
+            ("text/plain; charset=UTF-8", "text/*", true),
+            ("text/plain; charset=UTF-8", "*/*", true),
+            ("text/plain; charset=UTF-8", "application/*", false),
+            ("text/plain; charset=UTF-8", "text/html", false),
         ]
-        XCTAssertNoThrow(
-            try converter.validateContentTypeIfPresent(
-                in: headerFields,
-                substring: "application/json"
-            )
-        )
-    }
-
-    func testValidateContentType_missing() throws {
-        let headerFields: [HeaderField] = []
-        XCTAssertNoThrow(
-            try converter.validateContentTypeIfPresent(
-                in: headerFields,
-                substring: "application/json"
+        for testCase in cases {
+            XCTAssertEqual(
+                converter.isValidContentType(
+                    received: testCase.received,
+                    expected: testCase.expected
+                ),
+                testCase.isMatch,
+                "Wrong result for (\(testCase.received), \(testCase.expected), \(testCase.isMatch))"
             )
-        )
-    }
-
-    func testValidateContentType_mismatch() throws {
-        let headerFields: [HeaderField] = [
-            .init(name: "content-type", value: "text/plain")
-        ]
-        XCTAssertThrowsError(
-            try converter.validateContentTypeIfPresent(
-                in: headerFields,
-                substring: "application/json"
-            ),
-            "Was expected to throw error on mismatch",
-            { error in
-                guard
-                    let err = error as? RuntimeError,
-                    case .unexpectedContentTypeHeader(let contentType) = err
-                else {
-                    XCTFail("Unexpected kind of error thrown")
-                    return
-                }
-                XCTAssertEqual(contentType, "text/plain")
-            }
-        )
+        }
     }
 
     // MARK: Converter helper methods

Tests/OpenAPIRuntimeTests/Deprecated/Test_Deprecated.swift

@@ -222,6 +222,67 @@ final class Test_Deprecated: Test_Runtime {
         )
     }
 
+    @available(*, deprecated)
+    func testValidateContentType_match() throws {
+        let headerFields: [HeaderField] = [
+            .init(name: "content-type", value: "application/json")
+        ]
+        XCTAssertNoThrow(
+            try converter.validateContentTypeIfPresent(
+                in: headerFields,
+                substring: "application/json"
+            )
+        )
+    }
+
+    @available(*, deprecated)
+    func testValidateContentType_match_substring() throws {
+        let headerFields: [HeaderField] = [
+            .init(name: "content-type", value: "application/json; charset=utf-8")
+        ]
+        XCTAssertNoThrow(
+            try converter.validateContentTypeIfPresent(
+                in: headerFields,
+                substring: "application/json"
+            )
+        )
+    }
+
+    @available(*, deprecated)
+    func testValidateContentType_missing() throws {
+        let headerFields: [HeaderField] = []
+        XCTAssertNoThrow(
+            try converter.validateContentTypeIfPresent(
+                in: headerFields,
+                substring: "application/json"
+            )
+        )
+    }
+
+    @available(*, deprecated)
+    func testValidateContentType_mismatch() throws {
+        let headerFields: [HeaderField] = [
+            .init(name: "content-type", value: "text/plain")
+        ]
+        XCTAssertThrowsError(
+            try converter.validateContentTypeIfPresent(
+                in: headerFields,
+                substring: "application/json"
+            ),
+            "Was expected to throw error on mismatch",
+            { error in
+                guard
+                    let err = error as? RuntimeError,
+                    case .unexpectedContentTypeHeader(let contentType) = err
+                else {
+                    XCTFail("Unexpected kind of error thrown")
+                    return
+                }
+                XCTAssertEqual(contentType, "text/plain")
+            }
+        )
+    }
+
     //    | server | set | response body | text | string-convertible | required | setResponseBodyAsText |
     @available(*, deprecated)
     func test_deprecated_setResponseBodyAsText_stringConvertible() throws {