| [d24f17c] | 1 | 'use strict';
|
|---|
| 2 |
|
|---|
| 3 | var test = require('tape');
|
|---|
| 4 | var qs = require('../');
|
|---|
| 5 | var utils = require('../lib/utils');
|
|---|
| 6 | var iconv = require('iconv-lite');
|
|---|
| 7 | var SaferBuffer = require('safer-buffer').Buffer;
|
|---|
| 8 | var hasSymbols = require('has-symbols');
|
|---|
| 9 | var hasBigInt = typeof BigInt === 'function';
|
|---|
| 10 |
|
|---|
| 11 | test('stringify()', function (t) {
|
|---|
| 12 | t.test('stringifies a querystring object', function (st) {
|
|---|
| 13 | st.equal(qs.stringify({ a: 'b' }), 'a=b');
|
|---|
| 14 | st.equal(qs.stringify({ a: 1 }), 'a=1');
|
|---|
| 15 | st.equal(qs.stringify({ a: 1, b: 2 }), 'a=1&b=2');
|
|---|
| 16 | st.equal(qs.stringify({ a: 'A_Z' }), 'a=A_Z');
|
|---|
| 17 | st.equal(qs.stringify({ a: '€' }), 'a=%E2%82%AC');
|
|---|
| 18 | st.equal(qs.stringify({ a: '' }), 'a=%EE%80%80');
|
|---|
| 19 | st.equal(qs.stringify({ a: 'א' }), 'a=%D7%90');
|
|---|
| 20 | st.equal(qs.stringify({ a: '𐐷' }), 'a=%F0%90%90%B7');
|
|---|
| 21 | st.end();
|
|---|
| 22 | });
|
|---|
| 23 |
|
|---|
| 24 | t.test('stringifies falsy values', function (st) {
|
|---|
| 25 | st.equal(qs.stringify(undefined), '');
|
|---|
| 26 | st.equal(qs.stringify(null), '');
|
|---|
| 27 | st.equal(qs.stringify(null, { strictNullHandling: true }), '');
|
|---|
| 28 | st.equal(qs.stringify(false), '');
|
|---|
| 29 | st.equal(qs.stringify(0), '');
|
|---|
| 30 | st.end();
|
|---|
| 31 | });
|
|---|
| 32 |
|
|---|
| 33 | t.test('stringifies symbols', { skip: !hasSymbols() }, function (st) {
|
|---|
| 34 | st.equal(qs.stringify(Symbol.iterator), '');
|
|---|
| 35 | st.equal(qs.stringify([Symbol.iterator]), '0=Symbol%28Symbol.iterator%29');
|
|---|
| 36 | st.equal(qs.stringify({ a: Symbol.iterator }), 'a=Symbol%28Symbol.iterator%29');
|
|---|
| 37 | st.equal(
|
|---|
| 38 | qs.stringify({ a: [Symbol.iterator] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
|
|---|
| 39 | 'a[]=Symbol%28Symbol.iterator%29'
|
|---|
| 40 | );
|
|---|
| 41 | st.end();
|
|---|
| 42 | });
|
|---|
| 43 |
|
|---|
| 44 | t.test('stringifies bigints', { skip: !hasBigInt }, function (st) {
|
|---|
| 45 | var three = BigInt(3);
|
|---|
| 46 | var encodeWithN = function (value, defaultEncoder, charset) {
|
|---|
| 47 | var result = defaultEncoder(value, defaultEncoder, charset);
|
|---|
| 48 | return typeof value === 'bigint' ? result + 'n' : result;
|
|---|
| 49 | };
|
|---|
| 50 | st.equal(qs.stringify(three), '');
|
|---|
| 51 | st.equal(qs.stringify([three]), '0=3');
|
|---|
| 52 | st.equal(qs.stringify([three], { encoder: encodeWithN }), '0=3n');
|
|---|
| 53 | st.equal(qs.stringify({ a: three }), 'a=3');
|
|---|
| 54 | st.equal(qs.stringify({ a: three }, { encoder: encodeWithN }), 'a=3n');
|
|---|
| 55 | st.equal(
|
|---|
| 56 | qs.stringify({ a: [three] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
|
|---|
| 57 | 'a[]=3'
|
|---|
| 58 | );
|
|---|
| 59 | st.equal(
|
|---|
| 60 | qs.stringify({ a: [three] }, { encodeValuesOnly: true, encoder: encodeWithN, arrayFormat: 'brackets' }),
|
|---|
| 61 | 'a[]=3n'
|
|---|
| 62 | );
|
|---|
| 63 | st.end();
|
|---|
| 64 | });
|
|---|
| 65 |
|
|---|
| 66 | t.test('adds query prefix', function (st) {
|
|---|
| 67 | st.equal(qs.stringify({ a: 'b' }, { addQueryPrefix: true }), '?a=b');
|
|---|
| 68 | st.end();
|
|---|
| 69 | });
|
|---|
| 70 |
|
|---|
| 71 | t.test('with query prefix, outputs blank string given an empty object', function (st) {
|
|---|
| 72 | st.equal(qs.stringify({}, { addQueryPrefix: true }), '');
|
|---|
| 73 | st.end();
|
|---|
| 74 | });
|
|---|
| 75 |
|
|---|
| 76 | t.test('stringifies nested falsy values', function (st) {
|
|---|
| 77 | st.equal(qs.stringify({ a: { b: { c: null } } }), 'a%5Bb%5D%5Bc%5D=');
|
|---|
| 78 | st.equal(qs.stringify({ a: { b: { c: null } } }, { strictNullHandling: true }), 'a%5Bb%5D%5Bc%5D');
|
|---|
| 79 | st.equal(qs.stringify({ a: { b: { c: false } } }), 'a%5Bb%5D%5Bc%5D=false');
|
|---|
| 80 | st.end();
|
|---|
| 81 | });
|
|---|
| 82 |
|
|---|
| 83 | t.test('stringifies a nested object', function (st) {
|
|---|
| 84 | st.equal(qs.stringify({ a: { b: 'c' } }), 'a%5Bb%5D=c');
|
|---|
| 85 | st.equal(qs.stringify({ a: { b: { c: { d: 'e' } } } }), 'a%5Bb%5D%5Bc%5D%5Bd%5D=e');
|
|---|
| 86 | st.end();
|
|---|
| 87 | });
|
|---|
| 88 |
|
|---|
| 89 | t.test('stringifies a nested object with dots notation', function (st) {
|
|---|
| 90 | st.equal(qs.stringify({ a: { b: 'c' } }, { allowDots: true }), 'a.b=c');
|
|---|
| 91 | st.equal(qs.stringify({ a: { b: { c: { d: 'e' } } } }, { allowDots: true }), 'a.b.c.d=e');
|
|---|
| 92 | st.end();
|
|---|
| 93 | });
|
|---|
| 94 |
|
|---|
| 95 | t.test('stringifies an array value', function (st) {
|
|---|
| 96 | st.equal(
|
|---|
| 97 | qs.stringify({ a: ['b', 'c', 'd'] }, { arrayFormat: 'indices' }),
|
|---|
| 98 | 'a%5B0%5D=b&a%5B1%5D=c&a%5B2%5D=d',
|
|---|
| 99 | 'indices => indices'
|
|---|
| 100 | );
|
|---|
| 101 | st.equal(
|
|---|
| 102 | qs.stringify({ a: ['b', 'c', 'd'] }, { arrayFormat: 'brackets' }),
|
|---|
| 103 | 'a%5B%5D=b&a%5B%5D=c&a%5B%5D=d',
|
|---|
| 104 | 'brackets => brackets'
|
|---|
| 105 | );
|
|---|
| 106 | st.equal(
|
|---|
| 107 | qs.stringify({ a: ['b', 'c', 'd'] }, { arrayFormat: 'comma' }),
|
|---|
| 108 | 'a=b%2Cc%2Cd',
|
|---|
| 109 | 'comma => comma'
|
|---|
| 110 | );
|
|---|
| 111 | st.equal(
|
|---|
| 112 | qs.stringify({ a: ['b', 'c', 'd'] }),
|
|---|
| 113 | 'a%5B0%5D=b&a%5B1%5D=c&a%5B2%5D=d',
|
|---|
| 114 | 'default => indices'
|
|---|
| 115 | );
|
|---|
| 116 | st.end();
|
|---|
| 117 | });
|
|---|
| 118 |
|
|---|
| 119 | t.test('omits nulls when asked', function (st) {
|
|---|
| 120 | st.equal(qs.stringify({ a: 'b', c: null }, { skipNulls: true }), 'a=b');
|
|---|
| 121 | st.end();
|
|---|
| 122 | });
|
|---|
| 123 |
|
|---|
| 124 | t.test('omits nested nulls when asked', function (st) {
|
|---|
| 125 | st.equal(qs.stringify({ a: { b: 'c', d: null } }, { skipNulls: true }), 'a%5Bb%5D=c');
|
|---|
| 126 | st.end();
|
|---|
| 127 | });
|
|---|
| 128 |
|
|---|
| 129 | t.test('omits array indices when asked', function (st) {
|
|---|
| 130 | st.equal(qs.stringify({ a: ['b', 'c', 'd'] }, { indices: false }), 'a=b&a=c&a=d');
|
|---|
| 131 | st.end();
|
|---|
| 132 | });
|
|---|
| 133 |
|
|---|
| 134 | t.test('stringifies an array value with one item vs multiple items', function (st) {
|
|---|
| 135 | st.test('non-array item', function (s2t) {
|
|---|
| 136 | s2t.equal(qs.stringify({ a: 'c' }, { encodeValuesOnly: true, arrayFormat: 'indices' }), 'a=c');
|
|---|
| 137 | s2t.equal(qs.stringify({ a: 'c' }, { encodeValuesOnly: true, arrayFormat: 'brackets' }), 'a=c');
|
|---|
| 138 | s2t.equal(qs.stringify({ a: 'c' }, { encodeValuesOnly: true, arrayFormat: 'comma' }), 'a=c');
|
|---|
| 139 | s2t.equal(qs.stringify({ a: 'c' }, { encodeValuesOnly: true }), 'a=c');
|
|---|
| 140 |
|
|---|
| 141 | s2t.end();
|
|---|
| 142 | });
|
|---|
| 143 |
|
|---|
| 144 | st.test('array with a single item', function (s2t) {
|
|---|
| 145 | s2t.equal(qs.stringify({ a: ['c'] }, { encodeValuesOnly: true, arrayFormat: 'indices' }), 'a[0]=c');
|
|---|
| 146 | s2t.equal(qs.stringify({ a: ['c'] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }), 'a[]=c');
|
|---|
| 147 | s2t.equal(qs.stringify({ a: ['c'] }, { encodeValuesOnly: true, arrayFormat: 'comma' }), 'a=c');
|
|---|
| 148 | s2t.equal(qs.stringify({ a: ['c'] }, { encodeValuesOnly: true, arrayFormat: 'comma', commaRoundTrip: true }), 'a[]=c'); // so it parses back as an array
|
|---|
| 149 | s2t.equal(qs.stringify({ a: ['c'] }, { encodeValuesOnly: true }), 'a[0]=c');
|
|---|
| 150 |
|
|---|
| 151 | s2t.end();
|
|---|
| 152 | });
|
|---|
| 153 |
|
|---|
| 154 | st.test('array with multiple items', function (s2t) {
|
|---|
| 155 | s2t.equal(qs.stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true, arrayFormat: 'indices' }), 'a[0]=c&a[1]=d');
|
|---|
| 156 | s2t.equal(qs.stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }), 'a[]=c&a[]=d');
|
|---|
| 157 | s2t.equal(qs.stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true, arrayFormat: 'comma' }), 'a=c,d');
|
|---|
| 158 | s2t.equal(qs.stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true }), 'a[0]=c&a[1]=d');
|
|---|
| 159 |
|
|---|
| 160 | s2t.end();
|
|---|
| 161 | });
|
|---|
| 162 |
|
|---|
| 163 | st.end();
|
|---|
| 164 | });
|
|---|
| 165 |
|
|---|
| 166 | t.test('stringifies a nested array value', function (st) {
|
|---|
| 167 | st.equal(qs.stringify({ a: { b: ['c', 'd'] } }, { encodeValuesOnly: true, arrayFormat: 'indices' }), 'a[b][0]=c&a[b][1]=d');
|
|---|
| 168 | st.equal(qs.stringify({ a: { b: ['c', 'd'] } }, { encodeValuesOnly: true, arrayFormat: 'brackets' }), 'a[b][]=c&a[b][]=d');
|
|---|
| 169 | st.equal(qs.stringify({ a: { b: ['c', 'd'] } }, { encodeValuesOnly: true, arrayFormat: 'comma' }), 'a[b]=c,d');
|
|---|
| 170 | st.equal(qs.stringify({ a: { b: ['c', 'd'] } }, { encodeValuesOnly: true }), 'a[b][0]=c&a[b][1]=d');
|
|---|
| 171 | st.end();
|
|---|
| 172 | });
|
|---|
| 173 |
|
|---|
| 174 | t.test('stringifies a nested array value with dots notation', function (st) {
|
|---|
| 175 | st.equal(
|
|---|
| 176 | qs.stringify(
|
|---|
| 177 | { a: { b: ['c', 'd'] } },
|
|---|
| 178 | { allowDots: true, encodeValuesOnly: true, arrayFormat: 'indices' }
|
|---|
| 179 | ),
|
|---|
| 180 | 'a.b[0]=c&a.b[1]=d',
|
|---|
| 181 | 'indices: stringifies with dots + indices'
|
|---|
| 182 | );
|
|---|
| 183 | st.equal(
|
|---|
| 184 | qs.stringify(
|
|---|
| 185 | { a: { b: ['c', 'd'] } },
|
|---|
| 186 | { allowDots: true, encodeValuesOnly: true, arrayFormat: 'brackets' }
|
|---|
| 187 | ),
|
|---|
| 188 | 'a.b[]=c&a.b[]=d',
|
|---|
| 189 | 'brackets: stringifies with dots + brackets'
|
|---|
| 190 | );
|
|---|
| 191 | st.equal(
|
|---|
| 192 | qs.stringify(
|
|---|
| 193 | { a: { b: ['c', 'd'] } },
|
|---|
| 194 | { allowDots: true, encodeValuesOnly: true, arrayFormat: 'comma' }
|
|---|
| 195 | ),
|
|---|
| 196 | 'a.b=c,d',
|
|---|
| 197 | 'comma: stringifies with dots + comma'
|
|---|
| 198 | );
|
|---|
| 199 | st.equal(
|
|---|
| 200 | qs.stringify(
|
|---|
| 201 | { a: { b: ['c', 'd'] } },
|
|---|
| 202 | { allowDots: true, encodeValuesOnly: true }
|
|---|
| 203 | ),
|
|---|
| 204 | 'a.b[0]=c&a.b[1]=d',
|
|---|
| 205 | 'default: stringifies with dots + indices'
|
|---|
| 206 | );
|
|---|
| 207 | st.end();
|
|---|
| 208 | });
|
|---|
| 209 |
|
|---|
| 210 | t.test('stringifies an object inside an array', function (st) {
|
|---|
| 211 | st.equal(
|
|---|
| 212 | qs.stringify({ a: [{ b: 'c' }] }, { arrayFormat: 'indices' }),
|
|---|
| 213 | 'a%5B0%5D%5Bb%5D=c', // a[0][b]=c
|
|---|
| 214 | 'indices => brackets'
|
|---|
| 215 | );
|
|---|
| 216 | st.equal(
|
|---|
| 217 | qs.stringify({ a: [{ b: 'c' }] }, { arrayFormat: 'brackets' }),
|
|---|
| 218 | 'a%5B%5D%5Bb%5D=c', // a[][b]=c
|
|---|
| 219 | 'brackets => brackets'
|
|---|
| 220 | );
|
|---|
| 221 | st.equal(
|
|---|
| 222 | qs.stringify({ a: [{ b: 'c' }] }),
|
|---|
| 223 | 'a%5B0%5D%5Bb%5D=c',
|
|---|
| 224 | 'default => indices'
|
|---|
| 225 | );
|
|---|
| 226 |
|
|---|
| 227 | st.equal(
|
|---|
| 228 | qs.stringify({ a: [{ b: { c: [1] } }] }, { arrayFormat: 'indices' }),
|
|---|
| 229 | 'a%5B0%5D%5Bb%5D%5Bc%5D%5B0%5D=1',
|
|---|
| 230 | 'indices => indices'
|
|---|
| 231 | );
|
|---|
| 232 |
|
|---|
| 233 | st.equal(
|
|---|
| 234 | qs.stringify({ a: [{ b: { c: [1] } }] }, { arrayFormat: 'brackets' }),
|
|---|
| 235 | 'a%5B%5D%5Bb%5D%5Bc%5D%5B%5D=1',
|
|---|
| 236 | 'brackets => brackets'
|
|---|
| 237 | );
|
|---|
| 238 |
|
|---|
| 239 | st.equal(
|
|---|
| 240 | qs.stringify({ a: [{ b: { c: [1] } }] }),
|
|---|
| 241 | 'a%5B0%5D%5Bb%5D%5Bc%5D%5B0%5D=1',
|
|---|
| 242 | 'default => indices'
|
|---|
| 243 | );
|
|---|
| 244 |
|
|---|
| 245 | st.end();
|
|---|
| 246 | });
|
|---|
| 247 |
|
|---|
| 248 | t.test('stringifies an array with mixed objects and primitives', function (st) {
|
|---|
| 249 | st.equal(
|
|---|
| 250 | qs.stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true, arrayFormat: 'indices' }),
|
|---|
| 251 | 'a[0][b]=1&a[1]=2&a[2]=3',
|
|---|
| 252 | 'indices => indices'
|
|---|
| 253 | );
|
|---|
| 254 | st.equal(
|
|---|
| 255 | qs.stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
|
|---|
| 256 | 'a[][b]=1&a[]=2&a[]=3',
|
|---|
| 257 | 'brackets => brackets'
|
|---|
| 258 | );
|
|---|
| 259 | st.equal(
|
|---|
| 260 | qs.stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true, arrayFormat: 'comma' }),
|
|---|
| 261 | '???',
|
|---|
| 262 | 'brackets => brackets',
|
|---|
| 263 | { skip: 'TODO: figure out what this should do' }
|
|---|
| 264 | );
|
|---|
| 265 | st.equal(
|
|---|
| 266 | qs.stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true }),
|
|---|
| 267 | 'a[0][b]=1&a[1]=2&a[2]=3',
|
|---|
| 268 | 'default => indices'
|
|---|
| 269 | );
|
|---|
| 270 |
|
|---|
| 271 | st.end();
|
|---|
| 272 | });
|
|---|
| 273 |
|
|---|
| 274 | t.test('stringifies an object inside an array with dots notation', function (st) {
|
|---|
| 275 | st.equal(
|
|---|
| 276 | qs.stringify(
|
|---|
| 277 | { a: [{ b: 'c' }] },
|
|---|
| 278 | { allowDots: true, encode: false, arrayFormat: 'indices' }
|
|---|
| 279 | ),
|
|---|
| 280 | 'a[0].b=c',
|
|---|
| 281 | 'indices => indices'
|
|---|
| 282 | );
|
|---|
| 283 | st.equal(
|
|---|
| 284 | qs.stringify(
|
|---|
| 285 | { a: [{ b: 'c' }] },
|
|---|
| 286 | { allowDots: true, encode: false, arrayFormat: 'brackets' }
|
|---|
| 287 | ),
|
|---|
| 288 | 'a[].b=c',
|
|---|
| 289 | 'brackets => brackets'
|
|---|
| 290 | );
|
|---|
| 291 | st.equal(
|
|---|
| 292 | qs.stringify(
|
|---|
| 293 | { a: [{ b: 'c' }] },
|
|---|
| 294 | { allowDots: true, encode: false }
|
|---|
| 295 | ),
|
|---|
| 296 | 'a[0].b=c',
|
|---|
| 297 | 'default => indices'
|
|---|
| 298 | );
|
|---|
| 299 |
|
|---|
| 300 | st.equal(
|
|---|
| 301 | qs.stringify(
|
|---|
| 302 | { a: [{ b: { c: [1] } }] },
|
|---|
| 303 | { allowDots: true, encode: false, arrayFormat: 'indices' }
|
|---|
| 304 | ),
|
|---|
| 305 | 'a[0].b.c[0]=1',
|
|---|
| 306 | 'indices => indices'
|
|---|
| 307 | );
|
|---|
| 308 | st.equal(
|
|---|
| 309 | qs.stringify(
|
|---|
| 310 | { a: [{ b: { c: [1] } }] },
|
|---|
| 311 | { allowDots: true, encode: false, arrayFormat: 'brackets' }
|
|---|
| 312 | ),
|
|---|
| 313 | 'a[].b.c[]=1',
|
|---|
| 314 | 'brackets => brackets'
|
|---|
| 315 | );
|
|---|
| 316 | st.equal(
|
|---|
| 317 | qs.stringify(
|
|---|
| 318 | { a: [{ b: { c: [1] } }] },
|
|---|
| 319 | { allowDots: true, encode: false }
|
|---|
| 320 | ),
|
|---|
| 321 | 'a[0].b.c[0]=1',
|
|---|
| 322 | 'default => indices'
|
|---|
| 323 | );
|
|---|
| 324 |
|
|---|
| 325 | st.end();
|
|---|
| 326 | });
|
|---|
| 327 |
|
|---|
| 328 | t.test('does not omit object keys when indices = false', function (st) {
|
|---|
| 329 | st.equal(qs.stringify({ a: [{ b: 'c' }] }, { indices: false }), 'a%5Bb%5D=c');
|
|---|
| 330 | st.end();
|
|---|
| 331 | });
|
|---|
| 332 |
|
|---|
| 333 | t.test('uses indices notation for arrays when indices=true', function (st) {
|
|---|
| 334 | st.equal(qs.stringify({ a: ['b', 'c'] }, { indices: true }), 'a%5B0%5D=b&a%5B1%5D=c');
|
|---|
| 335 | st.end();
|
|---|
| 336 | });
|
|---|
| 337 |
|
|---|
| 338 | t.test('uses indices notation for arrays when no arrayFormat is specified', function (st) {
|
|---|
| 339 | st.equal(qs.stringify({ a: ['b', 'c'] }), 'a%5B0%5D=b&a%5B1%5D=c');
|
|---|
| 340 | st.end();
|
|---|
| 341 | });
|
|---|
| 342 |
|
|---|
| 343 | t.test('uses indices notation for arrays when no arrayFormat=indices', function (st) {
|
|---|
| 344 | st.equal(qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'indices' }), 'a%5B0%5D=b&a%5B1%5D=c');
|
|---|
| 345 | st.end();
|
|---|
| 346 | });
|
|---|
| 347 |
|
|---|
| 348 | t.test('uses repeat notation for arrays when no arrayFormat=repeat', function (st) {
|
|---|
| 349 | st.equal(qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'repeat' }), 'a=b&a=c');
|
|---|
| 350 | st.end();
|
|---|
| 351 | });
|
|---|
| 352 |
|
|---|
| 353 | t.test('uses brackets notation for arrays when no arrayFormat=brackets', function (st) {
|
|---|
| 354 | st.equal(qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'brackets' }), 'a%5B%5D=b&a%5B%5D=c');
|
|---|
| 355 | st.end();
|
|---|
| 356 | });
|
|---|
| 357 |
|
|---|
| 358 | t.test('stringifies a complicated object', function (st) {
|
|---|
| 359 | st.equal(qs.stringify({ a: { b: 'c', d: 'e' } }), 'a%5Bb%5D=c&a%5Bd%5D=e');
|
|---|
| 360 | st.end();
|
|---|
| 361 | });
|
|---|
| 362 |
|
|---|
| 363 | t.test('stringifies an empty value', function (st) {
|
|---|
| 364 | st.equal(qs.stringify({ a: '' }), 'a=');
|
|---|
| 365 | st.equal(qs.stringify({ a: null }, { strictNullHandling: true }), 'a');
|
|---|
| 366 |
|
|---|
| 367 | st.equal(qs.stringify({ a: '', b: '' }), 'a=&b=');
|
|---|
| 368 | st.equal(qs.stringify({ a: null, b: '' }, { strictNullHandling: true }), 'a&b=');
|
|---|
| 369 |
|
|---|
| 370 | st.equal(qs.stringify({ a: { b: '' } }), 'a%5Bb%5D=');
|
|---|
| 371 | st.equal(qs.stringify({ a: { b: null } }, { strictNullHandling: true }), 'a%5Bb%5D');
|
|---|
| 372 | st.equal(qs.stringify({ a: { b: null } }, { strictNullHandling: false }), 'a%5Bb%5D=');
|
|---|
| 373 |
|
|---|
| 374 | st.end();
|
|---|
| 375 | });
|
|---|
| 376 |
|
|---|
| 377 | t.test('stringifies an empty array in different arrayFormat', function (st) {
|
|---|
| 378 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false }), 'b[0]=&c=c');
|
|---|
| 379 | // arrayFormat default
|
|---|
| 380 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'indices' }), 'b[0]=&c=c');
|
|---|
| 381 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'brackets' }), 'b[]=&c=c');
|
|---|
| 382 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'repeat' }), 'b=&c=c');
|
|---|
| 383 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'comma' }), 'b=&c=c');
|
|---|
| 384 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'comma', commaRoundTrip: true }), 'b[]=&c=c');
|
|---|
| 385 | // with strictNullHandling
|
|---|
| 386 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'indices', strictNullHandling: true }), 'b[0]&c=c');
|
|---|
| 387 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'brackets', strictNullHandling: true }), 'b[]&c=c');
|
|---|
| 388 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'repeat', strictNullHandling: true }), 'b&c=c');
|
|---|
| 389 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'comma', strictNullHandling: true }), 'b&c=c');
|
|---|
| 390 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'comma', strictNullHandling: true, commaRoundTrip: true }), 'b[]&c=c');
|
|---|
| 391 | // with skipNulls
|
|---|
| 392 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'indices', skipNulls: true }), 'c=c');
|
|---|
| 393 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'brackets', skipNulls: true }), 'c=c');
|
|---|
| 394 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'repeat', skipNulls: true }), 'c=c');
|
|---|
| 395 | st.equal(qs.stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'comma', skipNulls: true }), 'c=c');
|
|---|
| 396 |
|
|---|
| 397 | st.end();
|
|---|
| 398 | });
|
|---|
| 399 |
|
|---|
| 400 | t.test('stringifies a null object', { skip: !Object.create }, function (st) {
|
|---|
| 401 | var obj = Object.create(null);
|
|---|
| 402 | obj.a = 'b';
|
|---|
| 403 | st.equal(qs.stringify(obj), 'a=b');
|
|---|
| 404 | st.end();
|
|---|
| 405 | });
|
|---|
| 406 |
|
|---|
| 407 | t.test('returns an empty string for invalid input', function (st) {
|
|---|
| 408 | st.equal(qs.stringify(undefined), '');
|
|---|
| 409 | st.equal(qs.stringify(false), '');
|
|---|
| 410 | st.equal(qs.stringify(null), '');
|
|---|
| 411 | st.equal(qs.stringify(''), '');
|
|---|
| 412 | st.end();
|
|---|
| 413 | });
|
|---|
| 414 |
|
|---|
| 415 | t.test('stringifies an object with a null object as a child', { skip: !Object.create }, function (st) {
|
|---|
| 416 | var obj = { a: Object.create(null) };
|
|---|
| 417 |
|
|---|
| 418 | obj.a.b = 'c';
|
|---|
| 419 | st.equal(qs.stringify(obj), 'a%5Bb%5D=c');
|
|---|
| 420 | st.end();
|
|---|
| 421 | });
|
|---|
| 422 |
|
|---|
| 423 | t.test('drops keys with a value of undefined', function (st) {
|
|---|
| 424 | st.equal(qs.stringify({ a: undefined }), '');
|
|---|
| 425 |
|
|---|
| 426 | st.equal(qs.stringify({ a: { b: undefined, c: null } }, { strictNullHandling: true }), 'a%5Bc%5D');
|
|---|
| 427 | st.equal(qs.stringify({ a: { b: undefined, c: null } }, { strictNullHandling: false }), 'a%5Bc%5D=');
|
|---|
| 428 | st.equal(qs.stringify({ a: { b: undefined, c: '' } }), 'a%5Bc%5D=');
|
|---|
| 429 | st.end();
|
|---|
| 430 | });
|
|---|
| 431 |
|
|---|
| 432 | t.test('url encodes values', function (st) {
|
|---|
| 433 | st.equal(qs.stringify({ a: 'b c' }), 'a=b%20c');
|
|---|
| 434 | st.end();
|
|---|
| 435 | });
|
|---|
| 436 |
|
|---|
| 437 | t.test('stringifies a date', function (st) {
|
|---|
| 438 | var now = new Date();
|
|---|
| 439 | var str = 'a=' + encodeURIComponent(now.toISOString());
|
|---|
| 440 | st.equal(qs.stringify({ a: now }), str);
|
|---|
| 441 | st.end();
|
|---|
| 442 | });
|
|---|
| 443 |
|
|---|
| 444 | t.test('stringifies the weird object from qs', function (st) {
|
|---|
| 445 | st.equal(qs.stringify({ 'my weird field': '~q1!2"\'w$5&7/z8)?' }), 'my%20weird%20field=~q1%212%22%27w%245%267%2Fz8%29%3F');
|
|---|
| 446 | st.end();
|
|---|
| 447 | });
|
|---|
| 448 |
|
|---|
| 449 | t.test('skips properties that are part of the object prototype', function (st) {
|
|---|
| 450 | Object.prototype.crash = 'test';
|
|---|
| 451 | st.equal(qs.stringify({ a: 'b' }), 'a=b');
|
|---|
| 452 | st.equal(qs.stringify({ a: { b: 'c' } }), 'a%5Bb%5D=c');
|
|---|
| 453 | delete Object.prototype.crash;
|
|---|
| 454 | st.end();
|
|---|
| 455 | });
|
|---|
| 456 |
|
|---|
| 457 | t.test('stringifies boolean values', function (st) {
|
|---|
| 458 | st.equal(qs.stringify({ a: true }), 'a=true');
|
|---|
| 459 | st.equal(qs.stringify({ a: { b: true } }), 'a%5Bb%5D=true');
|
|---|
| 460 | st.equal(qs.stringify({ b: false }), 'b=false');
|
|---|
| 461 | st.equal(qs.stringify({ b: { c: false } }), 'b%5Bc%5D=false');
|
|---|
| 462 | st.end();
|
|---|
| 463 | });
|
|---|
| 464 |
|
|---|
| 465 | t.test('stringifies buffer values', function (st) {
|
|---|
| 466 | st.equal(qs.stringify({ a: SaferBuffer.from('test') }), 'a=test');
|
|---|
| 467 | st.equal(qs.stringify({ a: { b: SaferBuffer.from('test') } }), 'a%5Bb%5D=test');
|
|---|
| 468 | st.end();
|
|---|
| 469 | });
|
|---|
| 470 |
|
|---|
| 471 | t.test('stringifies an object using an alternative delimiter', function (st) {
|
|---|
| 472 | st.equal(qs.stringify({ a: 'b', c: 'd' }, { delimiter: ';' }), 'a=b;c=d');
|
|---|
| 473 | st.end();
|
|---|
| 474 | });
|
|---|
| 475 |
|
|---|
| 476 | t.test('does not blow up when Buffer global is missing', function (st) {
|
|---|
| 477 | var tempBuffer = global.Buffer;
|
|---|
| 478 | delete global.Buffer;
|
|---|
| 479 | var result = qs.stringify({ a: 'b', c: 'd' });
|
|---|
| 480 | global.Buffer = tempBuffer;
|
|---|
| 481 | st.equal(result, 'a=b&c=d');
|
|---|
| 482 | st.end();
|
|---|
| 483 | });
|
|---|
| 484 |
|
|---|
| 485 | t.test('does not crash when parsing circular references', function (st) {
|
|---|
| 486 | var a = {};
|
|---|
| 487 | a.b = a;
|
|---|
| 488 |
|
|---|
| 489 | st['throws'](
|
|---|
| 490 | function () { qs.stringify({ 'foo[bar]': 'baz', 'foo[baz]': a }); },
|
|---|
| 491 | /RangeError: Cyclic object value/,
|
|---|
| 492 | 'cyclic values throw'
|
|---|
| 493 | );
|
|---|
| 494 |
|
|---|
| 495 | var circular = {
|
|---|
| 496 | a: 'value'
|
|---|
| 497 | };
|
|---|
| 498 | circular.a = circular;
|
|---|
| 499 | st['throws'](
|
|---|
| 500 | function () { qs.stringify(circular); },
|
|---|
| 501 | /RangeError: Cyclic object value/,
|
|---|
| 502 | 'cyclic values throw'
|
|---|
| 503 | );
|
|---|
| 504 |
|
|---|
| 505 | var arr = ['a'];
|
|---|
| 506 | st.doesNotThrow(
|
|---|
| 507 | function () { qs.stringify({ x: arr, y: arr }); },
|
|---|
| 508 | 'non-cyclic values do not throw'
|
|---|
| 509 | );
|
|---|
| 510 |
|
|---|
| 511 | st.end();
|
|---|
| 512 | });
|
|---|
| 513 |
|
|---|
| 514 | t.test('non-circular duplicated references can still work', function (st) {
|
|---|
| 515 | var hourOfDay = {
|
|---|
| 516 | 'function': 'hour_of_day'
|
|---|
| 517 | };
|
|---|
| 518 |
|
|---|
| 519 | var p1 = {
|
|---|
| 520 | 'function': 'gte',
|
|---|
| 521 | arguments: [hourOfDay, 0]
|
|---|
| 522 | };
|
|---|
| 523 | var p2 = {
|
|---|
| 524 | 'function': 'lte',
|
|---|
| 525 | arguments: [hourOfDay, 23]
|
|---|
| 526 | };
|
|---|
| 527 |
|
|---|
| 528 | st.equal(
|
|---|
| 529 | qs.stringify({ filters: { $and: [p1, p2] } }, { encodeValuesOnly: true }),
|
|---|
| 530 | 'filters[$and][0][function]=gte&filters[$and][0][arguments][0][function]=hour_of_day&filters[$and][0][arguments][1]=0&filters[$and][1][function]=lte&filters[$and][1][arguments][0][function]=hour_of_day&filters[$and][1][arguments][1]=23'
|
|---|
| 531 | );
|
|---|
| 532 |
|
|---|
| 533 | st.end();
|
|---|
| 534 | });
|
|---|
| 535 |
|
|---|
| 536 | t.test('selects properties when filter=array', function (st) {
|
|---|
| 537 | st.equal(qs.stringify({ a: 'b' }, { filter: ['a'] }), 'a=b');
|
|---|
| 538 | st.equal(qs.stringify({ a: 1 }, { filter: [] }), '');
|
|---|
| 539 |
|
|---|
| 540 | st.equal(
|
|---|
| 541 | qs.stringify(
|
|---|
| 542 | { a: { b: [1, 2, 3, 4], c: 'd' }, c: 'f' },
|
|---|
| 543 | { filter: ['a', 'b', 0, 2], arrayFormat: 'indices' }
|
|---|
| 544 | ),
|
|---|
| 545 | 'a%5Bb%5D%5B0%5D=1&a%5Bb%5D%5B2%5D=3',
|
|---|
| 546 | 'indices => indices'
|
|---|
| 547 | );
|
|---|
| 548 | st.equal(
|
|---|
| 549 | qs.stringify(
|
|---|
| 550 | { a: { b: [1, 2, 3, 4], c: 'd' }, c: 'f' },
|
|---|
| 551 | { filter: ['a', 'b', 0, 2], arrayFormat: 'brackets' }
|
|---|
| 552 | ),
|
|---|
| 553 | 'a%5Bb%5D%5B%5D=1&a%5Bb%5D%5B%5D=3',
|
|---|
| 554 | 'brackets => brackets'
|
|---|
| 555 | );
|
|---|
| 556 | st.equal(
|
|---|
| 557 | qs.stringify(
|
|---|
| 558 | { a: { b: [1, 2, 3, 4], c: 'd' }, c: 'f' },
|
|---|
| 559 | { filter: ['a', 'b', 0, 2] }
|
|---|
| 560 | ),
|
|---|
| 561 | 'a%5Bb%5D%5B0%5D=1&a%5Bb%5D%5B2%5D=3',
|
|---|
| 562 | 'default => indices'
|
|---|
| 563 | );
|
|---|
| 564 |
|
|---|
| 565 | st.end();
|
|---|
| 566 | });
|
|---|
| 567 |
|
|---|
| 568 | t.test('supports custom representations when filter=function', function (st) {
|
|---|
| 569 | var calls = 0;
|
|---|
| 570 | var obj = { a: 'b', c: 'd', e: { f: new Date(1257894000000) } };
|
|---|
| 571 | var filterFunc = function (prefix, value) {
|
|---|
| 572 | calls += 1;
|
|---|
| 573 | if (calls === 1) {
|
|---|
| 574 | st.equal(prefix, '', 'prefix is empty');
|
|---|
| 575 | st.equal(value, obj);
|
|---|
| 576 | } else if (prefix === 'c') {
|
|---|
| 577 | return void 0;
|
|---|
| 578 | } else if (value instanceof Date) {
|
|---|
| 579 | st.equal(prefix, 'e[f]');
|
|---|
| 580 | return value.getTime();
|
|---|
| 581 | }
|
|---|
| 582 | return value;
|
|---|
| 583 | };
|
|---|
| 584 |
|
|---|
| 585 | st.equal(qs.stringify(obj, { filter: filterFunc }), 'a=b&e%5Bf%5D=1257894000000');
|
|---|
| 586 | st.equal(calls, 5);
|
|---|
| 587 | st.end();
|
|---|
| 588 | });
|
|---|
| 589 |
|
|---|
| 590 | t.test('can disable uri encoding', function (st) {
|
|---|
| 591 | st.equal(qs.stringify({ a: 'b' }, { encode: false }), 'a=b');
|
|---|
| 592 | st.equal(qs.stringify({ a: { b: 'c' } }, { encode: false }), 'a[b]=c');
|
|---|
| 593 | st.equal(qs.stringify({ a: 'b', c: null }, { strictNullHandling: true, encode: false }), 'a=b&c');
|
|---|
| 594 | st.end();
|
|---|
| 595 | });
|
|---|
| 596 |
|
|---|
| 597 | t.test('can sort the keys', function (st) {
|
|---|
| 598 | var sort = function (a, b) {
|
|---|
| 599 | return a.localeCompare(b);
|
|---|
| 600 | };
|
|---|
| 601 | st.equal(qs.stringify({ a: 'c', z: 'y', b: 'f' }, { sort: sort }), 'a=c&b=f&z=y');
|
|---|
| 602 | st.equal(qs.stringify({ a: 'c', z: { j: 'a', i: 'b' }, b: 'f' }, { sort: sort }), 'a=c&b=f&z%5Bi%5D=b&z%5Bj%5D=a');
|
|---|
| 603 | st.end();
|
|---|
| 604 | });
|
|---|
| 605 |
|
|---|
| 606 | t.test('can sort the keys at depth 3 or more too', function (st) {
|
|---|
| 607 | var sort = function (a, b) {
|
|---|
| 608 | return a.localeCompare(b);
|
|---|
| 609 | };
|
|---|
| 610 | st.equal(
|
|---|
| 611 | qs.stringify(
|
|---|
| 612 | { a: 'a', z: { zj: { zjb: 'zjb', zja: 'zja' }, zi: { zib: 'zib', zia: 'zia' } }, b: 'b' },
|
|---|
| 613 | { sort: sort, encode: false }
|
|---|
| 614 | ),
|
|---|
| 615 | 'a=a&b=b&z[zi][zia]=zia&z[zi][zib]=zib&z[zj][zja]=zja&z[zj][zjb]=zjb'
|
|---|
| 616 | );
|
|---|
| 617 | st.equal(
|
|---|
| 618 | qs.stringify(
|
|---|
| 619 | { a: 'a', z: { zj: { zjb: 'zjb', zja: 'zja' }, zi: { zib: 'zib', zia: 'zia' } }, b: 'b' },
|
|---|
| 620 | { sort: null, encode: false }
|
|---|
| 621 | ),
|
|---|
| 622 | 'a=a&z[zj][zjb]=zjb&z[zj][zja]=zja&z[zi][zib]=zib&z[zi][zia]=zia&b=b'
|
|---|
| 623 | );
|
|---|
| 624 | st.end();
|
|---|
| 625 | });
|
|---|
| 626 |
|
|---|
| 627 | t.test('can stringify with custom encoding', function (st) {
|
|---|
| 628 | st.equal(qs.stringify({ 県: '大阪府', '': '' }, {
|
|---|
| 629 | encoder: function (str) {
|
|---|
| 630 | if (str.length === 0) {
|
|---|
| 631 | return '';
|
|---|
| 632 | }
|
|---|
| 633 | var buf = iconv.encode(str, 'shiftjis');
|
|---|
| 634 | var result = [];
|
|---|
| 635 | for (var i = 0; i < buf.length; ++i) {
|
|---|
| 636 | result.push(buf.readUInt8(i).toString(16));
|
|---|
| 637 | }
|
|---|
| 638 | return '%' + result.join('%');
|
|---|
| 639 | }
|
|---|
| 640 | }), '%8c%a7=%91%e5%8d%e3%95%7b&=');
|
|---|
| 641 | st.end();
|
|---|
| 642 | });
|
|---|
| 643 |
|
|---|
| 644 | t.test('receives the default encoder as a second argument', function (st) {
|
|---|
| 645 | st.plan(2);
|
|---|
| 646 | qs.stringify({ a: 1 }, {
|
|---|
| 647 | encoder: function (str, defaultEncoder) {
|
|---|
| 648 | st.equal(defaultEncoder, utils.encode);
|
|---|
| 649 | }
|
|---|
| 650 | });
|
|---|
| 651 | st.end();
|
|---|
| 652 | });
|
|---|
| 653 |
|
|---|
| 654 | t.test('throws error with wrong encoder', function (st) {
|
|---|
| 655 | st['throws'](function () {
|
|---|
| 656 | qs.stringify({}, { encoder: 'string' });
|
|---|
| 657 | }, new TypeError('Encoder has to be a function.'));
|
|---|
| 658 | st.end();
|
|---|
| 659 | });
|
|---|
| 660 |
|
|---|
| 661 | t.test('can use custom encoder for a buffer object', { skip: typeof Buffer === 'undefined' }, function (st) {
|
|---|
| 662 | st.equal(qs.stringify({ a: SaferBuffer.from([1]) }, {
|
|---|
| 663 | encoder: function (buffer) {
|
|---|
| 664 | if (typeof buffer === 'string') {
|
|---|
| 665 | return buffer;
|
|---|
| 666 | }
|
|---|
| 667 | return String.fromCharCode(buffer.readUInt8(0) + 97);
|
|---|
| 668 | }
|
|---|
| 669 | }), 'a=b');
|
|---|
| 670 |
|
|---|
| 671 | st.equal(qs.stringify({ a: SaferBuffer.from('a b') }, {
|
|---|
| 672 | encoder: function (buffer) {
|
|---|
| 673 | return buffer;
|
|---|
| 674 | }
|
|---|
| 675 | }), 'a=a b');
|
|---|
| 676 | st.end();
|
|---|
| 677 | });
|
|---|
| 678 |
|
|---|
| 679 | t.test('serializeDate option', function (st) {
|
|---|
| 680 | var date = new Date();
|
|---|
| 681 | st.equal(
|
|---|
| 682 | qs.stringify({ a: date }),
|
|---|
| 683 | 'a=' + date.toISOString().replace(/:/g, '%3A'),
|
|---|
| 684 | 'default is toISOString'
|
|---|
| 685 | );
|
|---|
| 686 |
|
|---|
| 687 | var mutatedDate = new Date();
|
|---|
| 688 | mutatedDate.toISOString = function () {
|
|---|
| 689 | throw new SyntaxError();
|
|---|
| 690 | };
|
|---|
| 691 | st['throws'](function () {
|
|---|
| 692 | mutatedDate.toISOString();
|
|---|
| 693 | }, SyntaxError);
|
|---|
| 694 | st.equal(
|
|---|
| 695 | qs.stringify({ a: mutatedDate }),
|
|---|
| 696 | 'a=' + Date.prototype.toISOString.call(mutatedDate).replace(/:/g, '%3A'),
|
|---|
| 697 | 'toISOString works even when method is not locally present'
|
|---|
| 698 | );
|
|---|
| 699 |
|
|---|
| 700 | var specificDate = new Date(6);
|
|---|
| 701 | st.equal(
|
|---|
| 702 | qs.stringify(
|
|---|
| 703 | { a: specificDate },
|
|---|
| 704 | { serializeDate: function (d) { return d.getTime() * 7; } }
|
|---|
| 705 | ),
|
|---|
| 706 | 'a=42',
|
|---|
| 707 | 'custom serializeDate function called'
|
|---|
| 708 | );
|
|---|
| 709 |
|
|---|
| 710 | st.equal(
|
|---|
| 711 | qs.stringify(
|
|---|
| 712 | { a: [date] },
|
|---|
| 713 | {
|
|---|
| 714 | serializeDate: function (d) { return d.getTime(); },
|
|---|
| 715 | arrayFormat: 'comma'
|
|---|
| 716 | }
|
|---|
| 717 | ),
|
|---|
| 718 | 'a=' + date.getTime(),
|
|---|
| 719 | 'works with arrayFormat comma'
|
|---|
| 720 | );
|
|---|
| 721 | st.equal(
|
|---|
| 722 | qs.stringify(
|
|---|
| 723 | { a: [date] },
|
|---|
| 724 | {
|
|---|
| 725 | serializeDate: function (d) { return d.getTime(); },
|
|---|
| 726 | arrayFormat: 'comma',
|
|---|
| 727 | commaRoundTrip: true
|
|---|
| 728 | }
|
|---|
| 729 | ),
|
|---|
| 730 | 'a%5B%5D=' + date.getTime(),
|
|---|
| 731 | 'works with arrayFormat comma'
|
|---|
| 732 | );
|
|---|
| 733 |
|
|---|
| 734 | st.end();
|
|---|
| 735 | });
|
|---|
| 736 |
|
|---|
| 737 | t.test('RFC 1738 serialization', function (st) {
|
|---|
| 738 | st.equal(qs.stringify({ a: 'b c' }, { format: qs.formats.RFC1738 }), 'a=b+c');
|
|---|
| 739 | st.equal(qs.stringify({ 'a b': 'c d' }, { format: qs.formats.RFC1738 }), 'a+b=c+d');
|
|---|
| 740 | st.equal(qs.stringify({ 'a b': SaferBuffer.from('a b') }, { format: qs.formats.RFC1738 }), 'a+b=a+b');
|
|---|
| 741 |
|
|---|
| 742 | st.equal(qs.stringify({ 'foo(ref)': 'bar' }, { format: qs.formats.RFC1738 }), 'foo(ref)=bar');
|
|---|
| 743 |
|
|---|
| 744 | st.end();
|
|---|
| 745 | });
|
|---|
| 746 |
|
|---|
| 747 | t.test('RFC 3986 spaces serialization', function (st) {
|
|---|
| 748 | st.equal(qs.stringify({ a: 'b c' }, { format: qs.formats.RFC3986 }), 'a=b%20c');
|
|---|
| 749 | st.equal(qs.stringify({ 'a b': 'c d' }, { format: qs.formats.RFC3986 }), 'a%20b=c%20d');
|
|---|
| 750 | st.equal(qs.stringify({ 'a b': SaferBuffer.from('a b') }, { format: qs.formats.RFC3986 }), 'a%20b=a%20b');
|
|---|
| 751 |
|
|---|
| 752 | st.end();
|
|---|
| 753 | });
|
|---|
| 754 |
|
|---|
| 755 | t.test('Backward compatibility to RFC 3986', function (st) {
|
|---|
| 756 | st.equal(qs.stringify({ a: 'b c' }), 'a=b%20c');
|
|---|
| 757 | st.equal(qs.stringify({ 'a b': SaferBuffer.from('a b') }), 'a%20b=a%20b');
|
|---|
| 758 |
|
|---|
| 759 | st.end();
|
|---|
| 760 | });
|
|---|
| 761 |
|
|---|
| 762 | t.test('Edge cases and unknown formats', function (st) {
|
|---|
| 763 | ['UFO1234', false, 1234, null, {}, []].forEach(function (format) {
|
|---|
| 764 | st['throws'](
|
|---|
| 765 | function () {
|
|---|
| 766 | qs.stringify({ a: 'b c' }, { format: format });
|
|---|
| 767 | },
|
|---|
| 768 | new TypeError('Unknown format option provided.')
|
|---|
| 769 | );
|
|---|
| 770 | });
|
|---|
| 771 | st.end();
|
|---|
| 772 | });
|
|---|
| 773 |
|
|---|
| 774 | t.test('encodeValuesOnly', function (st) {
|
|---|
| 775 | st.equal(
|
|---|
| 776 | qs.stringify(
|
|---|
| 777 | { a: 'b', c: ['d', 'e=f'], f: [['g'], ['h']] },
|
|---|
| 778 | { encodeValuesOnly: true }
|
|---|
| 779 | ),
|
|---|
| 780 | 'a=b&c[0]=d&c[1]=e%3Df&f[0][0]=g&f[1][0]=h'
|
|---|
| 781 | );
|
|---|
| 782 | st.equal(
|
|---|
| 783 | qs.stringify(
|
|---|
| 784 | { a: 'b', c: ['d', 'e'], f: [['g'], ['h']] }
|
|---|
| 785 | ),
|
|---|
| 786 | 'a=b&c%5B0%5D=d&c%5B1%5D=e&f%5B0%5D%5B0%5D=g&f%5B1%5D%5B0%5D=h'
|
|---|
| 787 | );
|
|---|
| 788 | st.end();
|
|---|
| 789 | });
|
|---|
| 790 |
|
|---|
| 791 | t.test('encodeValuesOnly - strictNullHandling', function (st) {
|
|---|
| 792 | st.equal(
|
|---|
| 793 | qs.stringify(
|
|---|
| 794 | { a: { b: null } },
|
|---|
| 795 | { encodeValuesOnly: true, strictNullHandling: true }
|
|---|
| 796 | ),
|
|---|
| 797 | 'a[b]'
|
|---|
| 798 | );
|
|---|
| 799 | st.end();
|
|---|
| 800 | });
|
|---|
| 801 |
|
|---|
| 802 | t.test('throws if an invalid charset is specified', function (st) {
|
|---|
| 803 | st['throws'](function () {
|
|---|
| 804 | qs.stringify({ a: 'b' }, { charset: 'foobar' });
|
|---|
| 805 | }, new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined'));
|
|---|
| 806 | st.end();
|
|---|
| 807 | });
|
|---|
| 808 |
|
|---|
| 809 | t.test('respects a charset of iso-8859-1', function (st) {
|
|---|
| 810 | st.equal(qs.stringify({ æ: 'æ' }, { charset: 'iso-8859-1' }), '%E6=%E6');
|
|---|
| 811 | st.end();
|
|---|
| 812 | });
|
|---|
| 813 |
|
|---|
| 814 | t.test('encodes unrepresentable chars as numeric entities in iso-8859-1 mode', function (st) {
|
|---|
| 815 | st.equal(qs.stringify({ a: '☺' }, { charset: 'iso-8859-1' }), 'a=%26%239786%3B');
|
|---|
| 816 | st.end();
|
|---|
| 817 | });
|
|---|
| 818 |
|
|---|
| 819 | t.test('respects an explicit charset of utf-8 (the default)', function (st) {
|
|---|
| 820 | st.equal(qs.stringify({ a: 'æ' }, { charset: 'utf-8' }), 'a=%C3%A6');
|
|---|
| 821 | st.end();
|
|---|
| 822 | });
|
|---|
| 823 |
|
|---|
| 824 | t.test('adds the right sentinel when instructed to and the charset is utf-8', function (st) {
|
|---|
| 825 | st.equal(qs.stringify({ a: 'æ' }, { charsetSentinel: true, charset: 'utf-8' }), 'utf8=%E2%9C%93&a=%C3%A6');
|
|---|
| 826 | st.end();
|
|---|
| 827 | });
|
|---|
| 828 |
|
|---|
| 829 | t.test('adds the right sentinel when instructed to and the charset is iso-8859-1', function (st) {
|
|---|
| 830 | st.equal(qs.stringify({ a: 'æ' }, { charsetSentinel: true, charset: 'iso-8859-1' }), 'utf8=%26%2310003%3B&a=%E6');
|
|---|
| 831 | st.end();
|
|---|
| 832 | });
|
|---|
| 833 |
|
|---|
| 834 | t.test('does not mutate the options argument', function (st) {
|
|---|
| 835 | var options = {};
|
|---|
| 836 | qs.stringify({}, options);
|
|---|
| 837 | st.deepEqual(options, {});
|
|---|
| 838 | st.end();
|
|---|
| 839 | });
|
|---|
| 840 |
|
|---|
| 841 | t.test('strictNullHandling works with custom filter', function (st) {
|
|---|
| 842 | var filter = function (prefix, value) {
|
|---|
| 843 | return value;
|
|---|
| 844 | };
|
|---|
| 845 |
|
|---|
| 846 | var options = { strictNullHandling: true, filter: filter };
|
|---|
| 847 | st.equal(qs.stringify({ key: null }, options), 'key');
|
|---|
| 848 | st.end();
|
|---|
| 849 | });
|
|---|
| 850 |
|
|---|
| 851 | t.test('strictNullHandling works with null serializeDate', function (st) {
|
|---|
| 852 | var serializeDate = function () {
|
|---|
| 853 | return null;
|
|---|
| 854 | };
|
|---|
| 855 | var options = { strictNullHandling: true, serializeDate: serializeDate };
|
|---|
| 856 | var date = new Date();
|
|---|
| 857 | st.equal(qs.stringify({ key: date }, options), 'key');
|
|---|
| 858 | st.end();
|
|---|
| 859 | });
|
|---|
| 860 |
|
|---|
| 861 | t.test('allows for encoding keys and values differently', function (st) {
|
|---|
| 862 | var encoder = function (str, defaultEncoder, charset, type) {
|
|---|
| 863 | if (type === 'key') {
|
|---|
| 864 | return defaultEncoder(str, defaultEncoder, charset, type).toLowerCase();
|
|---|
| 865 | }
|
|---|
| 866 | if (type === 'value') {
|
|---|
| 867 | return defaultEncoder(str, defaultEncoder, charset, type).toUpperCase();
|
|---|
| 868 | }
|
|---|
| 869 | throw 'this should never happen! type: ' + type;
|
|---|
| 870 | };
|
|---|
| 871 |
|
|---|
| 872 | st.deepEqual(qs.stringify({ KeY: 'vAlUe' }, { encoder: encoder }), 'key=VALUE');
|
|---|
| 873 | st.end();
|
|---|
| 874 | });
|
|---|
| 875 |
|
|---|
| 876 | t.test('objects inside arrays', function (st) {
|
|---|
| 877 | var obj = { a: { b: { c: 'd', e: 'f' } } };
|
|---|
| 878 | var withArray = { a: { b: [{ c: 'd', e: 'f' }] } };
|
|---|
| 879 |
|
|---|
| 880 | st.equal(qs.stringify(obj, { encode: false }), 'a[b][c]=d&a[b][e]=f', 'no array, no arrayFormat');
|
|---|
| 881 | st.equal(qs.stringify(obj, { encode: false, arrayFormat: 'bracket' }), 'a[b][c]=d&a[b][e]=f', 'no array, bracket');
|
|---|
| 882 | st.equal(qs.stringify(obj, { encode: false, arrayFormat: 'indices' }), 'a[b][c]=d&a[b][e]=f', 'no array, indices');
|
|---|
| 883 | st.equal(qs.stringify(obj, { encode: false, arrayFormat: 'comma' }), 'a[b][c]=d&a[b][e]=f', 'no array, comma');
|
|---|
| 884 |
|
|---|
| 885 | st.equal(qs.stringify(withArray, { encode: false }), 'a[b][0][c]=d&a[b][0][e]=f', 'array, no arrayFormat');
|
|---|
| 886 | st.equal(qs.stringify(withArray, { encode: false, arrayFormat: 'bracket' }), 'a[b][0][c]=d&a[b][0][e]=f', 'array, bracket');
|
|---|
| 887 | st.equal(qs.stringify(withArray, { encode: false, arrayFormat: 'indices' }), 'a[b][0][c]=d&a[b][0][e]=f', 'array, indices');
|
|---|
| 888 | st.equal(
|
|---|
| 889 | qs.stringify(withArray, { encode: false, arrayFormat: 'comma' }),
|
|---|
| 890 | '???',
|
|---|
| 891 | 'array, comma',
|
|---|
| 892 | { skip: 'TODO: figure out what this should do' }
|
|---|
| 893 | );
|
|---|
| 894 |
|
|---|
| 895 | st.end();
|
|---|
| 896 | });
|
|---|
| 897 |
|
|---|
| 898 | t.test('stringifies sparse arrays', function (st) {
|
|---|
| 899 | /* eslint no-sparse-arrays: 0 */
|
|---|
| 900 | st.equal(qs.stringify({ a: [, '2', , , '1'] }, { encodeValuesOnly: true }), 'a[1]=2&a[4]=1');
|
|---|
| 901 | st.equal(qs.stringify({ a: [, { b: [, , { c: '1' }] }] }, { encodeValuesOnly: true }), 'a[1][b][2][c]=1');
|
|---|
| 902 | st.equal(qs.stringify({ a: [, [, , [, , , { c: '1' }]]] }, { encodeValuesOnly: true }), 'a[1][2][3][c]=1');
|
|---|
| 903 | st.equal(qs.stringify({ a: [, [, , [, , , { c: [, '1'] }]]] }, { encodeValuesOnly: true }), 'a[1][2][3][c][1]=1');
|
|---|
| 904 |
|
|---|
| 905 | st.end();
|
|---|
| 906 | });
|
|---|
| 907 |
|
|---|
| 908 | t.end();
|
|---|
| 909 | });
|
|---|
