Skip to content

Commit 2629449

Browse files
nuclearacenuclearace
committed
Fix tests so they don't rely on comparing strings or the order of hashed collections
1 parent 0a7e1f4 commit 2629449

File tree

3 files changed

+241
-125
lines changed

3 files changed

+241
-125
lines changed

‎Cartfile.resolved‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1 @@
1-
github "daltoniam/Starscream" "3.0.4"
2-
github "daltoniam/common-crypto-spm" "1.1.0"
3-
github "daltoniam/zlib-spm" "1.1.0"
1+
github "daltoniam/Starscream" "3.0.5"

‎Tests/TestSocketIO/SocketBasicPacketTest.swift‎

Lines changed: 106 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -9,143 +9,180 @@
99
import XCTest
1010
@testable import SocketIO
1111

12-
class SocketBasicPacketTest: XCTestCase {
13-
let data = "test".data(using: String.Encoding.utf8)!
14-
let data2 = "test2".data(using: String.Encoding.utf8)!
15-
16-
func testEmpyEmit() {
17-
let expectedSendString = "2[\"test\"]"
12+
class SocketBasicPacketTest : XCTestCase {
13+
func testEmptyEmit() {
1814
let sendData = ["test"]
19-
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
15+
let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
16+
let parsed = parser.parseSocketMessage(packetStr)!
2017

21-
XCTAssertEqual(packet.packetString, expectedSendString)
18+
XCTAssertEqual(parsed.type, .event)
19+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
2220
}
2321

2422
func testNullEmit() {
25-
let expectedSendString = "2[\"test\",null]"
2623
let sendData: [Any] = ["test", NSNull()]
27-
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
24+
let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
25+
let parsed = parser.parseSocketMessage(packetStr)!
2826

29-
XCTAssertEqual(packet.packetString, expectedSendString)
27+
XCTAssertEqual(parsed.type, .event)
28+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
3029
}
3130

3231
func testStringEmit() {
33-
let expectedSendString = "2[\"test\",\"foo bar\"]"
3432
let sendData = ["test", "foo bar"]
35-
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
33+
let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
34+
let parsed = parser.parseSocketMessage(packetStr)!
3635

37-
XCTAssertEqual(packet.packetString, expectedSendString)
36+
XCTAssertEqual(parsed.type, .event)
37+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
3838
}
3939

4040
func testStringEmitWithQuotes() {
41-
let expectedSendString = "2[\"test\",\"\\\"he\\\"llo world\\\"\"]"
4241
let sendData = ["test", "\"he\"llo world\""]
43-
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
42+
let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
43+
let parsed = parser.parseSocketMessage(packetStr)!
4444

45-
XCTAssertEqual(packet.packetString, expectedSendString)
45+
XCTAssertEqual(parsed.type, .event)
46+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
4647
}
4748

4849
func testJSONEmit() {
49-
let expectedSendString = "2[\"test\",{\"null\":null,\"hello\":1,\"test\":\"hello\",\"foobar\":true}]"
5050
let sendData: [Any] = ["test", ["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
51-
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
51+
let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
52+
let parsed = parser.parseSocketMessage(packetStr)!
5253

53-
XCTAssertEqual(packet.packetString, expectedSendString)
54+
XCTAssertEqual(parsed.type, .event)
55+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
5456
}
5557

5658
func testArrayEmit() {
57-
let expectedSendString = "2[\"test\",[\"hello\",1,{\"test\":\"test\"}]]"
5859
let sendData: [Any] = ["test", ["hello", 1, ["test": "test"]]]
59-
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
60+
let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
61+
let parsed = parser.parseSocketMessage(packetStr)!
6062

61-
XCTAssertEqual(packet.packetString, expectedSendString)
63+
XCTAssertEqual(parsed.type, .event)
64+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
6265
}
6366

6467
func testBinaryEmit() {
65-
let expectedSendString = "51-[\"test\",{\"_placeholder\":true,\"num\":0}]"
6668
let sendData: [Any] = ["test", data]
6769
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
70+
let parsed = parser.parseSocketMessage(packet.packetString)!
6871

69-
XCTAssertEqual(packet.packetString, expectedSendString)
72+
XCTAssertEqual(parsed.type, .binaryEvent)
7073
XCTAssertEqual(packet.binary, [data])
74+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
75+
"test",
76+
["_placeholder": true, "num": 0]
77+
]))
7178
}
7279

7380
func testMultipleBinaryEmit() {
74-
let expectedSendString = "52-[\"test\",{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
7581
let sendData: [Any] = ["test", ["data1": data, "data2": data2] as NSDictionary]
7682
let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
83+
let parsed = parser.parseSocketMessage(packet.packetString)!
84+
85+
XCTAssertEqual(parsed.type, .binaryEvent)
86+
87+
let binaryObj = parsed.data[1] as! [String: Any]
88+
let data1Loc = (binaryObj["data1"] as! [String: Any])["num"] as! Int
89+
let data2Loc = (binaryObj["data2"] as! [String: Any])["num"] as! Int
7790

78-
XCTAssertEqual(packet.packetString, expectedSendString)
79-
XCTAssertEqual(packet.binary, [data2, data])
91+
XCTAssertEqual(packet.binary[data1Loc], data)
92+
XCTAssertEqual(packet.binary[data2Loc], data2)
8093
}
8194

8295
func testEmitWithAck() {
83-
let expectedSendString = "20[\"test\"]"
8496
let sendData = ["test"]
85-
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false)
86-
87-
XCTAssertEqual(packet.packetString,
97+
let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false).packetString
98+
let parsed = parser.parseSocketMessage(packetStr)!
8899

89-
expectedSendString)
100+
XCTAssertEqual(parsed.type, .event)
101+
XCTAssertEqual(parsed.id, 0)
102+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
90103
}
91104

92105
func testEmitDataWithAck() {
93-
let expectedSendString = "51-0[\"test\",{\"_placeholder\":true,\"num\":0}]"
94106
let sendData: [Any] = ["test", data]
95107
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false)
96-
97-
XCTAssertEqual(packet.packetString, expectedSendString)
108+
let parsed = parser.parseSocketMessage(packet.packetString)!
109+
110+
XCTAssertEqual(parsed.type, .binaryEvent)
111+
XCTAssertEqual(parsed.id, 0)
112+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
113+
"test",
114+
["_placeholder": true, "num": 0]
115+
]))
98116
XCTAssertEqual(packet.binary, [data])
99117
}
100118

101119
// Acks
102120
func testEmptyAck() {
103-
let expectedSendString = "30[]"
104-
let packet = SocketPacket.packetFromEmit([], id: 0, nsp: "/", ack: true)
121+
let packetStr = SocketPacket.packetFromEmit([], id: 0, nsp: "/", ack: true).packetString
122+
let parsed = parser.parseSocketMessage(packetStr)!
105123

106-
XCTAssertEqual(packet.packetString, expectedSendString)
124+
XCTAssertEqual(parsed.type, .ack)
125+
XCTAssertEqual(parsed.id, 0)
126+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: []))
107127
}
108128

109129
func testNullAck() {
110-
let expectedSendString = "30[null]"
111130
let sendData = [NSNull()]
112-
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
131+
let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true).packetString
132+
let parsed = parser.parseSocketMessage(packetStr)!
113133

114-
XCTAssertEqual(packet.packetString, expectedSendString)
134+
XCTAssertEqual(parsed.type, .ack)
135+
XCTAssertEqual(parsed.id, 0)
136+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
115137
}
116138

117139
func testStringAck() {
118-
let expectedSendString = "30[\"test\"]"
119140
let sendData = ["test"]
120-
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
141+
let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true).packetString
142+
let parsed = parser.parseSocketMessage(packetStr)!
121143

122-
XCTAssertEqual(packet.packetString, expectedSendString)
144+
XCTAssertEqual(parsed.type, .ack)
145+
XCTAssertEqual(parsed.id, 0)
146+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
123147
}
124148

125149
func testJSONAck() {
126-
let expectedSendString = "30[{\"null\":null,\"hello\":1,\"test\":\"hello\",\"foobar\":true}]"
127150
let sendData = [["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
128-
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
151+
let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true).packetString
152+
let parsed = parser.parseSocketMessage(packetStr)!
129153

130-
XCTAssertEqual(packet.packetString, expectedSendString)
154+
XCTAssertEqual(parsed.type, .ack)
155+
XCTAssertEqual(parsed.id, 0)
156+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
131157
}
132158

133159
func testBinaryAck() {
134-
let expectedSendString = "61-0[{\"_placeholder\":true,\"num\":0}]"
135160
let sendData = [data]
136161
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
162+
let parsed = parser.parseSocketMessage(packet.packetString)!
137163

138-
XCTAssertEqual(packet.packetString, expectedSendString)
164+
XCTAssertEqual(parsed.type, .binaryAck)
139165
XCTAssertEqual(packet.binary, [data])
166+
XCTAssertEqual(parsed.id, 0)
167+
XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
168+
["_placeholder": true, "num": 0]
169+
]))
140170
}
141171

142172
func testMultipleBinaryAck() {
143-
let expectedSendString = "62-0[{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
144173
let sendData = [["data1": data, "data2": data2]]
145174
let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
175+
let parsed = parser.parseSocketMessage(packet.packetString)!
176+
177+
XCTAssertEqual(parsed.id, 0)
178+
XCTAssertEqual(parsed.type, .binaryAck)
146179

147-
XCTAssertEqual(packet.packetString, expectedSendString)
148-
XCTAssertEqual(packet.binary, [data2, data])
180+
let binaryObj = parsed.data[0] as! [String: Any]
181+
let data1Loc = (binaryObj["data1"] as! [String: Any])["num"] as! Int
182+
let data2Loc = (binaryObj["data2"] as! [String: Any])["num"] as! Int
183+
184+
XCTAssertEqual(packet.binary[data1Loc], data)
185+
XCTAssertEqual(packet.binary[data2Loc], data2)
149186
}
150187

151188
func testBinaryStringPlaceholderInMessage() {
@@ -159,4 +196,20 @@ class SocketBasicPacketTest: XCTestCase {
159196
_ = packet.addData(data2)
160197
XCTAssertEqual(packet.args[0] as? String, "~~0")
161198
}
199+
200+
private func compareAnyArray(input: [Any], expected: [Any]) -> Bool {
201+
guard input.count == expected.count else { return false }
202+
203+
return (input as NSArray).isEqual(to: expected)
204+
}
205+
206+
let data = "test".data(using: String.Encoding.utf8)!
207+
let data2 = "test2".data(using: String.Encoding.utf8)!
208+
var parser: SocketParsable!
209+
210+
override func setUp() {
211+
super.setUp()
212+
213+
parser = SocketManager(socketURL: URL(string: "http://localhost")!)
214+
}
162215
}

0 commit comments

Comments
 (0)