@e22m4u/js-trie-router 0.7.0 → 0.7.2

package/dist/cjs/index.cjs

@@ -427,13 +427,43 @@ __name(parseCookieString, "parseCookieString");
 // src/utils/create-request-mock.js
 var import_net = require("net");
 var import_tls = require("tls");
+var import_querystring = __toESM(require("querystring"), 1);
 var import_http2 = require("http");
+var import_js_format9 = require("@e22m4u/js-format");
+
+// src/utils/create-cookie-string.js
 var import_js_format8 = require("@e22m4u/js-format");
+function createCookieString(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new import_js_format8.InvalidArgumentError(
+      "Cookie data must be an Object, but %v was given.",
+      data
+    );
+  }
+  let cookies = "";
+  for (const key in data) {
+    if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      continue;
+    }
+    const val = data[key];
+    if (val == null) {
+      continue;
+    }
+    cookies += `${key}=${val}; `;
+  }
+  return cookies.trim().replace(/;$/, "");
+}
+__name(createCookieString, "createCookieString");
+
+// src/utils/create-request-mock.js
 var SUPPORTED_OPTIONS = [
   "host",
   "method",
   "secure",
   "url",
+  "path",
+  "query",
+  "cookies",
   "headers",
   "body",
   "stream",
@@ -442,54 +472,106 @@ var SUPPORTED_OPTIONS = [
 function createRequestMock(options) {
   if (options !== void 0) {
     if (!options || typeof options !== "object" || Array.isArray(options)) {
-      throw new import_js_format8.InvalidArgumentError(
+      throw new import_js_format9.InvalidArgumentError(
         'Parameter "options" must be an Object, but %v was given.',
         options
       );
     }
     Object.keys(options).forEach((optionName) => {
       if (!SUPPORTED_OPTIONS.includes(optionName)) {
-        throw new import_js_format8.InvalidArgumentError(
+        throw new import_js_format9.InvalidArgumentError(
           "Option %v is not supported.",
           optionName
         );
       }
     });
     if (options.host !== void 0 && typeof options.host !== "string") {
-      throw new import_js_format8.InvalidArgumentError(
+      throw new import_js_format9.InvalidArgumentError(
         'Option "host" must be a String, but %v was given.',
         options.host
       );
     }
     if (options.method !== void 0 && typeof options.method !== "string") {
-      throw new import_js_format8.InvalidArgumentError(
+      throw new import_js_format9.InvalidArgumentError(
         'Option "method" must be a String, but %v was given.',
         options.method
       );
     }
     if (options.secure !== void 0 && typeof options.secure !== "boolean") {
-      throw new import_js_format8.InvalidArgumentError(
+      throw new import_js_format9.InvalidArgumentError(
         'Option "secure" must be a Boolean, but %v was given.',
         options.secure
       );
     }
     if (options.url !== void 0) {
       if (typeof options.url !== "string") {
-        throw new import_js_format8.InvalidArgumentError(
+        throw new import_js_format9.InvalidArgumentError(
           'Option "url" must be a String, but %v was given.',
           options.url
         );
       }
       if (options.url.indexOf("#") !== -1) {
-        throw new import_js_format8.InvalidArgumentError(
+        throw new import_js_format9.InvalidArgumentError(
           'Option "url" must not contain "#", but %v was given.',
           options.url
         );
       }
     }
+    if (options.path !== void 0) {
+      if (typeof options.path !== "string") {
+        throw new import_js_format9.InvalidArgumentError(
+          'Option "path" must be a String, but %v was given.',
+          options.path
+        );
+      }
+      if (options.path.indexOf("#") !== -1) {
+        throw new import_js_format9.InvalidArgumentError(
+          'Option "path" must not contain "#", but %v was given.',
+          options.path
+        );
+      }
+      if (options.path.indexOf("?") !== -1) {
+        throw new import_js_format9.InvalidArgumentError(
+          'Option "path" must not contain "?", but %v was given.',
+          options.path
+        );
+      }
+      if (!options.path.startsWith("/")) {
+        throw new import_js_format9.InvalidArgumentError(
+          'Option "path" must start with "/", but %v was given.',
+          options.path
+        );
+      }
+    }
+    if (options.query !== void 0) {
+      if (options.query === null || typeof options.query !== "string" && typeof options.query !== "object" || Array.isArray(options.query)) {
+        throw new import_js_format9.InvalidArgumentError(
+          'Option "query" must be a String or an Object, but %v was given.',
+          options.query
+        );
+      }
+    }
+    if (options.cookies !== void 0) {
+      if (!options.cookies || typeof options.cookies !== "object" || Array.isArray(options.cookies)) {
+        throw new import_js_format9.InvalidArgumentError(
+          'Option "cookies" must be an Object, but %v was given.',
+          options.cookies
+        );
+      }
+      Object.keys(options.cookies).forEach((cookieName) => {
+        const cookieValue = options.cookies[cookieName];
+        if (cookieValue !== void 0 && typeof cookieValue !== "string") {
+          throw new import_js_format9.InvalidArgumentError(
+            "Cookie %v must be a String, but %v was given.",
+            cookieName,
+            cookieValue
+          );
+        }
+      });
+    }
     if (options.headers !== void 0) {
       if (!options.headers || typeof options.headers !== "object" || Array.isArray(options.headers)) {
-        throw new import_js_format8.InvalidArgumentError(
+        throw new import_js_format9.InvalidArgumentError(
           'Option "headers" must be an Object, but %v was given.',
           options.headers
         );
@@ -498,7 +580,7 @@ function createRequestMock(options) {
         const headerValue = options.headers[headerName];
         if (headerValue !== void 0) {
           if (typeof headerValue !== "string" && !Array.isArray(headerValue)) {
-            throw new import_js_format8.InvalidArgumentError(
+            throw new import_js_format9.InvalidArgumentError(
               "Header %v must be a String or an Array, but %v was given.",
               headerName,
               headerValue
@@ -507,7 +589,7 @@ function createRequestMock(options) {
           if (Array.isArray(headerValue)) {
             headerValue.forEach((headerEl, index) => {
               if (typeof headerEl !== "string") {
-                throw new import_js_format8.InvalidArgumentError(
+                throw new import_js_format9.InvalidArgumentError(
                   "Element %d of the header %v must be a String, but %v was given.",
                   index,
                   headerName,
@@ -520,38 +602,50 @@ function createRequestMock(options) {
       });
     }
     if (options.stream !== void 0 && !isReadableStream(options.stream)) {
-      throw new import_js_format8.InvalidArgumentError(
+      throw new import_js_format9.InvalidArgumentError(
         'Option "stream" must be a Stream, but %v was given.',
         options.stream
       );
     }
     if (options.encoding !== void 0) {
       if (typeof options.encoding !== "string") {
-        throw new import_js_format8.InvalidArgumentError(
+        throw new import_js_format9.InvalidArgumentError(
           'Option "encoding" must be a String, but %v was given.',
           options.encoding
         );
       }
       if (!CHARACTER_ENCODING_LIST.includes(options.encoding)) {
-        throw new import_js_format8.InvalidArgumentError(
+        throw new import_js_format9.InvalidArgumentError(
           "Character encoding %v is not supported.",
           options.encoding
         );
       }
     }
-    if (options.stream) {
+    if (options.url !== void 0) {
+      if (options.path !== void 0) {
+        throw new import_js_format9.InvalidArgumentError(
+          'The "url" and "path" options cannot be used together.'
+        );
+      }
+      if (options.query !== void 0) {
+        throw new import_js_format9.InvalidArgumentError(
+          'The "url" and "query" options cannot be used together.'
+        );
+      }
+    }
+    if (options.stream !== void 0) {
       if (options.secure !== void 0) {
-        throw new import_js_format8.InvalidArgumentError(
+        throw new import_js_format9.InvalidArgumentError(
           'The "stream" and "secure" options cannot be used together.'
         );
       }
       if (options.body !== void 0) {
-        throw new import_js_format8.InvalidArgumentError(
+        throw new import_js_format9.InvalidArgumentError(
           'The "stream" and "body" options cannot be used together.'
         );
       }
       if (options.encoding !== void 0) {
-        throw new import_js_format8.InvalidArgumentError(
+        throw new import_js_format9.InvalidArgumentError(
           'The "stream" and "encoding" options cannot be used together.'
         );
       }
@@ -575,11 +669,17 @@ function createRequestMock(options) {
   Object.defineProperty(request.socket, "remoteAddress", { value: "127.0.0.1" });
   Object.defineProperty(request.socket, "localAddress", { value: "127.0.0.1" });
   request.httpVersion = "1.1";
-  request.url = options.url || "/";
+  request.url = "/";
+  if (options.url !== void 0) {
+    request.url = options.url;
+  } else if (options.path !== void 0 || options.query !== void 0) {
+    request.url = createRequestUrl(options.path, options.query);
+  }
   request.headers = createRequestHeaders(
     options.host,
     options.secure,
     options.body,
+    options.cookies,
     options.encoding,
     options.headers
   );
@@ -589,7 +689,7 @@ function createRequestMock(options) {
 __name(createRequestMock, "createRequestMock");
 function createRequestStream(secure, body, encoding) {
   if (encoding !== void 0 && typeof encoding !== "string") {
-    throw new import_js_format8.InvalidArgumentError(
+    throw new import_js_format9.InvalidArgumentError(
       'Parameter "encoding" must be a String, but %v was given.',
       encoding
     );
@@ -613,30 +713,67 @@ function createRequestStream(secure, body, encoding) {
   return request;
 }
 __name(createRequestStream, "createRequestStream");
-function createRequestHeaders(host, secure, body, encoding, headers) {
+function createRequestUrl(path, query) {
+  if (path !== void 0 && typeof path !== "string") {
+    throw new import_js_format9.InvalidArgumentError(
+      'Parameter "path" must be a String, but %v was given.',
+      path
+    );
+  }
+  if (query !== void 0) {
+    if (query === null || typeof query !== "string" && typeof query !== "object" || Array.isArray(query)) {
+      throw new import_js_format9.InvalidArgumentError(
+        'Parameter "query" must be a String or an Object, but %v was given.',
+        query
+      );
+    }
+  }
+  let res = path !== void 0 ? path : "/";
+  if (typeof query === "object") {
+    const qs = import_querystring.default.stringify(query);
+    if (qs) {
+      res += `?${qs}`;
+    }
+  } else if (typeof query === "string" && query !== "" && query !== "?") {
+    res += `?${query.replace(/^\?/, "")}`;
+  }
+  return res;
+}
+__name(createRequestUrl, "createRequestUrl");
+function createRequestHeaders(host, secure, body, cookies, encoding, headers) {
   if (host !== void 0 && typeof host !== "string") {
-    throw new import_js_format8.InvalidArgumentError(
+    throw new import_js_format9.InvalidArgumentError(
       'Parameter "host" must be a non-empty String, but %v was given.',
       host
     );
   }
   host = host || "localhost";
   if (secure !== void 0 && typeof secure !== "boolean") {
-    throw new import_js_format8.InvalidArgumentError(
+    throw new import_js_format9.InvalidArgumentError(
       'Parameter "secure" must be a Boolean, but %v was given.',
       secure
     );
   }
   secure = Boolean(secure);
-  if (headers !== void 0 && typeof headers !== "object" || Array.isArray(headers)) {
-    throw new import_js_format8.InvalidArgumentError(
-      'Parameter "headers" must be an Object, but %v was given.',
-      headers
-    );
+  if (cookies !== void 0) {
+    if (!cookies || typeof cookies !== "object" || Array.isArray(cookies)) {
+      throw new import_js_format9.InvalidArgumentError(
+        'Parameter "cookies" must be an Object, but %v was given.',
+        cookies
+      );
+    }
+  }
+  if (headers !== void 0) {
+    if (!headers || typeof headers !== "object" || Array.isArray(headers)) {
+      throw new import_js_format9.InvalidArgumentError(
+        'Parameter "headers" must be an Object, but %v was given.',
+        headers
+      );
+    }
   }
   headers = headers || {};
   if (encoding !== void 0 && typeof encoding !== "string") {
-    throw new import_js_format8.InvalidArgumentError(
+    throw new import_js_format9.InvalidArgumentError(
       'Parameter "encoding" must be a String, but %v was given.',
       encoding
     );
@@ -652,6 +789,14 @@ function createRequestHeaders(host, secure, body, encoding, headers) {
   if (secure) {
     res["x-forwarded-proto"] = "https";
   }
+  if (typeof cookies === "object" && Object.keys(cookies).length) {
+    if (res["cookie"]) {
+      const existedCookies = parseCookieString(res["cookie"]);
+      res["cookie"] = createCookieString({ ...existedCookies, ...cookies });
+    } else {
+      res["cookie"] = createCookieString(cookies);
+    }
+  }
   if (body != null && !("content-type" in res)) {
     if (typeof body === "string") {
       res["content-type"] = "text/plain";
@@ -785,12 +930,12 @@ function patchBody(response) {
 __name(patchBody, "patchBody");
 
 // src/utils/get-request-pathname.js
-var import_js_format9 = require("@e22m4u/js-format");
+var import_js_format10 = require("@e22m4u/js-format");
 var HOST_RE2 = /^https?:\/\/[^/]+/;
 var QUERY_STRING_RE = /\?.*$/;
 function getRequestPathname(request) {
   if (!request || typeof request !== "object" || Array.isArray(request) || typeof request.url !== "string") {
-    throw new import_js_format9.InvalidArgumentError(
+    throw new import_js_format10.InvalidArgumentError(
       'Parameter "request" must be an instance of IncomingMessage, but %v was given.',
       request
     );
@@ -802,30 +947,6 @@ function getRequestPathname(request) {
 }
 __name(getRequestPathname, "getRequestPathname");
 
-// src/utils/create-cookie-string.js
-var import_js_format10 = require("@e22m4u/js-format");
-function createCookieString(data) {
-  if (!data || typeof data !== "object" || Array.isArray(data)) {
-    throw new import_js_format10.InvalidArgumentError(
-      "Cookie data must be an Object, but %v was given.",
-      data
-    );
-  }
-  let cookies = "";
-  for (const key in data) {
-    if (!Object.prototype.hasOwnProperty.call(data, key)) {
-      continue;
-    }
-    const val = data[key];
-    if (val == null) {
-      continue;
-    }
-    cookies += `${key}=${val}; `;
-  }
-  return cookies.trim();
-}
-__name(createCookieString, "createCookieString");
-
 // src/request-context.js
 var import_js_format11 = require("@e22m4u/js-format");
 var import_js_service2 = require("@e22m4u/js-service");
@@ -2227,7 +2348,7 @@ function parseJsonBody(input) {
 __name(parseJsonBody, "parseJsonBody");
 
 // src/parsers/request-query-parser.js
-var import_querystring = __toESM(require("querystring"), 1);
+var import_querystring2 = __toESM(require("querystring"), 1);
 var _RequestQueryParser = class _RequestQueryParser extends DebuggableService {
   /**
    * Parse
@@ -2238,7 +2359,7 @@ var _RequestQueryParser = class _RequestQueryParser extends DebuggableService {
   parse(request) {
     const debug = this.getDebuggerFor(this.parse);
     const queryStr = request.url.replace(/^[^?]*\??/, "");
-    const query = queryStr ? import_querystring.default.parse(queryStr) : {};
+    const query = queryStr ? import_querystring2.default.parse(queryStr) : {};
     const queryKeys = Object.keys(query);
     if (queryKeys.length) {
       queryKeys.forEach((key) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/js-trie-router",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "HTTP маршрутизатор для Node.js на основе префиксного дерева",
   "author": "Mikhail Evstropov <e22m4u@yandex.ru>",
   "license": "MIT",

package/src/parsers/request-parser.spec.js

@@ -78,7 +78,7 @@ describe('RequestParser', function () {
 
     it('should return the result object with parsed cookies', function () {
       const S = new RequestParser();
-      const req = createRequestMock({headers: {cookie: 'p1=foo; p2=bar;'}});
+      const req = createRequestMock({headers: {cookie: 'p1=foo; p2=bar'}});
       const res = S.parse(req);
       expect(res).to.be.eql({
         query: {},
@@ -86,7 +86,7 @@ describe('RequestParser', function () {
         body: undefined,
         headers: {
           host: 'localhost',
-          cookie: 'p1=foo; p2=bar;',
+          cookie: 'p1=foo; p2=bar',
         },
       });
     });

package/src/parsers/request-query-parser.spec.js

@@ -12,13 +12,13 @@ describe('RequestQueryParser', function () {
 
     it('should return an empty object when the url does not have a query string', function () {
       const parser = new RequestQueryParser();
-      const result = parser.parse({url: `/test`});
+      const result = parser.parse({url: '/test'});
       expect(result).to.be.eql({});
     });
 
     it('should return an empty object when the url has an empty query string', function () {
       const parser = new RequestQueryParser();
-      const result = parser.parse({url: `/test?`});
+      const result = parser.parse({url: '/test?'});
       expect(result).to.be.eql({});
     });
   });

package/src/request-context.spec.js

@@ -139,6 +139,16 @@ describe('RequestContext', function () {
       expect(req.url).to.be.eq('/pathname?foo=bar');
       expect(ctx.path).to.be.eq('/pathname?foo=bar');
     });
+
+    it('should ignore a protocol and host in the request url', function () {
+      const req = createRequestMock({url: 'http://example.com:80/pathname'});
+      const res = createResponseMock();
+      const route = createRouteMock();
+      const cont = new ServiceContainer();
+      const ctx = new RequestContext(cont, req, res, route);
+      expect(req.url).to.be.eq('http://example.com:80/pathname');
+      expect(ctx.path).to.be.eq('/pathname');
+    });
   });
 
   describe('pathname', function () {

package/src/route/route-registry.spec.js

@@ -142,8 +142,8 @@ describe('RouteRegistry', function () {
         handler,
       });
       const res = S.matchRouteByRequest({
-        url: '/foo/baz/bar/qux',
         method: HttpMethod.GET,
+        url: '/foo/baz/bar/qux',
       });
       expect(typeof res).to.be.eq('object');
       expect(res.route).to.be.instanceof(Route);

package/src/trie-router.spec.js

@@ -88,7 +88,7 @@ describe('TrieRouter', function () {
           done();
         },
       });
-      const req = createRequestMock({url: '/test'});
+      const req = createRequestMock({path: '/test'});
       const res = createResponseMock();
       router.handleRequest(req, res);
     });
@@ -103,7 +103,7 @@ describe('TrieRouter', function () {
           done();
         },
       });
-      const req = createRequestMock({url: '/foo-bar'});
+      const req = createRequestMock({path: '/foo-bar'});
       const res = createResponseMock();
       router.handleRequest(req, res);
     });
@@ -118,7 +118,7 @@ describe('TrieRouter', function () {
           done();
         },
       });
-      const req = createRequestMock({url: '?p1=foo&p2=bar'});
+      const req = createRequestMock({query: {p1: 'foo', p2: 'bar'}});
       const res = createResponseMock();
       router.handleRequest(req, res);
     });
@@ -385,7 +385,7 @@ describe('TrieRouter', function () {
         router.addHook(RouterHookType.ON_REQUEST, () => {
           hookCalled = true;
         });
-        const req = createRequestMock({url: '/does-not-exist'});
+        const req = createRequestMock({path: '/does-not-exist'});
         const res = createResponseMock();
         await router.handleRequest(req, res);
         expect(hookCalled).to.be.true;
@@ -1641,7 +1641,7 @@ describe('TrieRouter', function () {
         });
         const req = createRequestMock({
           method: HttpMethod.OPTIONS,
-          url: '/api/resource',
+          path: '/api/resource',
         });
         const res = createResponseMock();
         await router.handleRequest(req, res);
@@ -1662,7 +1662,7 @@ describe('TrieRouter', function () {
         });
         const req = createRequestMock({
           method: HttpMethod.OPTIONS,
-          url: '/api/resource',
+          path: '/api/resource',
         });
         const res = createResponseMock();
         await router.handleRequest(req, res);
@@ -1676,7 +1676,7 @@ describe('TrieRouter', function () {
         const router = new TrieRouter();
         const req = createRequestMock({
           method: HttpMethod.OPTIONS,
-          url: '/unknown',
+          path: '/unknown',
         });
         const res = createResponseMock();
         await router.handleRequest(req, res);

package/src/utils/create-cookie-string.js

@@ -24,5 +24,5 @@ export function createCookieString(data) {
     }
     cookies += `${key}=${val}; `;
   }
-  return cookies.trim();
+  return cookies.trim().replace(/;$/, '');
 }

package/src/utils/create-cookie-string.spec.js

@@ -27,6 +27,6 @@ describe('createCookieString', function () {
   it('should return the cookie string for the given object', function () {
     const data = {foo: 'bar', baz: 'quz'};
     const result = createCookieString(data);
-    expect(result).to.be.eq('foo=bar; baz=quz;');
+    expect(result).to.be.eq('foo=bar; baz=quz');
   });
 });

package/src/utils/create-request-mock.d.ts

@@ -16,6 +16,9 @@ type RequestOptions = {
   method?: string;
   secure?: boolean;
   url?: string;
+  path?: string;
+  query?: string | object;
+  cookies?: object;
   headers?: RequestHeadersInput;
   body?: unknown;
   stream?: Readable;

package/src/utils/create-request-mock.js

@@ -1,8 +1,11 @@
 import {Socket} from 'net';
 import {TLSSocket} from 'tls';
+import queryString from 'querystring';
 import {IncomingMessage} from 'http';
 import {InvalidArgumentError} from '@e22m4u/js-format';
 import {isReadableStream} from './is-readable-stream.js';
+import {parseCookieString} from './parse-cookie-string.js';
+import {createCookieString} from './create-cookie-string.js';
 import {CHARACTER_ENCODING_LIST} from './fetch-request-body.js';
 
 /**
@@ -13,6 +16,9 @@ const SUPPORTED_OPTIONS = [
   'method',
   'secure',
   'url',
+  'path',
+  'query',
+  'cookies',
   'headers',
   'body',
   'stream',
@@ -77,6 +83,74 @@ export function createRequestMock(options) {
         );
       }
     }
+    // options.path
+    if (options.path !== undefined) {
+      if (typeof options.path !== 'string') {
+        throw new InvalidArgumentError(
+          'Option "path" must be a String, but %v was given.',
+          options.path,
+        );
+      }
+      // contain #
+      if (options.path.indexOf('#') !== -1) {
+        throw new InvalidArgumentError(
+          'Option "path" must not contain "#", but %v was given.',
+          options.path,
+        );
+      }
+      // contain ?
+      if (options.path.indexOf('?') !== -1) {
+        throw new InvalidArgumentError(
+          'Option "path" must not contain "?", but %v was given.',
+          options.path,
+        );
+      }
+      // not starting with /
+      if (!options.path.startsWith('/')) {
+        throw new InvalidArgumentError(
+          'Option "path" must start with "/", but %v was given.',
+          options.path,
+        );
+      }
+    }
+    // options.query
+    if (options.query !== undefined) {
+      if (
+        options.query === null ||
+        (typeof options.query !== 'string' &&
+          typeof options.query !== 'object') ||
+        Array.isArray(options.query)
+      ) {
+        throw new InvalidArgumentError(
+          'Option "query" must be a String or an Object, but %v was given.',
+          options.query,
+        );
+      }
+    }
+    // options.cookies
+    if (options.cookies !== undefined) {
+      if (
+        !options.cookies ||
+        typeof options.cookies !== 'object' ||
+        Array.isArray(options.cookies)
+      ) {
+        throw new InvalidArgumentError(
+          'Option "cookies" must be an Object, but %v was given.',
+          options.cookies,
+        );
+      }
+      // options.cookies[k]
+      Object.keys(options.cookies).forEach(cookieName => {
+        const cookieValue = options.cookies[cookieName];
+        if (cookieValue !== undefined && typeof cookieValue !== 'string') {
+          throw new InvalidArgumentError(
+            'Cookie %v must be a String, but %v was given.',
+            cookieName,
+            cookieValue,
+          );
+        }
+      });
+    }
     // options.headers
     if (options.headers !== undefined) {
       if (
@@ -139,9 +213,23 @@ export function createRequestMock(options) {
         );
       }
     }
+    // если определен url, выполняется
+    // проверка на несовместимые опции
+    if (options.url !== undefined) {
+      if (options.path !== undefined) {
+        throw new InvalidArgumentError(
+          'The "url" and "path" options cannot be used together.',
+        );
+      }
+      if (options.query !== undefined) {
+        throw new InvalidArgumentError(
+          'The "url" and "query" options cannot be used together.',
+        );
+      }
+    }
     // если передан поток, выполняется
     // проверка на несовместимые опции
-    if (options.stream) {
+    if (options.stream !== undefined) {
       if (options.secure !== undefined) {
         throw new InvalidArgumentError(
           'The "stream" and "secure" options cannot be used together.',
@@ -184,11 +272,17 @@ export function createRequestMock(options) {
   // определение остальных свойств
   // экземпляра IncomingMessage
   request.httpVersion = '1.1';
-  request.url = options.url || '/';
+  request.url = '/';
+  if (options.url !== undefined) {
+    request.url = options.url;
+  } else if (options.path !== undefined || options.query !== undefined) {
+    request.url = createRequestUrl(options.path, options.query);
+  }
   request.headers = createRequestHeaders(
     options.host,
     options.secure,
     options.body,
+    options.cookies,
     options.encoding,
     options.headers,
   );
@@ -238,17 +332,56 @@ function createRequestStream(secure, body, encoding) {
   return request;
 }
 
+/**
+ * Create request url.
+ *
+ * @param {string|undefined} path
+ * @param {string|object|undefined} query
+ * @returns {string}
+ */
+function createRequestUrl(path, query) {
+  if (path !== undefined && typeof path !== 'string') {
+    throw new InvalidArgumentError(
+      'Parameter "path" must be a String, but %v was given.',
+      path,
+    );
+  }
+  if (query !== undefined) {
+    if (
+      query === null ||
+      (typeof query !== 'string' && typeof query !== 'object') ||
+      Array.isArray(query)
+    ) {
+      throw new InvalidArgumentError(
+        'Parameter "query" must be a String or an Object, but %v was given.',
+        query,
+      );
+    }
+  }
+  let res = path !== undefined ? path : '/';
+  if (typeof query === 'object') {
+    const qs = queryString.stringify(query);
+    if (qs) {
+      res += `?${qs}`;
+    }
+  } else if (typeof query === 'string' && query !== '' && query !== '?') {
+    res += `?${query.replace(/^\?/, '')}`;
+  }
+  return res;
+}
+
 /**
  * Create request headers.
  *
  * @param {string|undefined} host
  * @param {boolean|undefined} secure
  * @param {*} body
+ * @param {object|undefined} cookies
  * @param {string|undefined} encoding
  * @param {object|undefined} headers
  * @returns {object}
  */
-function createRequestHeaders(host, secure, body, encoding, headers) {
+function createRequestHeaders(host, secure, body, cookies, encoding, headers) {
   if (host !== undefined && typeof host !== 'string') {
     throw new InvalidArgumentError(
       'Parameter "host" must be a non-empty String, but %v was given.',
@@ -263,14 +396,21 @@ function createRequestHeaders(host, secure, body, encoding, headers) {
     );
   }
   secure = Boolean(secure);
-  if (
-    (headers !== undefined && typeof headers !== 'object') ||
-    Array.isArray(headers)
-  ) {
-    throw new InvalidArgumentError(
-      'Parameter "headers" must be an Object, but %v was given.',
-      headers,
-    );
+  if (cookies !== undefined) {
+    if (!cookies || typeof cookies !== 'object' || Array.isArray(cookies)) {
+      throw new InvalidArgumentError(
+        'Parameter "cookies" must be an Object, but %v was given.',
+        cookies,
+      );
+    }
+  }
+  if (headers !== undefined) {
+    if (!headers || typeof headers !== 'object' || Array.isArray(headers)) {
+      throw new InvalidArgumentError(
+        'Parameter "headers" must be an Object, but %v was given.',
+        headers,
+      );
+    }
   }
   headers = headers || {};
   if (encoding !== undefined && typeof encoding !== 'string') {
@@ -290,6 +430,17 @@ function createRequestHeaders(host, secure, body, encoding, headers) {
   if (secure) {
     res['x-forwarded-proto'] = 'https';
   }
+  // формирование заголовка Cookie используя
+  // существующие данные заголовка и объекта,
+  // переданного в параметр данной функции
+  if (typeof cookies === 'object' && Object.keys(cookies).length) {
+    if (res['cookie']) {
+      const existedCookies = parseCookieString(res['cookie']);
+      res['cookie'] = createCookieString({...existedCookies, ...cookies});
+    } else {
+      res['cookie'] = createCookieString(cookies);
+    }
+  }
   // установка заголовка "content-type"
   // в зависимости от тела запроса
   if (body != null && !('content-type' in res)) {

package/src/utils/create-request-mock.spec.js

@@ -88,19 +88,121 @@ describe('createRequestMock', function () {
     throwable(undefined)();
   });
 
-  it('should require the option "url" to not contain "#" symbol', function () {
+  it('should require the option "url" to not contain "#"', function () {
     const throwable = v => () => createRequestMock({url: v});
-    const mustThrowFor = v => {
+    const mustThrowWith = v => {
       expect(throwable(v)).to.throw(
         format('Option "url" must not contain "#", but %v was given.', v),
       );
     };
-    mustThrowFor('#');
-    mustThrowFor('pathname#');
-    mustThrowFor('/pathname#');
-    mustThrowFor('http://example.com/#');
-    mustThrowFor('http://example.com/pathname#');
-    mustThrowFor('http://example.com/pathname?foo=bar#');
+    mustThrowWith('#');
+    mustThrowWith('pathname#');
+    mustThrowWith('/pathname#');
+    mustThrowWith('http://example.com/#');
+    mustThrowWith('http://example.com/pathname#');
+    mustThrowWith('http://example.com/pathname?foo=bar#');
+  });
+
+  it('should require the option "path" to be a String', function () {
+    const throwable = v => () => createRequestMock({path: v});
+    const error = v =>
+      format('Option "path" must be a String, but %s was given.', v);
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable(null)).to.throw(error('null'));
+    throwable('/path')();
+    throwable('/')();
+    throwable(undefined)();
+  });
+
+  it('should require the option "path" to not contain "#"', function () {
+    const throwable = v => () => createRequestMock({path: v});
+    const mustThrowWith = v => {
+      expect(throwable(v)).to.throw(
+        format('Option "path" must not contain "#", but %v was given.', v),
+      );
+    };
+    mustThrowWith('/#');
+    mustThrowWith('/path#');
+  });
+
+  it('should require the option "path" to not contain "?"', function () {
+    const throwable = v => () => createRequestMock({path: v});
+    const mustThrowWith = v => {
+      expect(throwable(v)).to.throw(
+        format('Option "path" must not contain "?", but %v was given.', v),
+      );
+    };
+    mustThrowWith('/?');
+    mustThrowWith('/path?');
+  });
+
+  it('should require the option "path" to start with "/"', function () {
+    const throwable = v => () => createRequestMock({path: v});
+    const mustThrowWith = v => {
+      expect(throwable(v)).to.throw(
+        format('Option "path" must start with "/", but %v was given.', v),
+      );
+    };
+    mustThrowWith('path');
+    mustThrowWith('');
+  });
+
+  it('should require the option "query" to be a String or an Object', function () {
+    const throwable = v => () => createRequestMock({query: v});
+    const error = v =>
+      format(
+        'Option "query" must be a String or an Object, but %s was given.',
+        v,
+      );
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(null)).to.throw(error('null'));
+    throwable({foo: 'bar'})();
+    throwable({})();
+    throwable('foo=bar')();
+    throwable('')();
+    throwable(undefined)();
+  });
+
+  it('should require the option "cookies" to be an Object', function () {
+    const throwable = v => () => createRequestMock({cookies: v});
+    const error = v =>
+      format('Option "cookies" must be an Object, but %s was given.', v);
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(null)).to.throw(error('null'));
+    throwable({foo: 'bar'})();
+    throwable({})();
+    throwable(undefined)();
+  });
+
+  it('should require values in the option "cookies" to be a String', function () {
+    const throwable = v => () => createRequestMock({cookies: {test: v}});
+    const error = v =>
+      format('Cookie "test" must be a String, but %s was given.', v);
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable(null)).to.throw(error('null'));
+    throwable('str')();
+    throwable('')();
+    throwable(undefined)();
   });
 
   it('should require the option "headers" to be an Object', function () {
@@ -120,7 +222,7 @@ describe('createRequestMock', function () {
     throwable(undefined)();
   });
 
-  it('should require values of the option "headers" to be a String or an Array', function () {
+  it('should require values in the option "headers" to be a String or an Array', function () {
     const throwable = v => () => createRequestMock({headers: {Test: v}});
     const error = v =>
       format(
@@ -196,6 +298,18 @@ describe('createRequestMock', function () {
     expect(throwable).to.throw('Option "unknownOption" is not supported.');
   });
 
+  it('should not allow using the "url" and "path" options together', function () {
+    const throwable = () => createRequestMock({url: 'url', path: '/path'});
+    const error = 'The "url" and "path" options cannot be used together.';
+    expect(throwable).to.throw(error);
+  });
+
+  it('should not allow using the "url" and "query" options together', function () {
+    const throwable = () => createRequestMock({url: 'url', query: {p: 1}});
+    const error = 'The "url" and "query" options cannot be used together.';
+    expect(throwable).to.throw(error);
+  });
+
   it('should require the option "encoding" to be a correct value', function () {
     const throwable = v => () => createRequestMock({encoding: v});
     const error = v => format('Character encoding %s is not supported.', v);
@@ -232,11 +346,6 @@ describe('createRequestMock', function () {
     throwable(undefined)();
   });
 
-  it('should use "localhost" as the default host', function () {
-    const req = createRequestMock();
-    expect(req.headers['host']).to.be.eq('localhost');
-  });
-
   it('should use "GET" as the default method', function () {
     const req = createRequestMock();
     expect(req.method).to.be.eq('GET');
@@ -247,17 +356,17 @@ describe('createRequestMock', function () {
     expect(req.socket).to.be.instanceof(Socket);
   });
 
-  it('should use the default path "/" without a query string', function () {
+  it('should use "/" as the default value of the request url', function () {
     const req = createRequestMock();
     expect(req.url).to.be.eq('/');
   });
 
-  it('should use "localhost" as the default value for the "host" header', function () {
+  it('should use "localhost" as the default value of the "host" header', function () {
     const req = createRequestMock();
     expect(req.headers).to.be.eql({host: 'localhost'});
   });
 
-  it('should use "utf-8" encoding by default', async function () {
+  it('should use "utf-8" as the default value of the data encoding', async function () {
     const body = 'test';
     const req = createRequestMock({body: Buffer.from(body)});
     const chunks = [];
@@ -327,7 +436,43 @@ describe('createRequestMock', function () {
     expect(data).to.be.eq(body);
   });
 
-  it('should stringify and pass an Object body to the stream', async function () {
+  it('should pass a number from the "body" option to the stream as a string', async function () {
+    const body = 10;
+    const req = createRequestMock({body});
+    const chunks = [];
+    const data = await new Promise((resolve, reject) => {
+      req.on('data', chunk => chunks.push(Buffer.from(chunk)));
+      req.on('error', err => reject(err));
+      req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+    });
+    expect(data).to.be.eq('10');
+  });
+
+  it('should pass a boolean from the "body" option to the stream as a string', async function () {
+    const body = true;
+    const req = createRequestMock({body});
+    const chunks = [];
+    const data = await new Promise((resolve, reject) => {
+      req.on('data', chunk => chunks.push(Buffer.from(chunk)));
+      req.on('error', err => reject(err));
+      req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+    });
+    expect(data).to.be.eq('true');
+  });
+
+  it('should pass an array from the "body" option to the stream as JSON', async function () {
+    const body = [1, 2];
+    const req = createRequestMock({body});
+    const chunks = [];
+    const data = await new Promise((resolve, reject) => {
+      req.on('data', chunk => chunks.push(Buffer.from(chunk)));
+      req.on('error', err => reject(err));
+      req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+    });
+    expect(data).to.be.eq(JSON.stringify(body));
+  });
+
+  it('should pass an object from the "body" option to the stream as JSON', async function () {
     const body = {foo: 'bar'};
     const req = createRequestMock({body});
     const chunks = [];
@@ -339,7 +484,7 @@ describe('createRequestMock', function () {
     expect(data).to.be.eq(JSON.stringify(body));
   });
 
-  it('should pass a binary data to the stream', async function () {
+  it('should pass a Buffer from the "body" option to the stream', async function () {
     const body = Buffer.from('test');
     const req = createRequestMock({body});
     const chunks = [];
@@ -351,12 +496,38 @@ describe('createRequestMock', function () {
     expect(data).to.be.eql(body);
   });
 
-  it('should set the "url" option to the request url', function () {
+  it('should pass a value form the "url" option to the request url', function () {
     const req = createRequestMock({url: '/test'});
     expect(req.url).to.be.eq('/test');
   });
 
-  it('should set the property "method" in upper case', async function () {
+  it('should pass a value form the "path" option to the request url', function () {
+    const req = createRequestMock({path: '/test'});
+    expect(req.url).to.be.eq('/test');
+  });
+
+  it('should pass a string form the "query" option to the request url', async function () {
+    const req1 = createRequestMock({query: 'p1=foo&p2=bar'});
+    const req2 = createRequestMock({query: '?p1=foo&p2=bar'});
+    expect(req1.url).to.be.eq('/?p1=foo&p2=bar');
+    expect(req2.url).to.be.eq('/?p1=foo&p2=bar');
+  });
+
+  it('should pass an object form the "query" option to the request url', async function () {
+    const req = createRequestMock({query: {foo: 'bar', baz: 'qux'}});
+    expect(req.url).to.be.eq('/?foo=bar&baz=qux');
+  });
+
+  it('should combine the "path" and "query" options in the request url', function () {
+    const req1 = createRequestMock({path: '/test', query: 'foo=bar'});
+    const req2 = createRequestMock({path: '/test', query: '?foo=bar'});
+    const req3 = createRequestMock({path: '/test', query: {foo: 'bar'}});
+    expect(req1.url).to.be.eq('/test?foo=bar');
+    expect(req2.url).to.be.eq('/test?foo=bar');
+    expect(req3.url).to.be.eq('/test?foo=bar');
+  });
+
+  it('should set a value from the "method" option to the request method in upper case', async function () {
     const req1 = createRequestMock({method: 'get'});
     const req2 = createRequestMock({method: 'post'});
     expect(req1.method).to.be.eq('GET');
@@ -374,6 +545,19 @@ describe('createRequestMock', function () {
     expect(req.headers['x-forwarded-proto']).to.be.eq('https');
   });
 
+  it('should serialize and set a value from the "cookies" option to the "cookie" header', function () {
+    const req = createRequestMock({cookies: {p1: 'foo', p2: 'bar'}});
+    expect(req.headers['cookie']).to.be.eq('p1=foo; p2=bar');
+  });
+
+  it('should merge the "cookie" header with the "cookies" option', function () {
+    const req = createRequestMock({
+      headers: {cookie: 'p1=foo; p2=bar'},
+      cookies: {p2: 'baz', p3: 'qux'},
+    });
+    expect(req.headers['cookie']).to.be.eq('p1=foo; p2=baz; p3=qux');
+  });
+
   it('should set the "content-type" header for a String body', function () {
     const req = createRequestMock({body: 'test'});
     expect(req.headers['content-type']).to.be.eq('text/plain');