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  }