@leyyo/http-mock 1.1.1 → 1.2.1

package/dist/response/mock-response.d.ts

@@ -1,119 +1,113 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { Application, CookieOptions, Errback, Request, Response } from "express";
-import { RecLike, OneOrMore, FuncLike, Key } from "@leyyo/core";
-import { OutgoingHttpHeader, OutgoingHttpHeaders } from "http";
-import { Socket } from "net";
-import { MockResponseLike, MockResponseResolve, ResponseData, ResponseErrorCallback } from "./index-types";
-export declare class MockResponse<D = ResponseData, L extends RecLike = RecLike> implements MockResponseLike<D, L>, RecLike {
+import type { Application, CookieOptions, Errback, Request, Response } from "express";
+import type { Socket } from "net";
+import type { MockResponseLike, MockResponseResolve, ResponseData, ResponseErrorCallback, ResponseLocal } from "./index-types";
+import type { Dict, KeyValue, OneOrMore } from "@leyyo/common";
+import { HttpEvent, type HttpStatus } from "../shared";
+import type { OutgoingHttpHeader, OutgoingHttpHeaders } from "node:http";
+export declare class MockResponse<R extends ResponseData, L extends ResponseLocal = ResponseLocal> extends HttpEvent<Response> implements MockResponseLike<R, L> {
     private _headersSent;
-    readonly isFake: boolean;
-    [key: string]: unknown;
     private readonly _resolver;
-    readonly app: Application;
-    readonly locals: L;
-    sendDate: boolean;
-    statusMessage: string;
     private _headers;
     private _cookies;
     private _clearedCookies;
     private _data;
     private _status;
-    charset: string;
-    chunkedEncoding: boolean;
+    readonly locals: L;
+    readonly isFake: boolean;
+    [another: string]: unknown;
+    static setFirstOrigin(origin: Response): void;
+    static get firstOrigin(): Response;
+    constructor(resolver: MockResponseResolve<R>, origin?: Response);
+    private _send;
+    private _setHeader;
+    private _setCookie;
+    private _cancelCookieClear;
+    private _clear;
     destroyed: boolean;
-    readonly connection: Socket | null;
-    finished: boolean;
-    readonly req: Request;
-    useChunkedEncodingByDefault: boolean;
+    closed: boolean;
+    errored: Error;
     readonly writable: boolean;
+    readonly writableAborted: boolean;
     readonly writableCorked: number;
     readonly writableEnded: boolean;
     readonly writableFinished: boolean;
     readonly writableHighWaterMark: number;
     readonly writableLength: number;
     readonly writableObjectMode: boolean;
-    shouldKeepAlive: boolean;
-    readonly socket: Socket | null;
-    statusCode: number;
-    writeHead: ((statusCode: number, statusMessage?: string, headers?: (OutgoingHttpHeaders | OutgoingHttpHeader[])) => this) & ((statusCode: number, headers?: (OutgoingHttpHeaders | OutgoingHttpHeader[])) => this);
-    closed: boolean;
-    errored: Error;
     writableNeedDrain: boolean;
-    constructor(resolver: MockResponseResolve, origin?: Response);
-    private _send;
-    private _setHeader;
-    private _setCookie;
-    private _cancelCookieClear;
-    private _clear;
-    _construct(callback?: ResponseErrorCallback): void;
-    _destroy(error: Error | null, callback: ResponseErrorCallback): void;
-    _final(callback: ResponseErrorCallback): void;
-    _write(chunk: unknown, encoding: BufferEncoding, callback: ResponseErrorCallback): void;
-    _writev(chunks: Array<{
+    _construct(_c?: ResponseErrorCallback): void;
+    _destroy(_e: Error | null, _c: ResponseErrorCallback): void;
+    _final(_c: ResponseErrorCallback): void;
+    _write(_c: unknown, _e: BufferEncoding, _r: ResponseErrorCallback): void;
+    _writev(_c: Array<{
         chunk: unknown;
         encoding: BufferEncoding;
-    }>, callback: ResponseErrorCallback): void;
-    addTrailers(headers: OutgoingHttpHeaders | Array<[string, string]>): void;
-    assignSocket(socket: Socket): void;
-    get headersSent(): boolean;
+    }>, _b: ResponseErrorCallback): void;
     cork(): void;
-    destroy(error: Error | undefined): this;
-    detachSocket(socket: Socket): void;
+    destroy(_e: Error | undefined): this;
+    pipe<T extends NodeJS.WritableStream>(_d: T, _o: {
+        end?: boolean | undefined;
+    } | undefined): T;
+    setDefaultEncoding(_e: BufferEncoding): this;
+    uncork(): void;
+    end(): this;
+    write(_b: Uint8Array | string, _c?: ResponseErrorCallback | BufferEncoding, _d?: ResponseErrorCallback): boolean;
+    compose<T>(_s: ComposeFnParam | Iterable<T> | AsyncIterable<T> | T, _o: {
+        signal: AbortSignal;
+    } | undefined): T;
+    sendDate: boolean;
+    statusMessage: string;
+    chunkedEncoding: boolean;
+    shouldKeepAlive: boolean;
+    finished: boolean;
+    get connection(): Socket;
+    useChunkedEncodingByDefault: boolean;
+    readonly socket: Socket | null;
+    statusCode: number;
+    writeHead: ((statusCode: number, statusMessage?: string, headers?: (OutgoingHttpHeaders | OutgoingHttpHeader[])) => this) & ((statusCode: number, headers?: (OutgoingHttpHeaders | OutgoingHttpHeader[])) => this);
+    strictContentLength: boolean;
+    addTrailers(_h: OutgoingHttpHeaders | Array<[string, string]>): void;
+    assignSocket(_s: Socket): void;
+    detachSocket(_s: Socket): void;
     flushHeaders(): void;
     getHeader(name: string): number | string | string[] | undefined;
     getHeaderNames(): string[];
     getHeaders(): OutgoingHttpHeaders;
     hasHeader(name: string): boolean;
-    json(data: D): this;
-    jsonp(data: D): this;
-    pipe<T>(destination: T, options: {
-        end?: boolean | undefined;
-    } | undefined): T;
     removeHeader(name: string): void;
-    send(body?: unknown): this;
-    setDefaultEncoding(encoding: BufferEncoding): this;
     setHeader(name: string, value: number | string | ReadonlyArray<string>): this;
-    setTimeout(msecs: number, callback: (() => void) | undefined): this;
-    uncork(): void;
-    writeContinue(callback: (() => void) | undefined): void;
+    setTimeout(_m: number, _c: (() => void) | undefined): this;
+    writeContinue(_c: (() => void) | undefined): void;
     writeProcessing(): void;
-    addListener(eventName: string | symbol, listener: FuncLike): this;
-    append(key: string, value?: OneOrMore<string>): this;
+    appendHeader(name: string, value: string | readonly string[]): this;
+    setHeaders(headers: Headers | Map<string, number | string | readonly string[]>): this;
+    writeEarlyHints(_h: Record<string, string | string[]>, _c: (() => void) | undefined): void;
+    readonly app: Application;
+    charset: string;
+    readonly req: Request;
+    get headersSent(): boolean;
+    json(data: R): this;
+    jsonp(data: R): this;
+    send(body?: unknown): this;
     attachment(filename?: string): this;
     clearCookie(name: string, options?: CookieOptions): this;
+    append(key: string, value?: OneOrMore<string>): this;
     contentType(type: string): this;
     cookie(key: string, value: unknown, option?: CookieOptions): this;
-    download(path: string, fn?: Errback | string, err?: unknown, errBack?: Errback): void;
-    emit(eventName: string | symbol, ...args: unknown[]): boolean;
-    end(): this;
-    eventNames(): Array<string | symbol>;
+    download(path: string, _fn?: Errback | string, _err?: unknown, _errBack?: Errback): void;
     format(obj: unknown): this;
     get(field: string): string;
-    getMaxListeners(): number;
     header(field: unknown, value?: OneOrMore<string>): this;
     links(map: unknown): this;
-    listenerCount(eventName: string | symbol): number;
-    listeners(eventName: string | symbol): Array<FuncLike>;
     location(url: string): this;
-    off(eventName: string | symbol, listener: FuncLike): this;
-    on(eventName: string | symbol, listener: FuncLike): this;
-    once(eventName: string | symbol, listener: FuncLike): this;
-    prependListener(eventName: string | symbol, listener: FuncLike): this;
-    prependOnceListener(eventName: string | symbol, listener: FuncLike): this;
-    rawListeners(eventName: string | symbol): Function[];
-    redirect(url: Key, status?: Key): void;
-    removeAllListeners(event?: string | symbol): this;
-    removeListener(eventName: string | symbol, listener: FuncLike): this;
-    render(view: string, options?: RecLike | ((err: Error, html: string) => void), callback?: (err: Error, html: string) => void): void;
-    sendFile(path: string, fn?: unknown, err?: Errback): void;
+    redirect(url: KeyValue, status?: KeyValue): void;
+    render(_v: string, _o?: Dict | ((err: Error, html: string) => void), _c?: (err: Error, html: string) => void): void;
+    sendFile(path: string, _fn?: unknown, _err?: Errback): void;
     sendStatus(status: number): this;
-    sendfile(path: string, options?: unknown, fn?: Errback): void;
     set(field: unknown, value?: string | string[]): this;
-    setMaxListeners(n: number): this;
-    status(status: number): this;
+    status(status: HttpStatus): this;
     type(type: string): this;
     vary(field: string): this;
-    write(buffer: Uint8Array | string, cb?: ResponseErrorCallback | BufferEncoding, cb2?: ResponseErrorCallback): boolean;
 }
+type ComposeFnParam = (source: any) => void;
+export {};

package/dist/response/mock-response.js

@@ -1,43 +1,71 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockResponse = void 0;
-const core_1 = require("@leyyo/core");
-const mime_1 = __importDefault(require("mime"));
-const fqn_1 = require("@leyyo/fqn");
-const internal_component_1 = require("../internal-component");
-const application_1 = require("../application");
-// noinspection JSUnusedGlobalSymbols
-let MockResponse = class MockResponse {
+const mime = __importStar(require("mime-types"));
+const common_1 = require("@leyyo/common");
+const shared_1 = require("../shared");
+let _firstOrigin;
+class MockResponse extends shared_1.HttpEvent {
+    // endregion property
+    // region static
+    // noinspection JSUnusedGlobalSymbols
+    static setFirstOrigin(origin) {
+        if (!_firstOrigin && origin) {
+            _firstOrigin = origin;
+        }
+    }
+    static get firstOrigin() {
+        return _firstOrigin;
+    }
+    // endregion static
+    // region constructor
     constructor(resolver, origin) {
+        var _a;
+        super(origin);
         if (typeof resolver != "function") {
-            resolver = (dto => {
-                (0, core_1.emptyFn)();
+            resolver = (() => {
             });
         }
         this._resolver = resolver;
         this.isFake = true;
-        if (!(origin === null || origin === void 0 ? void 0 : origin.app)) {
-            this.app = new application_1.MockApplication();
-        }
-        else {
-            this.app = origin.app;
-        }
-        this.locals = (core_1.leyyo.is.object(origin.locals) ? Object.assign({}, origin.locals) : {});
         this._headersSent = false;
+        this.locals = ((_a = origin === null || origin === void 0 ? void 0 : origin.locals) !== null && _a !== void 0 ? _a : {});
         this._clear();
     }
+    // endregion constructor
     // region private
     _send(data) {
         if (!this._headersSent) {
@@ -52,7 +80,6 @@ let MockResponse = class MockResponse {
                 cookies: this._cookies,
                 clearedCookies: this._clearedCookies,
                 data: this._data,
-                locals: this.locals,
             });
         }
         return this;
@@ -80,38 +107,61 @@ let MockResponse = class MockResponse {
         this._data = undefined;
         this._status = 200;
     }
-    _construct(callback) {
-        (0, core_1.emptyFn)();
+    _construct(_c) {
+        logger.warn('Should not be called', { fn: '_construct' });
     }
-    _destroy(error, callback) {
-        (0, core_1.emptyFn)();
+    _destroy(_e, _c) {
+        logger.warn('Should not be called', { fn: '_destroy' });
     }
-    _final(callback) {
-        (0, core_1.emptyFn)();
+    _final(_c) {
+        logger.warn('Should not be called', { fn: '_final' });
     }
-    _write(chunk, encoding, callback) {
-        (0, core_1.emptyFn)();
+    _write(_c, _e, _r) {
+        logger.warn('Should not be called', { fn: '_write' });
     }
-    _writev(chunks, callback) {
-        (0, core_1.emptyFn)();
+    _writev(_c, _b) {
+        logger.warn('Should not be called', { fn: '_writev' });
     }
-    addTrailers(headers) {
-        (0, core_1.emptyFn)();
+    cork() {
+        logger.warn('Should not be called', { fn: 'cork' });
     }
-    assignSocket(socket) {
-        (0, core_1.emptyFn)();
+    destroy(_e) {
+        logger.warn('Should not be called', { fn: 'destroy' });
+        return this;
     }
-    get headersSent() {
-        return this._headersSent;
+    pipe(_d, _o) {
+        logger.warn('Should not be called', { fn: 'pipe' });
+        return undefined;
     }
-    cork() {
-        (0, core_1.emptyFn)();
+    setDefaultEncoding(_e) {
+        logger.warn('Should not be called', { fn: 'setDefaultEncoding' });
+        return this;
     }
-    destroy(error) {
+    uncork() {
+        logger.warn('Should not be called', { fn: 'uncork' });
+    }
+    end() {
+        this._clear();
+        this._send();
         return this;
     }
-    detachSocket(socket) {
-        (0, core_1.emptyFn)();
+    write(_b, _c, _d) {
+        logger.warn('Should not be called', { fn: 'write' });
+        return false;
+    }
+    compose(_s, _o) {
+        logger.warn('Should not be called', { fn: 'compose' });
+        return undefined;
+    }
+    get connection() { return this.socket; }
+    addTrailers(_h) {
+        logger.warn('Should not be called', { fn: 'addTrailers' });
+    }
+    assignSocket(_s) {
+        logger.warn('Should not be called', { fn: 'assignSocket' });
+    }
+    detachSocket(_s) {
+        logger.warn('Should not be called', { fn: 'detachSocket' });
     }
     flushHeaders() {
         this._headers = {};
@@ -120,57 +170,81 @@ let MockResponse = class MockResponse {
         return this.get(name);
     }
     getHeaderNames() {
-        return [];
+        return Object.keys(this._headers);
     }
     getHeaders() {
-        return {};
+        return this._headers;
     }
     hasHeader(name) {
-        return false;
-    }
-    json(data) {
-        this._setHeader('Content-Type', 'application/json');
-        this._send(data);
-        return this;
-    }
-    jsonp(data) {
-        this._setHeader('Content-Type', 'application/json');
-        this._send(data);
-        return this;
-    }
-    pipe(destination, options) {
-        return destination;
+        return this._headers[name] !== undefined;
     }
     removeHeader(name) {
-        (0, core_1.emptyFn)();
+        if (this._headers[name] !== undefined) {
+            delete this._headers[name];
+        }
     }
-    send(body) {
-        this._send(body);
+    setHeader(name, value) {
+        this._headers[name] = value;
         return this;
     }
-    setDefaultEncoding(encoding) {
+    setTimeout(_m, _c) {
+        logger.warn('Should not be called', { fn: 'setTimeout' });
         return this;
     }
-    setHeader(name, value) {
+    writeContinue(_c) {
+        logger.warn('Should not be called', { fn: 'writeContinue' });
+    }
+    writeProcessing() {
+        logger.warn('Should not be called', { fn: 'writeProcessing' });
+    }
+    appendHeader(name, value) {
+        if (this._headers[name] === undefined) {
+            this._headers[name] = [];
+        }
+        else if (!Array.isArray(this._headers[name])) {
+            this._headers[name] = [this._headers[name]];
+        }
+        if (Array.isArray(value)) {
+            this._headers[name].push(...value);
+        }
+        else {
+            this._headers[name].push(value);
+        }
         return this;
     }
-    setTimeout(msecs, callback) {
+    setHeaders(headers) {
+        this._headers = {};
+        if (headers instanceof Map) {
+            for (const [k, v] of headers.entries()) {
+                this._headers[k] = v;
+            }
+        }
+        else {
+            for (const [k, v] of Object.entries(headers)) {
+                this._headers[k] = v;
+            }
+        }
         return this;
     }
-    uncork() {
-        (0, core_1.emptyFn)();
+    writeEarlyHints(_h, _c) {
+        logger.warn('Should not be called', { fn: 'writeEarlyHints' });
     }
-    writeContinue(callback) {
-        (0, core_1.emptyFn)();
+    get headersSent() {
+        return this._headersSent;
     }
-    writeProcessing() {
-        (0, core_1.emptyFn)();
+    json(data) {
+        this._setHeader('Content-Type', 'application/json');
+        this._send(data);
+        return this;
     }
-    addListener(eventName, listener) {
-        return undefined;
+    jsonp(data) {
+        this._setHeader('Content-Type', 'application/json');
+        this._send(data);
+        return this;
     }
-    append(key, value) {
-        return this._setHeader(key, value);
+    send(body) {
+        this._send(body);
+        return this;
     }
     attachment(filename) {
         filename = filename ? `; filename="${filename}"` : '';
@@ -180,6 +254,9 @@ let MockResponse = class MockResponse {
         this._clearedCookies[name] = options;
         return this;
     }
+    append(key, value) {
+        return this._setHeader(key, value);
+    }
     contentType(type) {
         return this.type(type);
     }
@@ -188,7 +265,7 @@ let MockResponse = class MockResponse {
             this._cancelCookieClear(key);
             return this._setCookie(key, value, option);
         }
-        if (core_1.leyyo.is.object(key)) {
+        if (key) {
             for (const [k, v] of Object.entries(key)) {
                 this._cancelCookieClear(k);
                 this._setCookie(k, v, value !== null && value !== void 0 ? value : option);
@@ -196,35 +273,21 @@ let MockResponse = class MockResponse {
         }
         return this;
     }
-    download(path, fn, err, errBack) {
-        LOG.warn('unsupported.feature', { fn: 'download', path });
-    }
-    emit(eventName, ...args) {
-        return false;
-    }
-    end() {
-        this._clear();
-        this._send();
-        return this;
-    }
-    eventNames() {
-        return [];
+    download(path, _fn, _err, _errBack) {
+        logger.warn('unsupported.feature', { fn: 'download', path });
     }
     format(obj) {
-        LOG.warn('unsupported.feature', { fn: 'format', obj });
+        logger.warn('unsupported.feature', { fn: 'format', obj });
         return this;
     }
     get(field) {
         return (typeof field === 'string') ? this._headers[field] : undefined;
     }
-    getMaxListeners() {
-        return 0;
-    }
     header(field, value) {
         return this._setHeader(field, value);
     }
     links(map) {
-        if (core_1.leyyo.is.object(map)) {
+        if (map) {
             const values = [];
             for (const [k, v] of Object.entries(map)) {
                 values.push(`<${v}>; rel="${k}"`);
@@ -235,71 +298,35 @@ let MockResponse = class MockResponse {
         }
         return this;
     }
-    listenerCount(eventName) {
-        return 0;
-    }
-    listeners(eventName) {
-        return [];
-    }
     location(url) {
-        LOG.warn('unsupported.feature', { fn: 'location', url });
-        return this;
-    }
-    off(eventName, listener) {
-        return this;
-    }
-    on(eventName, listener) {
-        return this;
-    }
-    once(eventName, listener) {
-        return this;
-    }
-    prependListener(eventName, listener) {
-        return this;
-    }
-    prependOnceListener(eventName, listener) {
+        logger.warn('unsupported.feature', { fn: 'location', url });
         return this;
     }
-    rawListeners(eventName) {
-        return [];
-    }
     redirect(url, status) {
-        LOG.warn('unsupported.feature', { fn: 'redirect', url, status });
+        logger.warn('unsupported.feature', { fn: 'redirect', url, status });
     }
-    removeAllListeners(event) {
-        return this;
-    }
-    removeListener(eventName, listener) {
-        return this;
+    render(_v, _o, _c) {
+        logger.warn('unsupported.feature', { fn: 'render' });
     }
-    render(view, options, callback) {
-        LOG.warn('unsupported.feature', { fn: 'render' });
-    }
-    sendFile(path, fn, err) {
-        LOG.warn('unsupported.feature', { fn: 'sendFile', path });
+    sendFile(path, _fn, _err) {
+        logger.warn('unsupported.feature', { fn: 'sendFile', path });
     }
     sendStatus(status) {
         this._status = status;
         this._send();
         return this;
     }
-    sendfile(path, options, fn) {
-        LOG.warn('unsupported.feature', { fn: 'render' });
-    }
     set(field, value) {
         if (typeof field === 'string') {
             return this._setHeader(field, value);
         }
-        if (core_1.leyyo.is.object(field)) {
+        if (field) {
             for (const [k, v] of Object.entries(field)) {
                 this._setHeader(k, v);
             }
         }
         return this;
     }
-    setMaxListeners(n) {
-        return this;
-    }
     status(status) {
         this._status = status;
         return this;
@@ -310,7 +337,7 @@ let MockResponse = class MockResponse {
                 this.header('Content-Type', type);
             }
             else {
-                this.header('Content-Type', mime_1.default.getType(type));
+                this.header('Content-Type', mime.lookup(type));
             }
         }
         return this;
@@ -319,14 +346,7 @@ let MockResponse = class MockResponse {
         this.header('Vary', field);
         return this;
     }
-    write(buffer, cb, cb2) {
-        return false;
-    }
-};
-MockResponse = __decorate([
-    (0, fqn_1.Fqn)(...internal_component_1.FQN_NAME),
-    __metadata("design:paramtypes", [Function, Object])
-], MockResponse);
+}
 exports.MockResponse = MockResponse;
-const LOG = core_1.logger.assign(MockResponse);
+const logger = common_1.$log.create(MockResponse);
 //# sourceMappingURL=mock-response.js.map