gingersnap 0.22.0

package/mocks.cjs

@@ -0,0 +1,301 @@
+'use strict';
+
+var _tslib = require('./_virtual/_tslib.cjs');
+var AbortError = require('./errors/AbortError.cjs');
+var VerificationError = require('./errors/VerificationError.cjs');
+require('./data/model/model.cjs');
+require('ramda');
+require('./data/model/types.cjs');
+require('./data/model/credentials.cjs');
+require('./networking/types.cjs');
+require('./stream.cjs');
+var future = require('./future/future.cjs');
+require('./networking/decorators/options.cjs');
+require('./networking/decorators/requests.cjs');
+var http = require('./networking/http.cjs');
+require('uuid');
+require('object-hash');
+require('./data/store/manager.cjs');
+require('./data-structures/object/WatchableObject.cjs');
+require('modern-isomorphic-ws');
+require('@msgpack/msgpack');
+
+/**
+ * Tracks specific details that should be used to match specific given network request
+ */
+class RequestDetails {
+    constructor() {
+        this.headers = {};
+        this.queries = {};
+    }
+    withMethod(method) {
+        this.method = method;
+        return this;
+    }
+    withPath(path) {
+        this.path = path;
+        return this;
+    }
+    withHeader(key, value) {
+        this.headers[key] = value;
+        return this;
+    }
+    withHeaders(value) {
+        this.headers = value;
+        return this;
+    }
+    withQuery(key, value) {
+        this.queries[key] = value;
+        return this;
+    }
+    withQueries(value) {
+        this.queries = value;
+        return this;
+    }
+    withBody(value) {
+        this.body = value;
+        return this;
+    }
+}
+class ResponseBuilder {
+    constructor() {
+        this.status = http.HTTPStatus.OK;
+        this.headers = {};
+    }
+    withStatus(status) {
+        this.status = status;
+        return this;
+    }
+    withHeader(key, value) {
+        this.headers[key] = value;
+        return this;
+    }
+    withHeaders(value) {
+        this.headers = value;
+        return this;
+    }
+    withBody(value) {
+        this.body = value;
+        return this;
+    }
+    withURI(value) {
+        this.uri = value;
+        return this;
+    }
+    withFragment(value) {
+        this.fragment = value;
+        return this;
+    }
+    withDelay(value) {
+        this.delay = value;
+        return this;
+    }
+    build() {
+        var _a, _b;
+        let data;
+        if (this.body && typeof this.body === "string") {
+            data = new Blob([this.body]);
+        }
+        else if (this.body instanceof Blob) {
+            data = this.body;
+        }
+        const status = (_a = this.status) !== null && _a !== void 0 ? _a : http.HTTPStatus.OK;
+        const response = new Response(data, {
+            status,
+            statusText: (_b = Object.keys(http.HTTPStatus)
+                .find((key) => http.HTTPStatus[key] === status)) === null || _b === void 0 ? void 0 : _b.toLowerCase().split("_").map((v) => v[0].toUpperCase() + v.slice(1)).join(" "),
+            headers: Object.entries(this.headers),
+        });
+        if (this.uri) {
+            const url = new URL(this.uri);
+            if (this.fragment) {
+                url.hash = this.fragment;
+            }
+            Object.defineProperty(response, "url", { value: url.href });
+        }
+        return { response, delay: this.delay };
+    }
+}
+class API {
+    constructor() {
+        this.matchers = [];
+        this.processedRequests = [];
+    }
+    resolve(req) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.findMatchingResponse(req);
+            if (resp) {
+                this.processedRequests.push([req, resp]);
+                return resp;
+            }
+            return new Response(null, { status: http.HTTPStatus.NOT_FOUND });
+        });
+    }
+    when(request, response) {
+        this.matchers.push(this.createMatcher(request, response));
+        return this;
+    }
+    verify(request, validator) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const matcher = this.requestMatcher(request);
+            const responses = yield Promise.all(this.processedRequests.map(([req, resp]) => matcher(req).then((v) => (v ? resp : null))));
+            if (!validator(responses.filter((v) => v !== null))) {
+                throw new VerificationError.VerificationError();
+            }
+        });
+    }
+    reset() {
+        this.processedRequests = [];
+    }
+    findMatchingResponse(request) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            for (const matcher of this.matchers) {
+                const resp = yield matcher(request);
+                if (resp) {
+                    return resp;
+                }
+            }
+        });
+    }
+    requestMatcher(mock) {
+        const mockRequest = mock;
+        const pathChecker = (req) => mockRequest.path ? new URL(req.url).pathname.startsWith(mockRequest.path) : true;
+        const methodChecker = (req) => mockRequest.method ? req.method.toUpperCase() === mockRequest.method : true;
+        const headersChecker = (req) => Object.entries(mockRequest.headers).every(([k, v]) => req.headers.get(k) === v);
+        const bodyChecker = (req) => {
+            if (!mockRequest.body) {
+                return Promise.resolve(true);
+            }
+            const data = typeof mockRequest.body !== "string" ? JSON.stringify(mockRequest.body) : mockRequest.body;
+            const buffer = new TextEncoder().encode(data);
+            return req.arrayBuffer().then((v) => {
+                const data = new Uint8Array(v);
+                for (let i = 0; i < buffer.length; i++) {
+                    if (buffer.at(i) !== data.at(i)) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        };
+        const queriesChecker = (req) => {
+            const params = new URL(req.url).searchParams;
+            return Object.entries(mockRequest.queries).every(([k, v]) => params.get(k) === v);
+        };
+        return (req) => bodyChecker(req).then((result) => result && queriesChecker(req) && headersChecker(req) && pathChecker(req) && methodChecker(req));
+    }
+    createMatcher(mockRequest, response) {
+        const matcher = this.requestMatcher(mockRequest);
+        return (request) => matcher(request).then((match) => _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (match) {
+                const { response: resp, delay } = response.build();
+                if (delay) {
+                    yield future.Future.sleep(delay);
+                }
+                return resp;
+            }
+        }));
+    }
+}
+/**
+ * Mocks network requests send via fetch API
+ */
+class MockNetworkService {
+    /**
+     * @param blockUnmatchedOrigins check whether to block requests sent to origins not specified as
+     * an API in this network service
+     */
+    constructor(blockUnmatchedOrigins = true) {
+        this.blockUnmatchedOrigins = blockUnmatchedOrigins;
+        this.realFetch = global.fetch;
+        this.apis = new Map();
+    }
+    /**
+     * Launches the network service to monitor requests
+     */
+    start() {
+        this.future = future.Future.of((resolve, reject, signal) => {
+            signal.onabort = () => {
+                global.fetch = this.realFetch;
+                reject(new AbortError.AbortError());
+            };
+            global.fetch = (input, init) => {
+                const req = new Request(input, init);
+                const uri = new URL(req.url);
+                const api = this.apis.get(uri.origin);
+                if (!api && this.blockUnmatchedOrigins) {
+                    return Promise.resolve(new Response(null, { status: http.HTTPStatus.NOT_FOUND }));
+                }
+                else if (!api) {
+                    return this.realFetch(input, init);
+                }
+                return api.resolve(req);
+            };
+        }).schedule();
+    }
+    /**
+     * Stops network monitoring
+     */
+    stop() {
+        if (this.future) {
+            this.future.cancel();
+            this.future = undefined;
+        }
+    }
+    /**
+     * Creates an API service - used to intercept requests for a given origin
+     * @param origin
+     */
+    createAPI(origin) {
+        const api = new API();
+        this.apis.set(origin, api);
+        return api;
+    }
+    /**
+     * Remove all created API services from network request routing
+     */
+    reset() {
+        this.apis.clear();
+    }
+}
+/**
+ * Validators
+ */
+/**
+ * Validates that the request was processed at least X times
+ * @param amount number of times the request was sent
+ */
+const atLeast = (amount) => (matches) => matches.length >= amount;
+/**
+ * Validates that the request was process at most X times
+ * @param amount number of times the request was sent
+ */
+const atMost = (amount) => (matches) => matches.length <= amount;
+/**
+ * Validates that the request was processed exactly X times
+ * @param amount number of times the request was sent
+ */
+const exact = (amount) => (matches) => matches.length === amount;
+/**
+ * Validates that the request was processed within the given range of times
+ * @param lower minimum times the request matched
+ * @param upper maximum times the request matched
+ * @param includeUpper if true, the upper limit provided with be included. Otherwise, the maximum will be upper - 1
+ */
+const range = (lower, upper, includeUpper = false) => (matches) => matches.length >= lower && (includeUpper ? matches.length <= upper : matches.length < upper);
+/**
+ * creates a request details instance that is used to track requests with a given set of criteria
+ */
+const request = () => new RequestDetails();
+/**
+ * creates a response builder
+ */
+const response = () => new ResponseBuilder();
+
+exports.MockNetworkService = MockNetworkService;
+exports.atLeast = atLeast;
+exports.atMost = atMost;
+exports.exact = exact;
+exports.range = range;
+exports.request = request;
+exports.response = response;

package/mocks.d.ts

@@ -0,0 +1,125 @@
+import { RequestType } from "./networking/types";
+import { HTTPStatus } from "./networking";
+import { WaitPeriod } from "./future";
+type Validator = (matches: Response[]) => boolean;
+/**
+ * Tracks specific details that should be used to match specific given network request
+ */
+declare class RequestDetails {
+    private method?;
+    private path?;
+    private headers;
+    private queries;
+    private body?;
+    constructor();
+    withMethod(method: RequestType): this;
+    withPath(path: string): this;
+    withHeader(key: string, value: string): this;
+    withHeaders(value: {
+        [string: string]: string;
+    }): this;
+    withQuery(key: string, value: string): this;
+    withQueries(value: {
+        [string: string]: string;
+    }): this;
+    withBody(value: string | any): this;
+}
+declare class ResponseBuilder {
+    private status;
+    private headers;
+    private body?;
+    private uri?;
+    private fragment?;
+    private delay?;
+    constructor();
+    withStatus(status: HTTPStatus): this;
+    withHeader(key: string, value: string): this;
+    withHeaders(value: {
+        [string: string]: string;
+    }): this;
+    withBody(value: string | Blob): this;
+    withURI(value: string): this;
+    withFragment(value: string): this;
+    withDelay(value: WaitPeriod): this;
+    build(): {
+        response: Response;
+        delay: WaitPeriod;
+    };
+}
+declare class API {
+    private readonly matchers;
+    private processedRequests;
+    constructor();
+    private resolve;
+    when(request: RequestDetails, response: ResponseBuilder): this;
+    verify(request: RequestDetails, validator: Validator): Promise<void>;
+    reset(): void;
+    private findMatchingResponse;
+    private requestMatcher;
+    private createMatcher;
+}
+/**
+ * Mocks network requests send via fetch API
+ */
+export declare class MockNetworkService {
+    private readonly blockUnmatchedOrigins;
+    private readonly realFetch;
+    private future?;
+    private readonly apis;
+    /**
+     * @param blockUnmatchedOrigins check whether to block requests sent to origins not specified as
+     * an API in this network service
+     */
+    constructor(blockUnmatchedOrigins?: boolean);
+    /**
+     * Launches the network service to monitor requests
+     */
+    start(): void;
+    /**
+     * Stops network monitoring
+     */
+    stop(): void;
+    /**
+     * Creates an API service - used to intercept requests for a given origin
+     * @param origin
+     */
+    createAPI(origin: string): API;
+    /**
+     * Remove all created API services from network request routing
+     */
+    reset(): void;
+}
+/**
+ * Validators
+ */
+/**
+ * Validates that the request was processed at least X times
+ * @param amount number of times the request was sent
+ */
+export declare const atLeast: (amount: number) => (matches: Response[]) => boolean;
+/**
+ * Validates that the request was process at most X times
+ * @param amount number of times the request was sent
+ */
+export declare const atMost: (amount: number) => (matches: Response[]) => boolean;
+/**
+ * Validates that the request was processed exactly X times
+ * @param amount number of times the request was sent
+ */
+export declare const exact: (amount: number) => (matches: Response[]) => boolean;
+/**
+ * Validates that the request was processed within the given range of times
+ * @param lower minimum times the request matched
+ * @param upper maximum times the request matched
+ * @param includeUpper if true, the upper limit provided with be included. Otherwise, the maximum will be upper - 1
+ */
+export declare const range: (lower: number, upper: number, includeUpper?: boolean) => (matches: Response[]) => boolean;
+/**
+ * creates a request details instance that is used to track requests with a given set of criteria
+ */
+export declare const request: () => RequestDetails;
+/**
+ * creates a response builder
+ */
+export declare const response: () => ResponseBuilder;
+export {};