github.com/dop251/goja_nodejs@v0.0.0-20240418154818-2aae10d4cbcf/url/testdata/url_search_params.js (about) 1 "use strict"; 2 3 const assert = require("../../assert.js"); 4 5 let params; 6 7 function testCtor(value, expected) { 8 assert.sameValue(new URLSearchParams(value).toString(), expected); 9 } 10 11 testCtor("user=abc&query=xyz", "user=abc&query=xyz"); 12 testCtor("?user=abc&query=xyz", "user=abc&query=xyz"); 13 14 testCtor( 15 { 16 num: 1, 17 user: "abc", 18 query: ["first", "second"], 19 obj: { prop: "value" }, 20 b: true, 21 }, 22 "num=1&user=abc&query=first%2Csecond&obj=%5Bobject+Object%5D&b=true" 23 ); 24 25 const map = new Map(); 26 map.set("user", "abc"); 27 map.set("query", "xyz"); 28 testCtor(map, "user=abc&query=xyz"); 29 30 testCtor( 31 [ 32 ["user", "abc"], 33 ["query", "first"], 34 ["query", "second"], 35 ], 36 "user=abc&query=first&query=second" 37 ); 38 39 // Each key-value pair must have exactly two elements 40 assert.throwsNodeError(() => new URLSearchParams([["single_value"]]), TypeError, "ERR_INVALID_TUPLE"); 41 assert.throwsNodeError(() => new URLSearchParams([["too", "many", "values"]]), TypeError, "ERR_INVALID_TUPLE"); 42 43 params = new URLSearchParams("a=b&cc=d"); 44 params.forEach((value, name, searchParams) => { 45 if (name === "a") { 46 assert.sameValue(value, "b"); 47 } 48 if (name === "cc") { 49 assert.sameValue(value, "d"); 50 } 51 assert.sameValue(searchParams, params); 52 }); 53 54 params.forEach((value, name, searchParams) => { 55 if (name === "a") { 56 assert.sameValue(value, "b"); 57 searchParams.set("cc", "d1"); 58 } 59 if (name === "cc") { 60 assert.sameValue(value, "d1"); 61 } 62 assert.sameValue(searchParams, params); 63 }); 64 65 assert.throwsNodeError(() => params.forEach(123), TypeError, "ERR_INVALID_ARG_TYPE"); 66 67 assert.throwsNodeError(() => params.forEach.call(1, 2), TypeError, "ERR_INVALID_THIS"); 68 69 params = new URLSearchParams("a=1=2&b=3"); 70 assert.sameValue(params.size, 2); 71 assert.sameValue(params.get("a"), "1=2"); 72 assert.sameValue(params.get("b"), "3"); 73 74 params = new URLSearchParams("&"); 75 assert.sameValue(params.size, 0); 76 77 params = new URLSearchParams("& "); 78 assert.sameValue(params.size, 1); 79 assert.sameValue(params.get(" "), ""); 80 81 params = new URLSearchParams(" &"); 82 assert.sameValue(params.size, 1); 83 assert.sameValue(params.get(" "), ""); 84 85 params = new URLSearchParams("="); 86 assert.sameValue(params.size, 1); 87 assert.sameValue(params.get(""), ""); 88 89 params = new URLSearchParams("&=2"); 90 assert.sameValue(params.size, 1); 91 assert.sameValue(params.get(""), "2"); 92 93 params = new URLSearchParams("?user=abc"); 94 assert.throwsNodeError(() => params.append(), TypeError, "ERR_MISSING_ARGS"); 95 params.append("query", "first"); 96 assert.sameValue(params.toString(), "user=abc&query=first"); 97 98 params = new URLSearchParams("first=one&second=two&third=three"); 99 assert.throwsNodeError(() => params.delete(), TypeError, "ERR_MISSING_ARGS"); 100 params.delete("second", "fake-value"); 101 assert.sameValue(params.toString(), "first=one&second=two&third=three"); 102 params.delete("third", "three"); 103 assert.sameValue(params.toString(), "first=one&second=two"); 104 params.delete("second"); 105 assert.sameValue(params.toString(), "first=one"); 106 107 params = new URLSearchParams("user=abc&query=xyz"); 108 assert.throwsNodeError(() => params.get(), TypeError, "ERR_MISSING_ARGS"); 109 assert.sameValue(params.get("user"), "abc"); 110 assert.sameValue(params.get("non-existant"), null); 111 112 params = new URLSearchParams("query=first&query=second"); 113 assert.throwsNodeError(() => params.getAll(), TypeError, "ERR_MISSING_ARGS"); 114 const all = params.getAll("query"); 115 assert.sameValue(all.includes("first"), true); 116 assert.sameValue(all.includes("second"), true); 117 assert.sameValue(all.length, 2); 118 const getAllUndefined = params.getAll(undefined); 119 assert.sameValue(getAllUndefined.length, 0); 120 const getAllNonExistant = params.getAll("does_not_exists"); 121 assert.sameValue(getAllNonExistant.length, 0); 122 123 params = new URLSearchParams("user=abc&query=xyz"); 124 assert.throwsNodeError(() => params.has(), TypeError, "ERR_MISSING_ARGS"); 125 assert.sameValue(params.has(undefined), false); 126 assert.sameValue(params.has("user"), true); 127 assert.sameValue(params.has("user", "abc"), true); 128 assert.sameValue(params.has("user", "abc", "extra-param"), true); 129 assert.sameValue(params.has("user", "efg"), false); 130 assert.sameValue(params.has("user", undefined), true); 131 132 params = new URLSearchParams(); 133 params.append("foo", "bar"); 134 params.append("foo", "baz"); 135 params.append("abc", "def"); 136 assert.sameValue(params.toString(), "foo=bar&foo=baz&abc=def"); 137 params.set("foo", "def"); 138 params.set("xyz", "opq"); 139 assert.sameValue(params.toString(), "foo=def&abc=def&xyz=opq"); 140 141 params = new URLSearchParams("query=first&query=second&user=abc&double=first,second"); 142 const URLSearchIteratorPrototype = params.entries().__proto__; 143 assert.sameValue(typeof URLSearchIteratorPrototype, "object"); 144 145 assert.sameValue(params[Symbol.iterator], params.entries); 146 147 { 148 const entries = params.entries(); 149 assert.sameValue(entries.toString(), "[object URLSearchParams Iterator]"); 150 assert.sameValue(entries.__proto__, URLSearchIteratorPrototype); 151 152 let item = entries.next(); 153 assert.sameValue(item.value.toString(), ["query", "first"].toString()); 154 assert.sameValue(item.done, false); 155 156 item = entries.next(); 157 assert.sameValue(item.value.toString(), ["query", "second"].toString()); 158 assert.sameValue(item.done, false); 159 160 item = entries.next(); 161 assert.sameValue(item.value.toString(), ["user", "abc"].toString()); 162 assert.sameValue(item.done, false); 163 164 item = entries.next(); 165 assert.sameValue(item.value.toString(), ["double", "first,second"].toString()); 166 assert.sameValue(item.done, false); 167 168 item = entries.next(); 169 assert.sameValue(item.value, undefined); 170 assert.sameValue(item.done, true); 171 } 172 173 params = new URLSearchParams("query=first&query=second&user=abc"); 174 { 175 const keys = params.keys(); 176 assert.sameValue(keys.__proto__, URLSearchIteratorPrototype); 177 178 let item = keys.next(); 179 assert.sameValue(item.value, "query"); 180 assert.sameValue(item.done, false); 181 182 item = keys.next(); 183 assert.sameValue(item.value, "query"); 184 assert.sameValue(item.done, false); 185 186 item = keys.next(); 187 assert.sameValue(item.value, "user"); 188 assert.sameValue(item.done, false); 189 190 item = keys.next(); 191 assert.sameValue(item.value, undefined); 192 assert.sameValue(item.done, true); 193 } 194 195 params = new URLSearchParams("query=first&query=second&user=abc"); 196 { 197 const values = params.values(); 198 assert.sameValue(values.__proto__, URLSearchIteratorPrototype); 199 200 let item = values.next(); 201 assert.sameValue(item.value, "first"); 202 assert.sameValue(item.done, false); 203 204 item = values.next(); 205 assert.sameValue(item.value, "second"); 206 assert.sameValue(item.done, false); 207 208 item = values.next(); 209 assert.sameValue(item.value, "abc"); 210 assert.sameValue(item.done, false); 211 212 item = values.next(); 213 assert.sameValue(item.value, undefined); 214 assert.sameValue(item.done, true); 215 } 216 217 218 params = new URLSearchParams("query[]=abc&type=search&query[]=123"); 219 params.sort(); 220 assert.sameValue(params.toString(), "query%5B%5D=abc&query%5B%5D=123&type=search"); 221 222 params = new URLSearchParams("query=first&query=second&user=abc"); 223 assert.sameValue(params.size, 3); 224 225 params = new URLSearchParams("%"); 226 assert.sameValue(params.has("%"), true); 227 assert.sameValue(params.toString(), "%25="); 228 229 { 230 const params = new URLSearchParams(""); 231 assert.sameValue(params.size, 0); 232 assert.sameValue(params.toString(), ""); 233 assert.sameValue(params.get(undefined), null); 234 params.set(undefined, true); 235 assert.sameValue(params.has(undefined), true); 236 assert.sameValue(params.has("undefined"), true); 237 assert.sameValue(params.get("undefined"), "true"); 238 assert.sameValue(params.get(undefined), "true"); 239 assert.sameValue(params.getAll(undefined).toString(), ["true"].toString()); 240 params.delete(undefined); 241 assert.sameValue(params.has(undefined), false); 242 assert.sameValue(params.has("undefined"), false); 243 244 assert.sameValue(params.has(null), false); 245 params.set(null, "nullval"); 246 assert.sameValue(params.has(null), true); 247 assert.sameValue(params.has("null"), true); 248 assert.sameValue(params.get(null), "nullval"); 249 assert.sameValue(params.get("null"), "nullval"); 250 params.delete(null); 251 assert.sameValue(params.has(null), false); 252 assert.sameValue(params.has("null"), false); 253 } 254 255 function* functionGeneratorExample() { 256 yield ["user", "abc"]; 257 yield ["query", "first"]; 258 yield ["query", "second"]; 259 } 260 261 params = new URLSearchParams(functionGeneratorExample()); 262 assert.sameValue(params.toString(), "user=abc&query=first&query=second"); 263 264 assert.sameValue(params.__proto__.constructor, URLSearchParams); 265 assert.sameValue(params instanceof URLSearchParams, true); 266 267 { 268 const params = new URLSearchParams("1=2&1=3"); 269 assert.sameValue(params.get(1), "2"); 270 assert.sameValue(params.getAll(1).toString(), ["2", "3"].toString()); 271 assert.sameValue(params.getAll("x").toString(), [].toString()); 272 } 273 274 // Sync 275 { 276 const url = new URL("https://test.com/"); 277 const params = url.searchParams; 278 assert.sameValue(params.size, 0); 279 url.search = "a=1"; 280 assert.sameValue(params.size, 1); 281 assert.sameValue(params.get("a"), "1"); 282 } 283 284 { 285 const url = new URL("https://test.com/?a=1"); 286 const params = url.searchParams; 287 assert.sameValue(params.size, 1); 288 url.search = ""; 289 assert.sameValue(params.size, 0); 290 url.search = "b=2"; 291 assert.sameValue(params.size, 1); 292 } 293 294 { 295 const url = new URL("https://test.com/"); 296 const params = url.searchParams; 297 params.append("a", "1"); 298 assert.sameValue(url.toString(), "https://test.com/?a=1"); 299 } 300 301 { 302 const url = new URL("https://test.com/"); 303 url.searchParams.append("a", "1"); 304 url.searchParams.append("b", "1"); 305 assert.sameValue(url.toString(), "https://test.com/?a=1&b=1"); 306 } 307 308 { 309 const url = new URL("https://test.com/"); 310 const params = url.searchParams; 311 url.searchParams.append("a", "1"); 312 assert.sameValue(url.search, "?a=1"); 313 } 314 315 { 316 const url = new URL("https://test.com/?a=1"); 317 const params = url.searchParams; 318 params.append("a", "2"); 319 assert.sameValue(url.search, "?a=1&a=2"); 320 } 321 322 { 323 const url = new URL("https://test.com/"); 324 const params = url.searchParams; 325 params.set("a", "1"); 326 assert.sameValue(url.search, "?a=1"); 327 } 328 329 { 330 const url = new URL("https://test.com/"); 331 url.searchParams.set("a", "1"); 332 url.searchParams.set("b", "1"); 333 assert.sameValue(url.toString(), "https://test.com/?a=1&b=1"); 334 } 335 336 { 337 const url = new URL("https://test.com/?a=1&b=2"); 338 const params = url.searchParams; 339 params.delete("a"); 340 assert.sameValue(url.search, "?b=2"); 341 } 342 343 { 344 const url = new URL("https://test.com/?b=2&a=1"); 345 const params = url.searchParams; 346 params.sort(); 347 assert.sameValue(url.search, "?a=1&b=2"); 348 } 349 350 { 351 const url = new URL("https://test.com/?a=1"); 352 const params = url.searchParams; 353 params.delete("a"); 354 assert.sameValue(url.search, ""); 355 356 params.set("a", 2); 357 assert.sameValue(url.search, "?a=2"); 358 } 359 360 // FAILING: no custom properties on wrapped Go structs 361 /* 362 { 363 const params = new URLSearchParams(""); 364 assert.sameValue(Object.isExtensible(params), true); 365 assert.sameValue(Reflect.defineProperty(params, "customField", {value: 42, configurable: true}), true); 366 assert.sameValue(params.customField, 42); 367 const desc = Reflect.getOwnPropertyDescriptor(params, "customField"); 368 assert.sameValue(desc.value, 42); 369 assert.sameValue(desc.writable, false); 370 assert.sameValue(desc.enumerable, false); 371 assert.sameValue(desc.configurable, true); 372 } 373 */ 374 375 // Escape 376 { 377 const myURL = new URL('https://example.org/abc?fo~o=~ba r%z'); 378 379 assert.sameValue(myURL.search, "?fo~o=~ba%20r%z"); 380 381 // Modify the URL via searchParams... 382 myURL.searchParams.sort(); 383 384 assert.sameValue(myURL.search, "?fo%7Eo=%7Eba+r%25z"); 385 }