Debian Codegraph @

closure-library/closure/goog/net/streams/jsonstreamparser_test.js

raw
1 // Copyright 2015 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 goog.provide('goog.net.streams.JsonStreamParserTest');
16 goog.setTestOnly('goog.net.streams.JsonStreamParserTest');
17
18 goog.require('goog.array');
19 goog.require('goog.json');
20 goog.require('goog.labs.testing.JsonFuzzing');
21 goog.require('goog.net.streams.JsonStreamParser');
22 goog.require('goog.testing.asserts');
23 goog.require('goog.testing.jsunit');
24 goog.require('goog.uri.utils');
25
26
27 var debug;
28
29
30 function setUp() {
31 var uri = window.document.URL;
32 if (uri) {
33 var debugFlag = goog.uri.utils.getParamValue(uri, 'debug');
34 if (debugFlag) {
35 debug = window.document.getElementById('debug');
36 }
37 }
38 }
39
40
41 /**
42 * Debug is enabled with "&debug=on" on the URL.
43 *
44 * @param {string} info The debug info
45 */
46 function print(info) {
47 if (debug) {
48 debug.innerHTML += '<p><p>' + info;
49 }
50 }
51
52 function testEmptyStream() {
53 var parser = new goog.net.streams.JsonStreamParser();
54 var result = parser.parse('[]');
55 assertNull(result);
56 }
57
58 function testEmptyStreamMore() {
59 var parser = new goog.net.streams.JsonStreamParser();
60 var result = parser.parse(' [ ] ');
61 assertNull(result);
62
63 parser = new goog.net.streams.JsonStreamParser();
64 result = parser.parse(' [ ');
65 assertNull(result);
66
67 result = parser.parse(' ] ');
68 assertNull(result);
69
70 parser = new goog.net.streams.JsonStreamParser();
71 assertThrows(function() { parser.parse(' a [ '); });
72 assertThrows(function() { parser.parse(' [ ] '); });
73 }
74
75 function testSingleMessage() {
76 var parser = new goog.net.streams.JsonStreamParser();
77 var result = parser.parse('[{"a" : "b"}]');
78 assertEquals(1, result.length);
79 assertEquals('b', result[0].a);
80 }
81
82 function testEnclosingArray() {
83 var parser = new goog.net.streams.JsonStreamParser();
84 var result = parser.parse('[\n');
85 assertNull(result);
86
87 result = parser.parse('{"a" : "b"}');
88 assertEquals(1, result.length);
89 assertEquals('b', result[0].a);
90
91 result = parser.parse('\n]');
92 assertNull(result);
93 }
94
95 function testSingleMessageInChunks() {
96 var parser = new goog.net.streams.JsonStreamParser();
97 var result = parser.parse('[{"a" : ');
98 assertNull(result);
99 result = parser.parse('"b"}]');
100 assertEquals(1, result.length);
101 assertEquals('b', result[0].a);
102
103 parser = new goog.net.streams.JsonStreamParser();
104 result = parser.parse('[ { "a" : ');
105 assertNull(result);
106 result = parser.parse('"b"} ');
107 assertEquals(1, result.length);
108 assertEquals('b', result[0].a);
109
110 result = parser.parse('] ');
111 assertNull(result);
112 }
113
114 function testTwoMessages() {
115 var parser = new goog.net.streams.JsonStreamParser();
116 var result = parser.parse('[{"a" : "b"}, {"c" : "d"}]');
117 assertEquals(2, result.length);
118 assertEquals('b', result[0].a);
119 assertEquals('d', result[1].c);
120 }
121
122 function testTwoMessagesInChunks() {
123 var parser = new goog.net.streams.JsonStreamParser();
124 var result = parser.parse('[{"a" : "b"}, ');
125 assertEquals(1, result.length);
126 assertEquals('b', result[0].a);
127 result = parser.parse('{"c" : "d"} ');
128 assertEquals(1, result.length);
129 assertEquals('d', result[0].c);
130 result = parser.parse('] ');
131 assertNull(result);
132 assertThrows(function() { parser.parse(' a '); });
133 }
134
135
136 /**
137 * Parse a fuzzy json string only once.
138 */
139 function testSingleFuzzyMessages() {
140 var fuzzing = new goog.labs.testing.JsonFuzzing();
141
142 // total # of tests
143 for (var i = 0; i < 5; i++) {
144 var data = fuzzing.newArray();
145 var dataString = goog.json.serialize(data);
146 var parser = new goog.net.streams.JsonStreamParser();
147 var result = parser.parse(dataString);
148
149 assertEquals(data.length, result.length);
150 goog.array.forEach(data, function(elm, index) {
151 assertNotNull(elm);
152 assertObjectEquals(dataString, elm, result[index]);
153 });
154 }
155 }
156
157
158 /**
159 * Parse a fuzzy json string split (in two chunks) at each index of the string.
160 *
161 * This is a VERY expensive test, so change the fuzzing options for manual runs
162 * as required.
163 */
164 function testChunkedFuzzyMessages() {
165 var options = {jsonSize: 5, numFields: 5, arraySize: 4, maxDepth: 3};
166 var fuzzing = new goog.labs.testing.JsonFuzzing(options);
167
168 var data = fuzzing.newArray();
169 var dataString = goog.json.serialize(data);
170
171 print(dataString);
172
173 for (var j = 1; j < dataString.length; j++) {
174 var parser = new goog.net.streams.JsonStreamParser();
175 var result = [];
176
177 var string1 = dataString.substring(0, j);
178
179 var parsed = parser.parse(string1);
180 if (parsed) {
181 result = goog.array.concat(result, parsed);
182 }
183
184 var string2 = dataString.substring(j);
185
186 parsed = parser.parse(string2);
187 if (parsed) {
188 result = goog.array.concat(result, parsed);
189 }
190
191 assertEquals(data.length, result.length);
192 goog.array.forEach(data, function(elm, index) {
193 assertObjectEquals(dataString, elm, result[index]);
194 });
195 }
196 }
197
198
199 /**
200 * Parse a fuzzy json string in randomly generated chunks.
201 */
202 function testRandomlyChunkedFuzzyMessages() {
203 var fuzzing = new goog.labs.testing.JsonFuzzing();
204
205 var data = fuzzing.newArray();
206 var dataString = goog.json.serialize(data);
207
208 var parser = new goog.net.streams.JsonStreamParser();
209
210 var result = [];
211
212 print(dataString);
213
214 // randomly generated chunks
215 var pos = 0;
216 while (pos < dataString.length) {
217 var num = fuzzing.nextInt(1, dataString.length - pos);
218 var next = pos + num;
219 var subString = dataString.substring(pos, next);
220
221 print(subString);
222
223 pos = next;
224 var parsed = parser.parse(subString);
225 if (parsed) {
226 result = goog.array.concat(result, parsed);
227 }
228 }
229
230 assertEquals(data.length, result.length);
231 goog.array.forEach(data, function(elm, index) {
232 assertObjectEquals(dataString + '\n@' + index, elm, result[index]);
233 });
234 }
235
236
237 // TODO(user): add a fuzzy test for this.
238
239 function testGetExtraInput() {
240 var parser = new goog.net.streams.JsonStreamParser();
241 var result = parser.parse('[] , [[1, 2, 3]]');
242 assertNull(result);
243 assertTrue(parser.done());
244 assertEquals(' , [[1, 2, 3]]', parser.getExtraInput());
245
246 parser = new goog.net.streams.JsonStreamParser();
247 assertFalse(parser.done());
248 parser.parse(' [{"a" : "b"}, {"c" : "d" ');
249 assertFalse(parser.done());
250 parser.parse(' } ] a ');
251 assertTrue(parser.done());
252 assertEquals(' a ', parser.getExtraInput());
253 }
254
255
256 function testDeliverMessageAsRawString() {
257 var parser = new goog.net.streams.JsonStreamParser(
258 {'deliverMessageAsRawString': true});
259 var result = parser.parse(' [{"a" : "b"}, {"c" : "d"},[],{}] ');
260 assertEquals(4, result.length);
261 assertEquals('{"a" : "b"}', result[0]);
262 assertEquals(' {"c" : "d"}', result[1]);
263 assertEquals('[]', result[2]);
264 assertEquals('{}', result[3]);
265 }