CommandLineToolkit

1
import Foundation
2
import JSONStream
3
import TestHelpers
4
import XCTest
5

6
class JSONReaderTests: XCTestCase {
7
    let eventStream = FakeEventStream()
8
    
9
    func testEmptyObject() throws {
10
        let jsonStream = FakeJSONStream(string: "{}")
11
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
12
        try reader.start()
13
        
14
        // swiftlint:disable:next empty_count
15
        XCTAssertTrue(eventStream.allObjects[0].count == 0)
16
    }
17
    
18
    func testEmptyArray() throws {
19
        let jsonStream = FakeJSONStream(string: "[]")
20
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
21
        try reader.start()
22
        
23
        // swiftlint:disable:next empty_count
24
        XCTAssertTrue(eventStream.allArrays[0].count == 0)
25
    }
26
    
27
    func testSimpleObject() throws {
28
        let jsonStream = FakeJSONStream(string: "{\"the key\": \"the value\"}")
29
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
30
        try reader.start()
31
        
32
        XCTAssertEqual(eventStream.allObjects[0], ["the key": "the value"])
33
    }
34
    
35
    func testSimpleArrayWithString() throws {
36
        let jsonStream = FakeJSONStream(string: "[\"value\"]")
37
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
38
        try reader.start()
39
        
40
        XCTAssertEqual(eventStream.allArrays[0], ["value"])
41
    }
42
    
43
    func testBrokenArrayWithSingleComma() throws {
44
        let jsonStream = FakeJSONStream(string: "[\"value\",]")
45
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
46
        assertThrows { try reader.start() }
47
    }
48
    
49
    func testBrokenArrayWithDoubleComma() throws {
50
        let jsonStream = FakeJSONStream(string: "[\"value\",,]")
51
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
52
        assertThrows { try reader.start() }
53
    }
54
    
55
    func testBrokenArrayWithOnlyComma() throws {
56
        let jsonStream = FakeJSONStream(string: "[,]")
57
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
58
        assertThrows { try reader.start() }
59
    }
60
    
61
    func testSimpleArrayWithMultipleStrings() throws {
62
        let jsonStream = FakeJSONStream(string: "[\"obj1\",\"obj2\",\"obj3\"]")
63
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
64
        try reader.start()
65
        
66
        XCTAssertEqual(eventStream.allArrays[0], ["obj1", "obj2", "obj3"])
67
    }
68
    
69
    func testKeyToObject() throws {
70
        let jsonStream = FakeJSONStream(string: "{\"the key\": {\"subobject\": \"subvalue\"}}")
71
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
72
        try reader.start()
73
        
74
        XCTAssertEqual(eventStream.allObjects[0], ["the key": ["subobject": "subvalue"]])
75
    }
76
    
77
    func testMultipleKeys() throws {
78
        let jsonStream = FakeJSONStream(string: "{\"one\": \"1\", \"two\": \"2\"}")
79
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
80
        try reader.start()
81
        
82
        XCTAssertEqual(eventStream.allObjects[0], ["one": "1", "two": "2"])
83
    }
84
    
85
    func testMultipleCommasInObject() throws {
86
        let jsonStream = FakeJSONStream(string: "{\"one\": \"1\",, \"two\": \"2\"}")
87
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
88
        assertThrows { try reader.start() }
89
    }
90
    
91
    func testObjectWithTailingComma() throws {
92
        let jsonStream = FakeJSONStream(string: "{\"one\": \"1\",}")
93
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
94
        assertThrows { try reader.start() }
95
    }
96
    
97
    func testEmptyValue() throws {
98
        let jsonStream = FakeJSONStream(string: "{\"key\": \"\"}")
99
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
100
        try reader.start()
101
        
102
        XCTAssertEqual(eventStream.allObjects[0], ["key": ""])
103
    }
104
    
105
    func testTwoObjectsInStream() throws {
106
        let jsonStream = FakeJSONStream(string: "{\"key1\": \"value1\"}{\"key2\": \"value2\"}")
107
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
108
        try reader.start()
109
        XCTAssertEqual(eventStream.all.count, 2)
110
        XCTAssertEqual(eventStream.allObjects[0], ["key1": "value1"])
111
        XCTAssertEqual(eventStream.allObjects[1], ["key2": "value2"])
112
    }
113
    
114
    func testArrayWithNull() throws {
115
        let jsonStream = FakeJSONStream(string: "[null]")
116
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
117
        try reader.start()
118
        
119
        XCTAssertEqual(eventStream.allArrays[0], [NSNull()])
120
    }
121
    
122
    func testObjectWithNullValue() throws {
123
        let jsonStream = FakeJSONStream(string: "{\"key\": null}")
124
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
125
        try reader.start()
126
        
127
        XCTAssertEqual(eventStream.allObjects[0], ["key": NSNull()])
128
    }
129
    
130
    func testObjectWithNullKeyFails() throws {
131
        let jsonStream = FakeJSONStream(string: "{null: \"value\"}")
132
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
133
        assertThrows { try reader.start() }
134
    }
135
    
136
    func testArrayWithTrue() throws {
137
        let jsonStream = FakeJSONStream(string: "[true]")
138
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
139
        try reader.start()
140
        
141
        XCTAssertEqual(eventStream.allArrays[0], [true])
142
    }
143
    
144
    func testObjectWithTrueValue() throws {
145
        let jsonStream = FakeJSONStream(string: "{\"key\": true}")
146
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
147
        try reader.start()
148
        
149
        XCTAssertEqual(eventStream.allObjects[0], ["key": true])
150
    }
151
    
152
    func testObjectWithTrueKeyFails() throws {
153
        let jsonStream = FakeJSONStream(string: "{true: \"value\"}")
154
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
155
        assertThrows { try reader.start() }
156
    }
157
    
158
    func testArrayWithFalse() throws {
159
        let jsonStream = FakeJSONStream(string: "[false]")
160
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
161
        try reader.start()
162
        
163
        XCTAssertEqual(eventStream.allArrays[0], [false])
164
    }
165
    
166
    func testArrayWithUnparsableFalse() throws {
167
        let jsonStream = FakeJSONStream(string: "[fulse]")
168
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
169
        
170
        assertThrows {
171
            try reader.start()
172
        }
173
    }
174
    
175
    func testObjectWithFalseValue() throws {
176
        let jsonStream = FakeJSONStream(string: "{\"key\": false}")
177
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
178
        try reader.start()
179
        
180
        XCTAssertEqual(eventStream.allObjects[0], ["key": false])
181
    }
182
    
183
    func testObjectWithFalseKeyFails() throws {
184
        let jsonStream = FakeJSONStream(string: "{false: \"value\"}")
185
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
186
        assertThrows { try reader.start() }
187
    }
188
    
189
    func testArrayWithNullTrueFalseObjectAndString() throws {
190
        let jsonStream = FakeJSONStream(string: "[null, true, false, {\"key\": \"value\"}, \"string\"]")
191
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
192
        try reader.start()
193
        
194
        XCTAssertEqual(eventStream.allArrays[0], [NSNull(), true, false, ["key": "value"], "string"])
195
    }
196
    
197
    func testArraySingleNumber() throws {
198
        let jsonStream = FakeJSONStream(string: "[42]")
199
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
200
        try reader.start()
201
        
202
        XCTAssertEqual(eventStream.allArrays[0], [42])
203
    }
204
    
205
    func testArraySingleNegativeNumber() throws {
206
        let jsonStream = FakeJSONStream(string: "[-42]")
207
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
208
        try reader.start()
209
        
210
        XCTAssertEqual(eventStream.allArrays[0], [-42])
211
    }
212
    
213
    func testArrayTwoNumbers() throws {
214
        let jsonStream = FakeJSONStream(string: "[-42, 42]")
215
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
216
        try reader.start()
217
        
218
        XCTAssertEqual(eventStream.allArrays[0], [-42, 42])
219
    }
220
    
221
    func testArrayWithExponentialNumbers() throws {
222
        let jsonStream = FakeJSONStream(string: "[-42e-3, 42e+3]")
223
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
224
        try reader.start()
225
        
226
        XCTAssertEqual(eventStream.allArrays[0], [-0.042, 42000])
227
    }
228
    
229
    func testArrayWithNegativeDoubleExponentialNumber() throws {
230
        let jsonStream = FakeJSONStream(string: "[-14318475.1248132e7]")
231
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
232
        try reader.start()
233
        
234
        XCTAssertEqual(eventStream.allArrays[0], [-143184751248132])
235
    }
236
    
237
    func testObjectWithSingleNumberValue() throws {
238
        let jsonStream = FakeJSONStream(string: "{\"key\": 42}")
239
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
240
        try reader.start()
241
        
242
        XCTAssertEqual(eventStream.allObjects[0], ["key": 42])
243
    }
244
    
245
    func testArrayWithIncorrectNumber() throws {
246
        let jsonStream = FakeJSONStream(string: "[-12ABA]")
247
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
248
        assertThrows { try reader.start() }
249
    }
250
    
251
    func testObjectWithIncorrectNumberValue() throws {
252
        let jsonStream = FakeJSONStream(string: "{\"key\": -12.bad-number}")
253
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
254
        assertThrows { try reader.start() }
255
    }
256
    
257
    func testObjectWithArrayValue() throws {
258
        let jsonStream = FakeJSONStream(string: "{\"key\":[\"obj\"]}")
259
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
260
        try reader.start()
261
        
262
        XCTAssertEqual(eventStream.all.count, 1)
263
        XCTAssertEqual(eventStream.allObjects[0], ["key": ["obj"]])
264
    }
265
    
266
    func testArrayWithArray() throws {
267
        let jsonStream = FakeJSONStream(string: "[[\"obj\"]]")
268
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
269
        try reader.start()
270
        
271
        XCTAssertEqual(eventStream.all.count, 1)
272
        XCTAssertEqual(eventStream.allArrays[0], [["obj"]])
273
    }
274
    
275
    func testArrayWithObject() throws {
276
        let jsonStream = FakeJSONStream(string: "[{\"key\":\"value\"}]")
277
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
278
        try reader.start()
279
        
280
        XCTAssertEqual(eventStream.all.count, 1)
281
        XCTAssertEqual(eventStream.allArrays[0], [["key": "value"]])
282
    }
283

284
    func testComplexStream() throws {
285
        let dict: [String: Any] = [
286
            "key": [true, false, NSNull()] as [Any],
287
            "second_key": [
288
                "subobject_key1": 12,
289
                "subobject_key2": "string with spaces"
290
            ] as [String: Any]
291
        ]
292
        let array: [Any] = ["string!", dict, false, 12e2]
293

294
        let firstObjectString = try assertNotNil { String(data: try JSONSerialization.data(withJSONObject: dict, options: [.prettyPrinted]), encoding: .utf8) }
295
        let secondObjectString = try assertNotNil { String(data: try JSONSerialization.data(withJSONObject: array, options: [.prettyPrinted]), encoding: .utf8) }
296

297
        let jsonStream = FakeJSONStream(string: firstObjectString + "\n" + secondObjectString)
298
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
299
        try reader.start()
300

301
        XCTAssertEqual(eventStream.all.count, 2)
302
        XCTAssertEqual(eventStream.allObjects[0], dict as NSDictionary)
303
        XCTAssertEqual(eventStream.allArrays[0], array as NSArray)
304
    }
305
    
306
    func testEventStreamGetsScalars() throws {
307
        let jsonStream = FakeJSONStream(string: "[[\"obj\"]]")
308
        let reader = JSONReader(inputStream: jsonStream, eventStream: eventStream)
309
        try reader.start()
310
        
311
        XCTAssertEqual(eventStream.allData.count, 1)
312
        let string = String(data: Data(eventStream.allData[0]), encoding: .utf8)
313
        XCTAssertEqual(string, "[[\"obj\"]]")
314
    }
315
}
316