www.aleph1.co.uk Git - yaffs-website/blob - node_modules/tiny-lr/node_modules/qs/test/parse.js

   1 /* eslint no-extend-native:0 */
   2 // Load modules
   3
   4 var Code = require('code');
   5 var Lab = require('lab');
   6 var Qs = require('../');
   7
   8
   9 // Declare internals
  10
  11 var internals = {};
  12
  13
  14 // Test shortcuts
  15
  16 var lab = exports.lab = Lab.script();
  17 var expect = Code.expect;
  18 var describe = lab.experiment;
  19 var it = lab.test;
  20
  21
  22 describe('parse()', function () {
  23
  24     it('parses a simple string', function (done) {
  25
  26         expect(Qs.parse('0=foo')).to.deep.equal({ '0': 'foo' });
  27         expect(Qs.parse('foo=c++')).to.deep.equal({ foo: 'c  ' });
  28         expect(Qs.parse('a[>=]=23')).to.deep.equal({ a: { '>=': '23' } });
  29         expect(Qs.parse('a[<=>]==23')).to.deep.equal({ a: { '<=>': '=23' } });
  30         expect(Qs.parse('a[==]=23')).to.deep.equal({ a: { '==': '23' } });
  31         expect(Qs.parse('foo', { strictNullHandling: true })).to.deep.equal({ foo: null });
  32         expect(Qs.parse('foo' )).to.deep.equal({ foo: '' });
  33         expect(Qs.parse('foo=')).to.deep.equal({ foo: '' });
  34         expect(Qs.parse('foo=bar')).to.deep.equal({ foo: 'bar' });
  35         expect(Qs.parse(' foo = bar = baz ')).to.deep.equal({ ' foo ': ' bar = baz ' });
  36         expect(Qs.parse('foo=bar=baz')).to.deep.equal({ foo: 'bar=baz' });
  37         expect(Qs.parse('foo=bar&bar=baz')).to.deep.equal({ foo: 'bar', bar: 'baz' });
  38         expect(Qs.parse('foo2=bar2&baz2=')).to.deep.equal({ foo2: 'bar2', baz2: '' });
  39         expect(Qs.parse('foo=bar&baz', { strictNullHandling: true })).to.deep.equal({ foo: 'bar', baz: null });
  40         expect(Qs.parse('foo=bar&baz')).to.deep.equal({ foo: 'bar', baz: '' });
  41         expect(Qs.parse('cht=p3&chd=t:60,40&chs=250x100&chl=Hello|World')).to.deep.equal({
  42             cht: 'p3',
  43             chd: 't:60,40',
  44             chs: '250x100',
  45             chl: 'Hello|World'
  46         });
  47         done();
  48     });
  49
  50     it('allows enabling dot notation', function (done) {
  51
  52         expect(Qs.parse('a.b=c')).to.deep.equal({ 'a.b': 'c' });
  53         expect(Qs.parse('a.b=c', { allowDots: true })).to.deep.equal({ a: { b: 'c' } });
  54         done();
  55     });
  56
  57     it('parses a single nested string', function (done) {
  58
  59         expect(Qs.parse('a[b]=c')).to.deep.equal({ a: { b: 'c' } });
  60         done();
  61     });
  62
  63     it('parses a double nested string', function (done) {
  64
  65         expect(Qs.parse('a[b][c]=d')).to.deep.equal({ a: { b: { c: 'd' } } });
  66         done();
  67     });
  68
  69     it('defaults to a depth of 5', function (done) {
  70
  71         expect(Qs.parse('a[b][c][d][e][f][g][h]=i')).to.deep.equal({ a: { b: { c: { d: { e: { f: { '[g][h]': 'i' } } } } } } });
  72         done();
  73     });
  74
  75     it('only parses one level when depth = 1', function (done) {
  76
  77         expect(Qs.parse('a[b][c]=d', { depth: 1 })).to.deep.equal({ a: { b: { '[c]': 'd' } } });
  78         expect(Qs.parse('a[b][c][d]=e', { depth: 1 })).to.deep.equal({ a: { b: { '[c][d]': 'e' } } });
  79         done();
  80     });
  81
  82     it('parses a simple array', function (done) {
  83
  84         expect(Qs.parse('a=b&a=c')).to.deep.equal({ a: ['b', 'c'] });
  85         done();
  86     });
  87
  88     it('parses an explicit array', function (done) {
  89
  90         expect(Qs.parse('a[]=b')).to.deep.equal({ a: ['b'] });
  91         expect(Qs.parse('a[]=b&a[]=c')).to.deep.equal({ a: ['b', 'c'] });
  92         expect(Qs.parse('a[]=b&a[]=c&a[]=d')).to.deep.equal({ a: ['b', 'c', 'd'] });
  93         done();
  94     });
  95
  96     it('parses a mix of simple and explicit arrays', function (done) {
  97
  98         expect(Qs.parse('a=b&a[]=c')).to.deep.equal({ a: ['b', 'c'] });
  99         expect(Qs.parse('a[]=b&a=c')).to.deep.equal({ a: ['b', 'c'] });
 100         expect(Qs.parse('a[0]=b&a=c')).to.deep.equal({ a: ['b', 'c'] });
 101         expect(Qs.parse('a=b&a[0]=c')).to.deep.equal({ a: ['b', 'c'] });
 102         expect(Qs.parse('a[1]=b&a=c')).to.deep.equal({ a: ['b', 'c'] });
 103         expect(Qs.parse('a=b&a[1]=c')).to.deep.equal({ a: ['b', 'c'] });
 104         done();
 105     });
 106
 107     it('parses a nested array', function (done) {
 108
 109         expect(Qs.parse('a[b][]=c&a[b][]=d')).to.deep.equal({ a: { b: ['c', 'd'] } });
 110         expect(Qs.parse('a[>=]=25')).to.deep.equal({ a: { '>=': '25' } });
 111         done();
 112     });
 113
 114     it('allows to specify array indices', function (done) {
 115
 116         expect(Qs.parse('a[1]=c&a[0]=b&a[2]=d')).to.deep.equal({ a: ['b', 'c', 'd'] });
 117         expect(Qs.parse('a[1]=c&a[0]=b')).to.deep.equal({ a: ['b', 'c'] });
 118         expect(Qs.parse('a[1]=c')).to.deep.equal({ a: ['c'] });
 119         done();
 120     });
 121
 122     it('limits specific array indices to 20', function (done) {
 123
 124         expect(Qs.parse('a[20]=a')).to.deep.equal({ a: ['a'] });
 125         expect(Qs.parse('a[21]=a')).to.deep.equal({ a: { '21': 'a' } });
 126         done();
 127     });
 128
 129     it('supports keys that begin with a number', function (done) {
 130
 131         expect(Qs.parse('a[12b]=c')).to.deep.equal({ a: { '12b': 'c' } });
 132         done();
 133     });
 134
 135     it('supports encoded = signs', function (done) {
 136
 137         expect(Qs.parse('he%3Dllo=th%3Dere')).to.deep.equal({ 'he=llo': 'th=ere' });
 138         done();
 139     });
 140
 141     it('is ok with url encoded strings', function (done) {
 142
 143         expect(Qs.parse('a[b%20c]=d')).to.deep.equal({ a: { 'b c': 'd' } });
 144         expect(Qs.parse('a[b]=c%20d')).to.deep.equal({ a: { b: 'c d' } });
 145         done();
 146     });
 147
 148     it('allows brackets in the value', function (done) {
 149
 150         expect(Qs.parse('pets=["tobi"]')).to.deep.equal({ pets: '["tobi"]' });
 151         expect(Qs.parse('operators=[">=", "<="]')).to.deep.equal({ operators: '[">=", "<="]' });
 152         done();
 153     });
 154
 155     it('allows empty values', function (done) {
 156
 157         expect(Qs.parse('')).to.deep.equal({});
 158         expect(Qs.parse(null)).to.deep.equal({});
 159         expect(Qs.parse(undefined)).to.deep.equal({});
 160         done();
 161     });
 162
 163     it('transforms arrays to objects', function (done) {
 164
 165         expect(Qs.parse('foo[0]=bar&foo[bad]=baz')).to.deep.equal({ foo: { '0': 'bar', bad: 'baz' } });
 166         expect(Qs.parse('foo[bad]=baz&foo[0]=bar')).to.deep.equal({ foo: { bad: 'baz', '0': 'bar' } });
 167         expect(Qs.parse('foo[bad]=baz&foo[]=bar')).to.deep.equal({ foo: { bad: 'baz', '0': 'bar' } });
 168         expect(Qs.parse('foo[]=bar&foo[bad]=baz')).to.deep.equal({ foo: { '0': 'bar', bad: 'baz' } });
 169         expect(Qs.parse('foo[bad]=baz&foo[]=bar&foo[]=foo')).to.deep.equal({ foo: { bad: 'baz', '0': 'bar', '1': 'foo' } });
 170         expect(Qs.parse('foo[0][a]=a&foo[0][b]=b&foo[1][a]=aa&foo[1][b]=bb')).to.deep.equal({ foo: [{ a: 'a', b: 'b' }, { a: 'aa', b: 'bb' }] });
 171         expect(Qs.parse('a[]=b&a[t]=u&a[hasOwnProperty]=c')).to.deep.equal({ a: { '0': 'b', t: 'u', c: true } });
 172         expect(Qs.parse('a[]=b&a[hasOwnProperty]=c&a[x]=y')).to.deep.equal({ a: { '0': 'b', '1': 'c', x: 'y' } });
 173         done();
 174     });
 175
 176     it('transforms arrays to objects (dot notation)', function (done) {
 177
 178         expect(Qs.parse('foo[0].baz=bar&fool.bad=baz', { allowDots: true })).to.deep.equal({ foo: [{ baz: 'bar' }], fool: { bad: 'baz' } });
 179         expect(Qs.parse('foo[0].baz=bar&fool.bad.boo=baz', { allowDots: true })).to.deep.equal({ foo: [{ baz: 'bar' }], fool: { bad: { boo: 'baz' } } });
 180         expect(Qs.parse('foo[0][0].baz=bar&fool.bad=baz', { allowDots: true })).to.deep.equal({ foo: [[{ baz: 'bar' }]], fool: { bad: 'baz' } });
 181         expect(Qs.parse('foo[0].baz[0]=15&foo[0].bar=2', { allowDots: true })).to.deep.equal({ foo: [{ baz: ['15'], bar: '2' }] });
 182         expect(Qs.parse('foo[0].baz[0]=15&foo[0].baz[1]=16&foo[0].bar=2', { allowDots: true })).to.deep.equal({ foo: [{ baz: ['15', '16'], bar: '2' }] });
 183         expect(Qs.parse('foo.bad=baz&foo[0]=bar', { allowDots: true })).to.deep.equal({ foo: { bad: 'baz', '0': 'bar' } });
 184         expect(Qs.parse('foo.bad=baz&foo[]=bar', { allowDots: true })).to.deep.equal({ foo: { bad: 'baz', '0': 'bar' } });
 185         expect(Qs.parse('foo[]=bar&foo.bad=baz', { allowDots: true })).to.deep.equal({ foo: { '0': 'bar', bad: 'baz' } });
 186         expect(Qs.parse('foo.bad=baz&foo[]=bar&foo[]=foo', { allowDots: true })).to.deep.equal({ foo: { bad: 'baz', '0': 'bar', '1': 'foo' } });
 187         expect(Qs.parse('foo[0].a=a&foo[0].b=b&foo[1].a=aa&foo[1].b=bb', { allowDots: true })).to.deep.equal({ foo: [{ a: 'a', b: 'b' }, { a: 'aa', b: 'bb' }] });
 188         done();
 189     });
 190
 191     it('can add keys to objects', function (done) {
 192
 193         expect(Qs.parse('a[b]=c&a=d')).to.deep.equal({ a: { b: 'c', d: true } });
 194         done();
 195     });
 196
 197     it('correctly prunes undefined values when converting an array to an object', function (done) {
 198
 199         expect(Qs.parse('a[2]=b&a[99999999]=c')).to.deep.equal({ a: { '2': 'b', '99999999': 'c' } });
 200         done();
 201     });
 202
 203     it('supports malformed uri characters', function (done) {
 204
 205         expect(Qs.parse('{%:%}', { strictNullHandling: true })).to.deep.equal({ '{%:%}': null });
 206         expect(Qs.parse('{%:%}=')).to.deep.equal({ '{%:%}': '' });
 207         expect(Qs.parse('foo=%:%}')).to.deep.equal({ foo: '%:%}' });
 208         done();
 209     });
 210
 211     it('doesn\'t produce empty keys', function (done) {
 212
 213         expect(Qs.parse('_r=1&')).to.deep.equal({ '_r': '1' });
 214         done();
 215     });
 216
 217     it('cannot access Object prototype', function (done) {
 218
 219         Qs.parse('constructor[prototype][bad]=bad');
 220         Qs.parse('bad[constructor][prototype][bad]=bad');
 221         expect(typeof Object.prototype.bad).to.equal('undefined');
 222         done();
 223     });
 224
 225     it('parses arrays of objects', function (done) {
 226
 227         expect(Qs.parse('a[][b]=c')).to.deep.equal({ a: [{ b: 'c' }] });
 228         expect(Qs.parse('a[0][b]=c')).to.deep.equal({ a: [{ b: 'c' }] });
 229         done();
 230     });
 231
 232     it('allows for empty strings in arrays', function (done) {
 233
 234         expect(Qs.parse('a[]=b&a[]=&a[]=c')).to.deep.equal({ a: ['b', '', 'c'] });
 235         expect(Qs.parse('a[0]=b&a[1]&a[2]=c&a[19]=', { strictNullHandling: true })).to.deep.equal({ a: ['b', null, 'c', ''] });
 236         expect(Qs.parse('a[0]=b&a[1]=&a[2]=c&a[19]', { strictNullHandling: true })).to.deep.equal({ a: ['b', '', 'c', null] });
 237         expect(Qs.parse('a[]=&a[]=b&a[]=c')).to.deep.equal({ a: ['', 'b', 'c'] });
 238         done();
 239     });
 240
 241     it('compacts sparse arrays', function (done) {
 242
 243         expect(Qs.parse('a[10]=1&a[2]=2')).to.deep.equal({ a: ['2', '1'] });
 244         done();
 245     });
 246
 247     it('parses semi-parsed strings', function (done) {
 248
 249         expect(Qs.parse({ 'a[b]': 'c' })).to.deep.equal({ a: { b: 'c' } });
 250         expect(Qs.parse({ 'a[b]': 'c', 'a[d]': 'e' })).to.deep.equal({ a: { b: 'c', d: 'e' } });
 251         done();
 252     });
 253
 254     it('parses buffers correctly', function (done) {
 255
 256         var b = new Buffer('test');
 257         expect(Qs.parse({ a: b })).to.deep.equal({ a: b });
 258         done();
 259     });
 260
 261     it('continues parsing when no parent is found', function (done) {
 262
 263         expect(Qs.parse('[]=&a=b')).to.deep.equal({ '0': '', a: 'b' });
 264         expect(Qs.parse('[]&a=b', { strictNullHandling: true })).to.deep.equal({ '0': null, a: 'b' });
 265         expect(Qs.parse('[foo]=bar')).to.deep.equal({ foo: 'bar' });
 266         done();
 267     });
 268
 269     it('does not error when parsing a very long array', function (done) {
 270
 271         var str = 'a[]=a';
 272         while (Buffer.byteLength(str) < 128 * 1024) {
 273             str += '&' + str;
 274         }
 275
 276         expect(function () {
 277
 278             Qs.parse(str);
 279         }).to.not.throw();
 280
 281         done();
 282     });
 283
 284     it('should not throw when a native prototype has an enumerable property', { parallel: false }, function (done) {
 285
 286         Object.prototype.crash = '';
 287         Array.prototype.crash = '';
 288         expect(Qs.parse.bind(null, 'a=b')).to.not.throw();
 289         expect(Qs.parse('a=b')).to.deep.equal({ a: 'b' });
 290         expect(Qs.parse.bind(null, 'a[][b]=c')).to.not.throw();
 291         expect(Qs.parse('a[][b]=c')).to.deep.equal({ a: [{ b: 'c' }] });
 292         delete Object.prototype.crash;
 293         delete Array.prototype.crash;
 294         done();
 295     });
 296
 297     it('parses a string with an alternative string delimiter', function (done) {
 298
 299         expect(Qs.parse('a=b;c=d', { delimiter: ';' })).to.deep.equal({ a: 'b', c: 'd' });
 300         done();
 301     });
 302
 303     it('parses a string with an alternative RegExp delimiter', function (done) {
 304
 305         expect(Qs.parse('a=b; c=d', { delimiter: /[;,] */ })).to.deep.equal({ a: 'b', c: 'd' });
 306         done();
 307     });
 308
 309     it('does not use non-splittable objects as delimiters', function (done) {
 310
 311         expect(Qs.parse('a=b&c=d', { delimiter: true })).to.deep.equal({ a: 'b', c: 'd' });
 312         done();
 313     });
 314
 315     it('allows overriding parameter limit', function (done) {
 316
 317         expect(Qs.parse('a=b&c=d', { parameterLimit: 1 })).to.deep.equal({ a: 'b' });
 318         done();
 319     });
 320
 321     it('allows setting the parameter limit to Infinity', function (done) {
 322
 323         expect(Qs.parse('a=b&c=d', { parameterLimit: Infinity })).to.deep.equal({ a: 'b', c: 'd' });
 324         done();
 325     });
 326
 327     it('allows overriding array limit', function (done) {
 328
 329         expect(Qs.parse('a[0]=b', { arrayLimit: -1 })).to.deep.equal({ a: { '0': 'b' } });
 330         expect(Qs.parse('a[-1]=b', { arrayLimit: -1 })).to.deep.equal({ a: { '-1': 'b' } });
 331         expect(Qs.parse('a[0]=b&a[1]=c', { arrayLimit: 0 })).to.deep.equal({ a: { '0': 'b', '1': 'c' } });
 332         done();
 333     });
 334
 335     it('allows disabling array parsing', function (done) {
 336
 337         expect(Qs.parse('a[0]=b&a[1]=c', { parseArrays: false })).to.deep.equal({ a: { '0': 'b', '1': 'c' } });
 338         done();
 339     });
 340
 341     it('parses an object', function (done) {
 342
 343         var input = {
 344             'user[name]': { 'pop[bob]': 3 },
 345             'user[email]': null
 346         };
 347
 348         var expected = {
 349             'user': {
 350                 'name': { 'pop[bob]': 3 },
 351                 'email': null
 352             }
 353         };
 354
 355         var result = Qs.parse(input);
 356
 357         expect(result).to.deep.equal(expected);
 358         done();
 359     });
 360
 361     it('parses an object in dot notation', function (done) {
 362
 363         var input = {
 364             'user.name': { 'pop[bob]': 3 },
 365             'user.email.': null
 366         };
 367
 368         var expected = {
 369             'user': {
 370                 'name': { 'pop[bob]': 3 },
 371                 'email': null
 372             }
 373         };
 374
 375         var result = Qs.parse(input, { allowDots: true });
 376
 377         expect(result).to.deep.equal(expected);
 378         done();
 379     });
 380
 381     it('parses an object and not child values', function (done) {
 382
 383         var input = {
 384             'user[name]': { 'pop[bob]': { 'test': 3 } },
 385             'user[email]': null
 386         };
 387
 388         var expected = {
 389             'user': {
 390                 'name': { 'pop[bob]': { 'test': 3 } },
 391                 'email': null
 392             }
 393         };
 394
 395         var result = Qs.parse(input);
 396
 397         expect(result).to.deep.equal(expected);
 398         done();
 399     });
 400
 401     it('does not blow up when Buffer global is missing', function (done) {
 402
 403         var tempBuffer = global.Buffer;
 404         delete global.Buffer;
 405         var result = Qs.parse('a=b&c=d');
 406         global.Buffer = tempBuffer;
 407         expect(result).to.deep.equal({ a: 'b', c: 'd' });
 408         done();
 409     });
 410
 411     it('does not crash when parsing circular references', function (done) {
 412
 413         var a = {};
 414         a.b = a;
 415
 416         var parsed;
 417
 418         expect(function () {
 419
 420             parsed = Qs.parse({ 'foo[bar]': 'baz', 'foo[baz]': a });
 421         }).to.not.throw();
 422
 423         expect(parsed).to.contain('foo');
 424         expect(parsed.foo).to.contain('bar', 'baz');
 425         expect(parsed.foo.bar).to.equal('baz');
 426         expect(parsed.foo.baz).to.deep.equal(a);
 427         done();
 428     });
 429
 430     it('parses plain objects correctly', function (done) {
 431
 432         var a = Object.create(null);
 433         a.b = 'c';
 434
 435         expect(Qs.parse(a)).to.deep.equal({ b: 'c' });
 436         var result = Qs.parse({ a: a });
 437         expect(result).to.contain('a');
 438         expect(result.a).to.deep.equal(a);
 439         done();
 440     });
 441
 442     it('parses dates correctly', function (done) {
 443
 444         var now = new Date();
 445         expect(Qs.parse({ a: now })).to.deep.equal({ a: now });
 446         done();
 447     });
 448
 449     it('parses regular expressions correctly', function (done) {
 450
 451         var re = /^test$/;
 452         expect(Qs.parse({ a: re })).to.deep.equal({ a: re });
 453         done();
 454     });
 455
 456     it('can allow overwriting prototype properties', function (done) {
 457
 458         expect(Qs.parse('a[hasOwnProperty]=b', { allowPrototypes: true })).to.deep.equal({ a: { hasOwnProperty: 'b' } }, { prototype: false });
 459         expect(Qs.parse('hasOwnProperty=b', { allowPrototypes: true })).to.deep.equal({ hasOwnProperty: 'b' }, { prototype: false });
 460         done();
 461     });
 462
 463     it('can return plain objects', function (done) {
 464
 465         var expected = Object.create(null);
 466         expected.a = Object.create(null);
 467         expected.a.b = 'c';
 468         expected.a.hasOwnProperty = 'd';
 469         expect(Qs.parse('a[b]=c&a[hasOwnProperty]=d', { plainObjects: true })).to.deep.equal(expected);
 470         expect(Qs.parse(null, { plainObjects: true })).to.deep.equal(Object.create(null));
 471         var expectedArray = Object.create(null);
 472         expectedArray.a = Object.create(null);
 473         expectedArray.a['0'] = 'b';
 474         expectedArray.a.c = 'd';
 475         expect(Qs.parse('a[]=b&a[c]=d', { plainObjects: true })).to.deep.equal(expectedArray);
 476         done();
 477     });
 478 });