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

Fix tests so they don't rely on comparing strings or the order of hashed collections

Browse Source
This commit is contained in:
Erik Little 2018-06-07 09:25:34 -04:00
parent 0a7e1f4185
commit 2629449436
No known key found for this signature in database
GPG Key ID: 62F837E56F4E9320
3 changed files with 240 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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"

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")!)
}
} }

145
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(parsed.type, .event)
XCTAssertEqual(packet.packetString, expectedSendString) 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(parsed.type, .binaryEvent)
XCTAssertEqual(packet.binary, [data2, data]) 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(parsed.type, .binaryEvent)
XCTAssertEqual(packet.binary, [data]) 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(parsed.type, .binaryAck)
XCTAssertEqual(packet.binary, [data]) 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(parsed.type, .binaryAck)
XCTAssertEqual(packet.binary, [data2, data]) 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")!)
} }
} }