this is so slow

Author: millotp

.github/workflows/check.yml

@@ -378,7 +378,7 @@ jobs:
         run: yarn cli cts generate ${{ matrix.client.language }} --language-version ${{ matrix.client.version }}
 
       - name: Run unit CTS
-        run: yarn cli cts run ${{ matrix.client.language }} --no-e2e
+        run: yarn cli cts run ${{ matrix.client.language }} --no-e2e -v
 
       - name: Run e2e CTS
         id: cts-e2e

templates/swift/tests/client/tests.mustache

@@ -41,8 +41,7 @@
         {{#testResponse}}
           {{#isHelper}}
             {{^match.isPrimitive}}
-              let comparableData = try XCTUnwrap("{{#lambda.escapeQuotes}}{{{match.value}}}{{/lambda.escapeQuotes}}".data(using: .utf8))
-              try XCTLenientAssertEqual(received: CodableHelper.jsonEncoder.encode(response), expected: comparableData)
+              try XCTLenientAssertEqual(received: response, expected: "{{#lambda.escapeQuotes}}{{{match.value}}}{{/lambda.escapeQuotes}}")
             {{/match.isPrimitive}}
             {{#match.isPrimitive}}
               {{#match.isNull}}
@@ -54,9 +53,7 @@
             {{/match.isPrimitive}}
           {{/isHelper}}
           {{^isHelper}}
-            let comparableData = "{{#lambda.escapeQuotes}}{{{match.value}}}{{/lambda.escapeQuotes}}".data(using: .utf8)
-            let comparableJSON = try XCTUnwrap(comparableData?.jsonString)
-            XCTAssertEqual(comparableJSON, String(data: try CodableHelper.jsonEncoder.encode(response), encoding: .utf8)!);
+            XTCJSONEquals(received: response, expected: "{{#lambda.escapeQuotes}}{{{match.value}}}{{/lambda.escapeQuotes}}")
           {{/isHelper}}
         {{/testResponse}}
         {{#shouldScope}}

templates/swift/tests/e2e/e2e.mustache

@@ -63,12 +63,7 @@ final class {{client}}RequestsTestsE2E: XCTestCase {
         {{#response}}
           let response{{#isGeneric}}: Response<{{#lambda.prefix}}{{{returnType}}}{{/lambda.prefix}}<{{#lambda.prefix}}Hit{{/lambda.prefix}}>>{{/isGeneric}} = {{> tests/method}}
           {{#body}}
-            let responseBody = try XCTUnwrap(response.body)
-            let responseBodyData = try CodableHelper.jsonEncoder.encode(responseBody)
-
-            let expectedBodyData = try XCTUnwrap("{{#lambda.escapeJSON}}{{{body}}}{{/lambda.escapeJSON}}".data(using: .utf8))
-
-            XCTLenientAssertEqual(received: responseBodyData, expected: expectedBodyData)
+            try XCTLenientAssertEqual(received: XCTUnwrap(response.body), expected: "{{#lambda.escapeJSON}}{{{body}}}{{/lambda.escapeJSON}}")
           {{/body}}
 
           {{#statusCode}}

tests/output/swift/Tests/Utils/Utils.swift

@@ -31,14 +31,31 @@ struct TestError: Error {
     let message: String
 }
 
-public func XCTLenientAssertEqual(received: Data, expected: Data) {
+public func XTCJSONEquals(received: some Encodable, expected: String) {
+    let expectedData = expected.data(using: .utf8)!
+    let receivedJSON = try! JSONEncoder().encode(received)
+
+    let dictReceived = try! JSONSerialization.jsonObject(with: receivedJSON) as! NSDictionary
+    let dictExpected = try! JSONSerialization.jsonObject(with: expectedData) as! NSDictionary
+
+    XCTAssertEqual(
+        dictReceived,
+        dictExpected,
+        """
+        Received JSON: \(String(data: receivedJSON, encoding: .utf8) ?? "nil")
+        Expected JSON: \(expected)
+        """
+    )
+}
+
+public func XCTLenientAssertEqual(received: some Encodable, expected: String) {
+    let receivedData = try! JSONEncoder().encode(received)
     guard let unionizedObject = try? union(
-        expected: JSONSerialization.jsonObject(with: expected, options: [.fragmentsAllowed]),
-        received: JSONSerialization.jsonObject(with: received, options: [.fragmentsAllowed])
+        expected: JSONSerialization.jsonObject(with: expected.data(using: .utf8)!, options: [.fragmentsAllowed]),
+        received: JSONSerialization.jsonObject(with: receivedData, options: [.fragmentsAllowed])
     ) else {
-        if let receivedString = String(data: received, encoding: .utf8),
-           let expectedString = String(data: expected, encoding: .utf8) {
-            XCTAssertEqual(receivedString, expectedString)
+        if let receivedString = String(data: receivedData, encoding: .utf8) {
+            XCTAssertEqual(receivedString, expected)
         } else {
             XCTFail("Unable to unionize received and expected objects")
         }
@@ -47,17 +64,19 @@ public func XCTLenientAssertEqual(received: Data, expected: Data) {
 
     guard let unionizedData = try? JSONSerialization.data(withJSONObject: unionizedObject, options: .fragmentsAllowed),
           let unionizedJSON = unionizedData.jsonString?.data(using: .utf8),
-          let expectedJSON = expected.jsonString?.data(using: .utf8),
-          let unionizedString = String(data: unionizedJSON, encoding: .utf8),
-          let expectedString = String(data: expectedJSON, encoding: .utf8)
+          let unionizedString = String(data: unionizedJSON, encoding: .utf8)
     else {
         XCTFail("Unable to serialize JSON strings")
         return
     }
 
     XCTAssertEqual(
         unionizedString,
-        expectedString
+        expected,
+        """
+        Received JSON: \(String(data: receivedData, encoding: .utf8) ?? "nil")
+        Expected JSON: \(expected)
+        """
     )
 }