Merge branch 'development'

* development:
  update changelog
  update starscream for spm
  Fix tests so they don't rely on comparing strings or the order of hashed collections
  don't bind error when we're not pattern matching
  Clarify comments to explain why we did the move
  Added comments to document changes reasons
  Fixed loosing POST packets on web socket connection failure and engine memory leak on server errors.
  add test for extraHeaders on objc

CHANGELOG.md

@@ -1,3 +1,8 @@
+# v13.2.1
+
+- Fix packets getting lost when WebSocket upgrade fails. [#1033](https://github.com/socketio/socket.io-client-swift/issues/1033)
+- Fix bad unit tests. [#794](https://github.com/socketio/socket.io-client-swift/issues/794)
+
 # v13.2.0
 
 - Add ability to bypass Data inspection in emits. [#992]((https://github.com/socketio/socket.io-client-swift/issues/992))

Cartfile.resolved

@@ -1,3 +1 @@
-github "daltoniam/Starscream" "3.0.4"
-github "daltoniam/common-crypto-spm" "1.1.0"
-github "daltoniam/zlib-spm" "1.1.0"
+github "daltoniam/Starscream" "3.0.5"

Package.resolved

@@ -15,8 +15,8 @@
         "repositoryURL": "https://github.com/daltoniam/Starscream",
         "state": {
           "branch": null,
-          "revision": "6cb1c474e09b0a3aa60bcdc7553b570336d6a61a",
-          "version": "3.0.3"
+          "revision": "114e5df9b6251970a069e8f1c0cbb5802759f0a9",
+          "version": "3.0.5"
         }
       },
       {

Source/SocketIO/Ack/SocketAckEmitter.swift

@@ -75,8 +75,8 @@ public final class SocketAckEmitter : NSObject {
 
         do {
             socket.emitAck(ackNum, with: try items.map({ try $0.socketRepresentation() }))
-        } catch let err {
-            socket.handleClientEvent(.error, data: [ackNum, items, err])
+        } catch {
+            socket.handleClientEvent(.error, data: [ackNum, items, error])
         }
     }
 

Source/SocketIO/Client/SocketIOClient.swift

@@ -214,11 +214,11 @@ open class SocketIOClient : NSObject, SocketIOClientSpec {
     open func emit(_ event: String, _ items: SocketData...) {
         do {
             try emit(event, with: items.map({ try $0.socketRepresentation() }))
-        } catch let err {
+        } catch {
             DefaultSocketLogger.Logger.error("Error creating socketRepresentation for emit: \(event), \(items)",
                                              type: logType)
 
-            handleClientEvent(.error, data: [event, items, err])
+            handleClientEvent(.error, data: [event, items, error])
         }
     }
 
@@ -253,11 +253,11 @@ open class SocketIOClient : NSObject, SocketIOClientSpec {
     open func emitWithAck(_ event: String, _ items: SocketData...) -> OnAckCallback {
         do {
             return emitWithAck(event, with: try items.map({ try $0.socketRepresentation() }))
-        } catch let err {
+        } catch {
             DefaultSocketLogger.Logger.error("Error creating socketRepresentation for emit: \(event), \(items)",
                                              type: logType)
 
-            handleClientEvent(.error, data: [event, items, err])
+            handleClientEvent(.error, data: [event, items, error])
 
             return OnAckCallback(ackNumber: -1, items: [], socket: self)
         }

Source/SocketIO/Client/SocketRawView.swift

@@ -48,11 +48,11 @@ public final class SocketRawView : NSObject {
     public func emit(_ event: String, _ items: SocketData...) {
         do {
             try emit(event, with: items.map({ try $0.socketRepresentation() }))
-        } catch let err {
+        } catch {
             DefaultSocketLogger.Logger.error("Error creating socketRepresentation for emit: \(event), \(items)",
                                              type: "SocketIOClient")
 
-            socket.handleClientEvent(.error, data: [event, items, err])
+            socket.handleClientEvent(.error, data: [event, items, error])
         }
     }
 
@@ -87,11 +87,11 @@ public final class SocketRawView : NSObject {
     public func emitWithAck(_ event: String, _ items: SocketData...) -> OnAckCallback {
         do {
             return emitWithAck(event, with: try items.map({ try $0.socketRepresentation() }))
-        } catch let err {
+        } catch {
             DefaultSocketLogger.Logger.error("Error creating socketRepresentation for emit: \(event), \(items)",
                                              type: "SocketIOClient")
 
-            socket.handleClientEvent(.error, data: [event, items, err])
+            socket.handleClientEvent(.error, data: [event, items, error])
 
             return OnAckCallback(ackNumber: -1, items: [], socket: socket)
         }
@@ -146,8 +146,8 @@ public final class SocketRawAckView : NSObject {
 
         do {
             socket.emit(try items.map({ try $0.socketRepresentation() }), ack: ackNum, binary: false, isAck: true)
-        } catch let err {
-            socket.handleClientEvent(.error, data: [ackNum, items, err])
+        } catch {
+            socket.handleClientEvent(.error, data: [ackNum, items, error])
         }
     }
 

Source/SocketIO/Engine/SocketEngine.swift

@@ -371,6 +371,13 @@ open class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePollable, So
         fastUpgrade = false
         probing = false
         flushProbeWait()
+
+        // Need to flush postWait to socket since it connected successfully
+        // moved from flushProbeWait() since it is also called on connected failure, and we don't want to try and send
+        // packets through WebSockets when WebSockets has failed!
+        if !postWait.isEmpty {
+            flushWaitingForPostToWebSocket()
+        }
     }
 
     private func flushProbeWait() {
@@ -381,10 +388,6 @@ open class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePollable, So
         }
 
         probeWait.removeAll(keepingCapacity: false)
-
-        if postWait.count != 0 {
-            flushWaitingForPostToWebSocket()
-        }
     }
 
     /// Causes any packets that were waiting for POSTing to be sent through the WebSocket. This happens because when

Source/SocketIO/Manager/SocketManager.swift

@@ -169,6 +169,9 @@ open class SocketManager : NSObject, SocketManagerSpec, SocketParsable, SocketDa
 
         engine?.engineQueue.sync {
             self.engine?.client = nil
+
+            // Close old engine so it will not leak because of URLSession if in polling mode
+            self.engine?.disconnect(reason: "Adding new engine")
         }
 
         engine = SocketEngine(client: self, url: socketURL, config: config)

Tests/TestSocketIO/SocketBasicPacketTest.swift

@@ -9,143 +9,180 @@
 import XCTest
 @testable import SocketIO
 
-class SocketBasicPacketTest: XCTestCase {
-    let data = "test".data(using: String.Encoding.utf8)!
-    let data2 = "test2".data(using: String.Encoding.utf8)!
-
-    func testEmpyEmit() {
-        let expectedSendString = "2[\"test\"]"
+class SocketBasicPacketTest : XCTestCase {
+    func testEmptyEmit() {
         let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testNullEmit() {
-        let expectedSendString = "2[\"test\",null]"
 		let sendData: [Any] = ["test", NSNull()]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testStringEmit() {
-        let expectedSendString = "2[\"test\",\"foo bar\"]"
         let sendData = ["test", "foo bar"]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testStringEmitWithQuotes() {
-        let expectedSendString = "2[\"test\",\"\\\"he\\\"llo world\\\"\"]"
         let sendData = ["test", "\"he\"llo world\""]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testJSONEmit() {
-        let expectedSendString = "2[\"test\",{\"null\":null,\"hello\":1,\"test\":\"hello\",\"foobar\":true}]"
         let sendData: [Any] = ["test", ["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testArrayEmit() {
-        let expectedSendString = "2[\"test\",[\"hello\",1,{\"test\":\"test\"}]]"
         let sendData: [Any] = ["test", ["hello", 1, ["test": "test"]]]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testBinaryEmit() {
-        let expectedSendString = "51-[\"test\",{\"_placeholder\":true,\"num\":0}]"
         let sendData: [Any] = ["test", data]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .binaryEvent)
         XCTAssertEqual(packet.binary, [data])
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            "test",
+            ["_placeholder": true, "num": 0]
+        ]))
     }
 
     func testMultipleBinaryEmit() {
-        let expectedSendString = "52-[\"test\",{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
         let sendData: [Any] = ["test", ["data1": data, "data2": data2] as NSDictionary]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data2, data])
+        XCTAssertEqual(parsed.type, .binaryEvent)
+
+        let binaryObj = parsed.data[1] as! [String: Any]
+        let data1Loc = (binaryObj["data1"] as! [String: Any])["num"] as! Int
+        let data2Loc = (binaryObj["data2"] as! [String: Any])["num"] as! Int
+
+        XCTAssertEqual(packet.binary[data1Loc], data)
+        XCTAssertEqual(packet.binary[data2Loc], data2)
     }
 
     func testEmitWithAck() {
-        let expectedSendString = "20[\"test\"]"
         let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString,
-
-                       expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testEmitDataWithAck() {
-        let expectedSendString = "51-0[\"test\",{\"_placeholder\":true,\"num\":0}]"
         let sendData: [Any] = ["test", data]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .binaryEvent)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            "test",
+            ["_placeholder": true, "num": 0]
+        ]))
         XCTAssertEqual(packet.binary, [data])
     }
 
     // Acks
     func testEmptyAck() {
-        let expectedSendString = "30[]"
-        let packet = SocketPacket.packetFromEmit([], id: 0, nsp: "/", ack: true)
+        let packetStr = SocketPacket.packetFromEmit([], id: 0, nsp: "/", ack: true).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: []))
     }
 
     func testNullAck() {
-        let expectedSendString = "30[null]"
         let sendData = [NSNull()]
-        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testStringAck() {
-        let expectedSendString = "30[\"test\"]"
         let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testJSONAck() {
-        let expectedSendString = "30[{\"null\":null,\"hello\":1,\"test\":\"hello\",\"foobar\":true}]"
         let sendData = [["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
-        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testBinaryAck() {
-        let expectedSendString = "61-0[{\"_placeholder\":true,\"num\":0}]"
         let sendData = [data]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .binaryAck)
         XCTAssertEqual(packet.binary, [data])
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            ["_placeholder": true, "num": 0]
+        ]))
     }
 
     func testMultipleBinaryAck() {
-        let expectedSendString = "62-0[{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
         let sendData = [["data1": data, "data2": data2]]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data2, data])
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertEqual(parsed.type, .binaryAck)
+
+        let binaryObj = parsed.data[0] as! [String: Any]
+        let data1Loc = (binaryObj["data1"] as! [String: Any])["num"] as! Int
+        let data2Loc = (binaryObj["data2"] as! [String: Any])["num"] as! Int
+
+        XCTAssertEqual(packet.binary[data1Loc], data)
+        XCTAssertEqual(packet.binary[data2Loc], data2)
     }
 
     func testBinaryStringPlaceholderInMessage() {
@@ -159,4 +196,20 @@ class SocketBasicPacketTest: XCTestCase {
         _ = packet.addData(data2)
         XCTAssertEqual(packet.args[0] as? String, "~~0")
     }
+
+    private func compareAnyArray(input: [Any], expected: [Any]) -> Bool {
+        guard input.count == expected.count else { return false }
+
+        return (input as NSArray).isEqual(to: expected)
+    }
+
+    let data = "test".data(using: String.Encoding.utf8)!
+    let data2 = "test2".data(using: String.Encoding.utf8)!
+    var parser: SocketParsable!
+
+    override func setUp() {
+        super.setUp()
+
+        parser = SocketManager(socketURL: URL(string: "http://localhost")!)
+    }
 }

Tests/TestSocketIO/SocketNamespacePacketTest.swift

@@ -9,133 +9,198 @@
 import XCTest
 @testable import SocketIO
 
-class SocketNamespacePacketTest: XCTestCase {
-    let data = "test".data(using: String.Encoding.utf8)!
-    let data2 = "test2".data(using: String.Encoding.utf8)!
-    
-    func testEmpyEmit() {
-        let expectedSendString = "2/swift,[\"test\"]"
+class SocketNamespacePacketTest : XCTestCase {
+    func testEmptyEmit() {
         let sendData: [Any] = ["test"]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testNullEmit() {
-        let expectedSendString = "2/swift,[\"test\",null]"
         let sendData: [Any] = ["test", NSNull()]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testStringEmit() {
-        let expectedSendString = "2/swift,[\"test\",\"foo bar\"]"
         let sendData: [Any] = ["test", "foo bar"]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testJSONEmit() {
-        let expectedSendString = "2/swift,[\"test\",{\"null\":null,\"test\":\"hello\",\"hello\":1,\"foobar\":true}]"
         let sendData: [Any] = ["test", ["foobar": true, "hello": 1, "test": "hello", "null": NSNull()] as NSDictionary]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testArrayEmit() {
-        let expectedSendString = "2/swift,[\"test\",[\"hello\",1,{\"test\":\"test\"},true]]"
         let sendData: [Any] = ["test", ["hello", 1, ["test": "test"], true]]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testBinaryEmit() {
-        let expectedSendString = "51-/swift,[\"test\",{\"_placeholder\":true,\"num\":0}]"
         let sendData: [Any] = ["test", data]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .binaryEvent)
+        XCTAssertEqual(parsed.nsp, "/swift")
         XCTAssertEqual(packet.binary, [data])
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            "test",
+            ["_placeholder": true, "num": 0]
+        ]))
     }
 
     func testMultipleBinaryEmit() {
-        let expectedSendString = "52-/swift,[\"test\",{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
         let sendData: [Any] = ["test", ["data1": data, "data2": data2] as NSDictionary]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data2, data])
+        XCTAssertEqual(parsed.type, .binaryEvent)
+        XCTAssertEqual(parsed.nsp, "/swift")
+
+        let binaryObj = parsed.data[1] as! [String: Any]
+        let data1Loc = (binaryObj["data1"] as! [String: Any])["num"] as! Int
+        let data2Loc = (binaryObj["data2"] as! [String: Any])["num"] as! Int
+
+        XCTAssertEqual(packet.binary[data1Loc], data)
+        XCTAssertEqual(packet.binary[data2Loc], data2)
     }
 
     func testEmitWithAck() {
-        let expectedSendString = "2/swift,0[\"test\"]"
         let sendData = ["test"]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testEmitDataWithAck() {
-        let expectedSendString = "51-/swift,0[\"test\",{\"_placeholder\":true,\"num\":0}]"
         let sendData: [Any] = ["test", data]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data])
+        XCTAssertEqual(parsed.type, .binaryEvent)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            "test",
+            ["_placeholder": true, "num": 0]
+        ]))
     }
 
     // Acks
     func testEmptyAck() {
-        let expectedSendString = "3/swift,0[]"
         let packet = SocketPacket.packetFromEmit([], id: 0, nsp: "/swift", ack: true)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
     }
 
     func testNullAck() {
-        let expectedSendString = "3/swift,0[null]"
         let sendData = [NSNull()]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testStringAck() {
-        let expectedSendString = "3/swift,0[\"test\"]"
         let sendData = ["test"]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testJSONAck() {
-        let expectedSendString = "3/swift,0[{\"null\":null,\"hello\":1,\"test\":\"hello\",\"foobar\":true}]"
         let sendData = [["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testBinaryAck() {
-        let expectedSendString = "61-/swift,0[{\"_placeholder\":true,\"num\":0}]"
         let sendData = [data]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data])
+        XCTAssertEqual(parsed.type, .binaryAck)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            ["_placeholder": true, "num": 0]
+        ]))
     }
 
     func testMultipleBinaryAck() {
-        let expectedSendString = "62-/swift,0[{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
         let sendData = [["data1": data, "data2": data2]]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data2, data])
+        XCTAssertEqual(parsed.type, .binaryAck)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+
+        let binaryObj = parsed.data[0] as! [String: Any]
+        let data1Loc = (binaryObj["data1"] as! [String: Any])["num"] as! Int
+        let data2Loc = (binaryObj["data2"] as! [String: Any])["num"] as! Int
+
+        XCTAssertEqual(packet.binary[data1Loc], data)
+        XCTAssertEqual(packet.binary[data2Loc], data2)
+    }
+
+    let data = "test".data(using: String.Encoding.utf8)!
+    let data2 = "test2".data(using: String.Encoding.utf8)!
+    var parser: SocketParsable!
+
+    private func compareAnyArray(input: [Any], expected: [Any]) -> Bool {
+        guard input.count == expected.count else { return false }
+
+        return (input as NSArray).isEqual(to: expected)
+    }
+
+    override func setUp() {
+        super.setUp()
+
+        parser = SocketManager(socketURL: URL(string: "http://localhost")!)
     }
 }

Tests/TestSocketIOObjc/ManagerObjectiveCTest.m

@@ -13,9 +13,18 @@
 
 - (void)testSettingConfig {
     NSURL* url = [[NSURL alloc] initWithString:@"http://localhost"];
-    self.manager = [[TestManager alloc] initWithSocketURL:url config:@{@"forceNew": @YES}];
+    NSDictionary* headers = @{@"My Header": @"Some Value"};
+
+    self.manager = [[TestManager alloc] initWithSocketURL:url config:@{
+            @"forceNew": @YES,
+            @"extraHeaders": headers
+    }];
+
+    [self.manager connect];
 
     XCTAssertTrue(self.manager.forceNew);
+    XCTAssertTrue([self.manager.engine.extraHeaders isEqualToDictionary:headers]);
+
 }
 
 - (void)testManagerProperties {