cheykrym/socket.io-client-swift
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'development'

Browse Source 
* 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
This commit is contained in:
Erik Little 2018-06-07 09:50:01 -04:00
commit d06c1e5f5b
No known key found for this signature in database
GPG Key ID: 62F837E56F4E9320
11 changed files with 279 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CHANGELOG.md
View File

@ -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 # v13.2.0
- Add ability to bypass Data inspection in emits. [#992]((https://github.com/socketio/socket.io-client-swift/issues/992)) - Add ability to bypass Data inspection in emits. [#992]((https://github.com/socketio/socket.io-client-swift/issues/992))

4
Cartfile.resolved
View File

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

4
Package.resolved
View File

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

4
Source/SocketIO/Ack/SocketAckEmitter.swift
View File

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

8
Source/SocketIO/Client/SocketIOClient.swift
View File

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

12
Source/SocketIO/Client/SocketRawView.swift
View File

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

11
Source/SocketIO/Engine/SocketEngine.swift
View File

@ -371,6 +371,13 @@ open class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePollable, So
fastUpgrade = false fastUpgrade = false
probing = false probing = false
flushProbeWait() 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() { private func flushProbeWait() {
@ -381,10 +388,6 @@ open class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePollable, So
} }
probeWait.removeAll(keepingCapacity: false) 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 /// Causes any packets that were waiting for POSTing to be sent through the WebSocket. This happens because when

3
Source/SocketIO/Manager/SocketManager.swift
View File

@ -169,6 +169,9 @@ open class SocketManager : NSObject, SocketManagerSpec, SocketParsable, SocketDa
engine?.engineQueue.sync { engine?.engineQueue.sync {
self.engine?.client = nil 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) engine = SocketEngine(client: self, url: socketURL, config: config)

157
Tests/TestSocketIO/SocketBasicPacketTest.swift
View File

@ -9,143 +9,180 @@
import XCTest import XCTest
@testable import SocketIO @testable import SocketIO
class SocketBasicPacketTest: XCTestCase { class SocketBasicPacketTest : XCTestCase {
let data = "test".data(using: String.Encoding.utf8)! func testEmptyEmit() {
let data2 = "test2".data(using: String.Encoding.utf8)!
func testEmpyEmit() {
let expectedSendString = "2[\"test\"]"
let sendData = ["test"] 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() { func testNullEmit() {
let expectedSendString = "2[\"test\",null]"
let sendData: [Any] = ["test", NSNull()] 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() { func testStringEmit() {
let expectedSendString = "2[\"test\",\"foo bar\"]"
let sendData = ["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() { func testStringEmitWithQuotes() {
let expectedSendString = "2[\"test\",\"\\\"he\\\"llo world\\\"\"]"
let sendData = ["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() { 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 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() { func testArrayEmit() {
let expectedSendString = "2[\"test\",[\"hello\",1,{\"test\":\"test\"}]]"
let sendData: [Any] = ["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() { func testBinaryEmit() {
let expectedSendString = "51-[\"test\",{\"_placeholder\":true,\"num\":0}]"
let sendData: [Any] = ["test", data] let sendData: [Any] = ["test", data]
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false) 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]) XCTAssertEqual(packet.binary, [data])
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
"test",
["_placeholder": true, "num": 0]
]))
} }
func testMultipleBinaryEmit() { 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 sendData: [Any] = ["test", ["data1": data, "data2": data2] as NSDictionary]
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false) 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, [data2, data])
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() { func testEmitWithAck() {
let expectedSendString = "20[\"test\"]"
let sendData = ["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, XCTAssertEqual(parsed.type, .event)
XCTAssertEqual(parsed.id, 0)
expectedSendString) XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
} }
func testEmitDataWithAck() { func testEmitDataWithAck() {
let expectedSendString = "51-0[\"test\",{\"_placeholder\":true,\"num\":0}]"
let sendData: [Any] = ["test", data] let sendData: [Any] = ["test", data]
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false) 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]) XCTAssertEqual(packet.binary, [data])
} }
// Acks // Acks
func testEmptyAck() { func testEmptyAck() {
let expectedSendString = "30[]" let packetStr = SocketPacket.packetFromEmit([], id: 0, nsp: "/", ack: true).packetString
let packet = SocketPacket.packetFromEmit([], id: 0, nsp: "/", ack: true) 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() { func testNullAck() {
let expectedSendString = "30[null]"
let sendData = [NSNull()] 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() { func testStringAck() {
let expectedSendString = "30[\"test\"]"
let sendData = ["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() { func testJSONAck() {
let expectedSendString = "30[{\"null\":null,\"hello\":1,\"test\":\"hello\",\"foobar\":true}]"
let sendData = [["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]] 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() { func testBinaryAck() {
let expectedSendString = "61-0[{\"_placeholder\":true,\"num\":0}]"
let sendData = [data] let sendData = [data]
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true) 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(packet.binary, [data])
XCTAssertEqual(parsed.id, 0)
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
["_placeholder": true, "num": 0]
]))
} }
func testMultipleBinaryAck() { func testMultipleBinaryAck() {
let expectedSendString = "62-0[{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
let sendData = [["data1": data, "data2": data2]] let sendData = [["data1": data, "data2": data2]]
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true) let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
let parsed = parser.parseSocketMessage(packet.packetString)!
XCTAssertEqual(packet.packetString, expectedSendString) XCTAssertEqual(parsed.id, 0)
XCTAssertEqual(packet.binary, [data2, data]) 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() { func testBinaryStringPlaceholderInMessage() {
@ -159,4 +196,20 @@ class SocketBasicPacketTest: XCTestCase {
_ = packet.addData(data2) _ = packet.addData(data2)
XCTAssertEqual(packet.args[0] as? String, "~~0") 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")!)
}
} }

203
Tests/TestSocketIO/SocketNamespacePacketTest.swift
View File

@ -9,133 +9,198 @@
import XCTest import XCTest
@testable import SocketIO @testable import SocketIO
class SocketNamespacePacketTest: XCTestCase { class SocketNamespacePacketTest : XCTestCase {
let data = "test".data(using: String.Encoding.utf8)! func testEmptyEmit() {
let data2 = "test2".data(using: String.Encoding.utf8)!
func testEmpyEmit() {
let expectedSendString = "2/swift,[\"test\"]"
let sendData: [Any] = ["test"] let sendData: [Any] = ["test"]
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false) 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() { func testNullEmit() {
let expectedSendString = "2/swift,[\"test\",null]"
let sendData: [Any] = ["test", NSNull()] let sendData: [Any] = ["test", NSNull()]
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false) 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() { func testStringEmit() {
let expectedSendString = "2/swift,[\"test\",\"foo bar\"]"
let sendData: [Any] = ["test", "foo bar"] let sendData: [Any] = ["test", "foo bar"]
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false) 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() { 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 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 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() { func testArrayEmit() {
let expectedSendString = "2/swift,[\"test\",[\"hello\",1,{\"test\":\"test\"},true]]"
let sendData: [Any] = ["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 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() { func testBinaryEmit() {
let expectedSendString = "51-/swift,[\"test\",{\"_placeholder\":true,\"num\":0}]"
let sendData: [Any] = ["test", data] let sendData: [Any] = ["test", data]
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false) 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]) XCTAssertEqual(packet.binary, [data])
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
"test",
["_placeholder": true, "num": 0]
]))
} }
func testMultipleBinaryEmit() { 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 sendData: [Any] = ["test", ["data1": data, "data2": data2] as NSDictionary]
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false) 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() { func testEmitWithAck() {
let expectedSendString = "2/swift,0[\"test\"]"
let sendData = ["test"] let sendData = ["test"]
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: false) 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() { func testEmitDataWithAck() {
let expectedSendString = "51-/swift,0[\"test\",{\"_placeholder\":true,\"num\":0}]"
let sendData: [Any] = ["test", data] let sendData: [Any] = ["test", data]
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: false) 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 // Acks
func testEmptyAck() { func testEmptyAck() {
let expectedSendString = "3/swift,0[]"
let packet = SocketPacket.packetFromEmit([], id: 0, nsp: "/swift", ack: true) 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() { func testNullAck() {
let expectedSendString = "3/swift,0[null]"
let sendData = [NSNull()] let sendData = [NSNull()]
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true) 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() { func testStringAck() {
let expectedSendString = "3/swift,0[\"test\"]"
let sendData = ["test"] let sendData = ["test"]
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true) 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() { 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 sendData = [["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true) 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() { func testBinaryAck() {
let expectedSendString = "61-/swift,0[{\"_placeholder\":true,\"num\":0}]"
let sendData = [data] let sendData = [data]
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true) 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() { func testMultipleBinaryAck() {
let expectedSendString = "62-/swift,0[{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
let sendData = [["data1": data, "data2": data2]] let sendData = [["data1": data, "data2": data2]]
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true) 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")!)
} }
} }

11
Tests/TestSocketIOObjc/ManagerObjectiveCTest.m
View File

@ -13,9 +13,18 @@
- (void)testSettingConfig { - (void)testSettingConfig {
NSURL* url = [[NSURL alloc] initWithString:@"http://localhost"]; 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.forceNew);
XCTAssertTrue([self.manager.engine.extraHeaders isEqualToDictionary:headers]);
} }
- (void)testManagerProperties { - (void)testManagerProperties {