🚨 Fix deep Array comparison in tests

Author: alexaubry

Sources/JSExpression.swift

@@ -185,12 +185,6 @@ extension JSExpression {
                 return
             }
 
-            do {
-                let typeError: ReturnType = try decoder.decode(value)
-            } catch {
-                dump(error)
-            }
-
             guard let decodedValue: ReturnType = try? decoder.decode(value) else {
                 let typeError = JSErrorDomain.invalidReturnType(value: value)
                 completeEvaluation(completionHandler, .failure(typeError))

Tests/JavaScriptKit/CodableModels.swift

@@ -25,13 +25,19 @@ class EmptyObject: Codable {
 // MARK: - User
 
 /// A simple structure
-struct User: Codable, Equatable {
+struct User: Codable, Hashable {
+
     let displayName: String
     let handle: String
 
+    var hashValue: Int {
+        return displayName.hashValue & handle.hashValue
+    }
+
     static func == (lhs: User, rhs: User) -> Bool {
         return (lhs.displayName == rhs.displayName) && (lhs.handle == rhs.handle)
     }
+
 }
 
 // MARK: - Person

Tests/JavaScriptKit/Decoding/UnkeyedDecodingTests.swift

@@ -30,11 +30,7 @@ class UnkeyedDecoderTests: XCTestCase {
         let decoder = JavaScriptDecoder()
         let decodedArray: [[String]] = try decoder.decode(array)
 
-        XCTAssertEqual(decodedArray.count, array.count)
-
-        for (decoded, base) in zip(decodedArray, array) {
-            XCTAssertEqual(decoded, base)
-        }
+        XCTAssertDeepEqual(decodedArray, array)
 
     }
 
@@ -66,11 +62,7 @@ class UnkeyedDecoderTests: XCTestCase {
             ]
         ]
 
-        XCTAssertEqual(decodedArray.count, expectedUsers.count)
-
-        for (decoded, expected) in zip(decodedArray, expectedUsers) {
-            XCTAssertEqual(decoded, expected)
-        }
+        XCTAssertDeepEqual(decodedArray, expectedUsers)
 
     }
 

Tests/JavaScriptKit/Encoding/KeyedEncodingTests.swift

@@ -122,7 +122,7 @@ class KeyedEncodingTests: XCTestCase {
             ]
         ]
 
-        XCTAssertEqual(jsonObjectGraph, expectedGraph)
+        XCTAssertDeepEqual(jsonObjectGraph, expectedGraph)
 
     }
 
@@ -156,7 +156,7 @@ class KeyedEncodingTests: XCTestCase {
         let encoder = JavaScriptEncoder()
         let encodedGraph = try encoder.encode([apple, google, facebook]).data(using: .utf8)!
 
-        guard let jsonObjectList = try JSONSerialization.jsonObject(with: encodedGraph, options: []) as? NSArray else {
+        guard let jsonObjectList = try JSONSerialization.jsonObject(with: encodedGraph, options: []) as? [Any] else {
             XCTFail("Encoded didn't encode a valid JSON array literal for the object graph.")
             return
         }
@@ -194,7 +194,7 @@ class KeyedEncodingTests: XCTestCase {
             ],
         ]
 
-        XCTAssertTrue(jsonObjectList.isEqual(to: expectedList))
+        XCTAssertDeepEqual(jsonObjectList, expectedList)
 
     }
 

Tests/JavaScriptKit/TestsSupport.swift

@@ -1,7 +1,8 @@
 import XCTest
 import Foundation
 
-func XCTAssertEqual(_ dictionary: [String: Any], _ expected: [String: Any]) {
+/// Checks if two dictionaries are equal.
+func XCTAssertDeepEqual(_ dictionary: [String: Any], _ expected: [String: Any]) {
 
     for (key, value) in dictionary {
 
@@ -10,48 +11,84 @@ func XCTAssertEqual(_ dictionary: [String: Any], _ expected: [String: Any]) {
             break
         }
 
-        if let hashable = value as? AnyHashable, let expectedHashable = expectedValue as? AnyHashable {
-            XCTAssertEqual(hashable, expectedHashable)
-            continue
-        }
+        let didCompare = XCTDeepCompare(value, expectedValue)
 
-        if let array = value as? [AnyHashable], let expectedArray = expectedValue as? [AnyHashable] {
-            XCTAssertEqual(array, expectedArray)
-            continue
+        guard didCompare == true else {
+            XCTFail("Could not compare values for key \(key)")
+            return
         }
 
-        if let arrayArray = value as? [[AnyHashable]], let expectedArrayArray = expectedValue as? [[AnyHashable]] {
+    }
+
+}
+
+/// Checks if two arrays are equal.
+func XCTAssertDeepEqual(_ array: [Any], _ expected: [Any]) {
+
+    guard array.count == expected.count else {
+        XCTFail("Array does not have the expected number of items.")
+        return
+    }
+
+    var idx = 0
 
-            XCTAssertEqual(arrayArray.count, expectedArrayArray.count)
+    for (value, expectedValue) in zip(array, expected) {
 
-            for (arr, expectedArr) in zip(arrayArray, expectedArrayArray) {
-                XCTAssertEqual(arr, expectedArr)
-            }
+        let didCompare = XCTDeepCompare(value, expectedValue)
 
-            continue
-            
+        guard didCompare == true else {
+            XCTFail("Could not compare values at index \(idx).")
+            return
         }
 
+        idx += 1
+
+    }
+
+}
+
+private func XCTDeepCompare(_ value: Any, _ expectedValue: Any) -> Bool {
+
+    if let hashable = value as? AnyHashable, let expectedHashable = expectedValue as? AnyHashable {
+        XCTAssertEqual(hashable, expectedHashable)
+        return true
+    }
+
+    if let array = value as? [AnyHashable], let expectedArray = expectedValue as? [AnyHashable] {
+        XCTAssertEqual(array, expectedArray)
+        return true
+    }
+
+    if let arrayArray = value as? [[AnyHashable]], let expectedArrayArray = expectedValue as? [[AnyHashable]] {
 
-        if let dictionary = value as? [String: Any], let expectedDictionary = expectedValue as? [String: Any] {
-            XCTAssertEqual(dictionary, expectedDictionary)
-            continue
+        XCTAssertEqual(arrayArray.count, expectedArrayArray.count)
+
+        for (arr, expectedArr) in zip(arrayArray, expectedArrayArray) {
+            XCTAssertEqual(arr, expectedArr)
         }
 
-        if let dictionaryArray = value as? [[String: Any]], let expectedDictionaryArray = expectedValue as? [[String: Any]] {
+        return true
+
+    }
+
 
-            XCTAssertEqual(dictionaryArray.count, expectedDictionaryArray.count)
+    if let dictionary = value as? [String: Any], let expectedDictionary = expectedValue as? [String: Any] {
+        XCTAssertDeepEqual(dictionary, expectedDictionary)
+        return true
+    }
 
-            for (dict, expectedDict) in zip(dictionaryArray, expectedDictionaryArray) {
-                XCTAssertEqual(dict, expectedDict)
-            }
+    if let dictionaryArray = value as? [[String: Any]], let expectedDictionaryArray = expectedValue as? [[String: Any]] {
 
-            continue
+        XCTAssertEqual(dictionaryArray.count, expectedDictionaryArray.count)
 
+        for (dict, expectedDict) in zip(dictionaryArray, expectedDictionaryArray) {
+            XCTAssertDeepEqual(dict, expectedDict)
         }
 
-        XCTFail("Could not compare values for key \(key)")
+        return true
 
     }
 
+    return false
+
 }