@opra/testing 0.0.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @opra/I18n
+
+OPRA i18n package.

package/cjs/expect/api-expect-body.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExpectBody = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+class ApiExpectBody {
+    _toMatchObject(actuals, expected) {
+        const v = lodash_1.default.omitBy(expected, lodash_1.default.isNil);
+        for (const actual of actuals)
+            expect(actual).toMatchObject(v);
+        return this;
+    }
+    _haveKeysOnly(actuals, keys) {
+        for (const actual of actuals)
+            expect(actual).toEqual(expect.objectHaveKeysOnly(keys));
+        return this;
+    }
+    _haveKeys(actuals, keys) {
+        const matcher = keys.reduce((a, k) => {
+            a[k] = expect.anything();
+            return a;
+        }, {});
+        for (const actual of actuals)
+            expect(actual).toEqual(expect.objectContaining(matcher));
+        return this;
+    }
+    _notHaveKeys(actuals, keys) {
+        const matcher = keys.reduce((a, k) => {
+            a[k] = expect.anything();
+            return a;
+        }, {});
+        for (const actual of actuals)
+            expect(actual).not.toEqual(expect.objectContaining(matcher));
+        return this;
+    }
+}
+exports.ApiExpectBody = ApiExpectBody;

package/cjs/expect/api-expect-errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExpectErrors = void 0;
+const api_expect_body_js_1 = require("./api-expect-body.js");
+class ApiExpectErrors extends api_expect_body_js_1.ApiExpectBody {
+    _body;
+    constructor(_body) {
+        super();
+        this._body = _body;
+    }
+    toBeDefined() {
+        expect(this._body.errors).toBeDefined();
+        expect(this._body.errors.length).toBeGreaterThan(0);
+        return this;
+    }
+}
+exports.ApiExpectErrors = ApiExpectErrors;

package/cjs/expect/api-expect-list.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExpectList = void 0;
+const api_expect_body_js_1 = require("./api-expect-body.js");
+class ApiExpectList extends api_expect_body_js_1.ApiExpectBody {
+    _body;
+    constructor(_body) {
+        super();
+        this._body = _body;
+    }
+    toBeDefined() {
+        expect(this._body).toBeDefined();
+        expect(this._body.items).toBeDefined();
+        return this;
+    }
+    toMatchObject(value) {
+        return this._toMatchObject(this._body.items || [], value);
+    }
+    haveKeysOnly(keys) {
+        this._haveKeysOnly(this._body.items || [], keys);
+        return this;
+    }
+    haveKeys(keys) {
+        this._haveKeys(this._body.items || [], keys);
+        return this;
+    }
+    notHaveKeys(keys) {
+        this._notHaveKeys(this._body.items || [], keys);
+        return this;
+    }
+}
+exports.ApiExpectList = ApiExpectList;

package/cjs/expect/api-expect-resource.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExpectResource = void 0;
+const api_expect_body_js_1 = require("./api-expect-body.js");
+class ApiExpectResource extends api_expect_body_js_1.ApiExpectBody {
+    _body;
+    constructor(_body) {
+        super();
+        this._body = _body;
+    }
+    toBeDefined() {
+        expect(this._body).toBeDefined();
+        return this;
+    }
+    toMatchObject(value) {
+        return this._toMatchObject([this._body], value);
+    }
+    haveKeysOnly(keys) {
+        this._haveKeysOnly([this._body], keys);
+        return this;
+    }
+    haveKeys(keys) {
+        this._haveKeys([this._body], keys);
+        return this;
+    }
+    notHaveKeys(keys) {
+        this._notHaveKeys([this._body], keys);
+        return this;
+    }
+}
+exports.ApiExpectResource = ApiExpectResource;

package/cjs/expect/api-expect.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExpect = void 0;
+const api_expect_errors_js_1 = require("./api-expect-errors.js");
+const api_expect_list_js_1 = require("./api-expect-list.js");
+const api_expect_resource_js_1 = require("./api-expect-resource.js");
+class ApiExpect {
+    response;
+    _bodyResource;
+    _bodyList;
+    _bodyErrors;
+    constructor(response) {
+        this.response = response;
+    }
+    status(value) {
+        expect(this.response.status).toEqual(value);
+        return this;
+    }
+    get bodyAsResource() {
+        return this._bodyResource =
+            this._bodyResource || new api_expect_resource_js_1.ApiExpectResource(this.response.body);
+    }
+    get bodyAsList() {
+        return this._bodyList =
+            this._bodyList || new api_expect_list_js_1.ApiExpectList(this.response.body);
+    }
+    toSuccess(status = 200) {
+        expect(this.response.body.errors).toStrictEqual(undefined);
+        expect(this.response.status).toEqual(status);
+        return this;
+    }
+    get errors() {
+        return this._bodyErrors =
+            this._bodyErrors || new api_expect_errors_js_1.ApiExpectErrors(this.response.body);
+    }
+}
+exports.ApiExpect = ApiExpect;

package/cjs/expect/jest-extend.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_matcher_utils_1 = require("jest-matcher-utils");
+expect.extend({
+    objectHaveKeysOnly(received, expected) {
+        if (typeof received === 'object') {
+            const keys = Array.isArray(expected) ? expected : Object.keys(expected);
+            const additionalKeys = Object.keys(received).filter(x => !keys.includes(x));
+            if (additionalKeys.length) {
+                return {
+                    pass: false,
+                    message: () => `Object contains unexpected additional keys (${additionalKeys})`
+                };
+            }
+        }
+        return { actual: received, pass: true, message: () => '' };
+    },
+    objectMatches(received, expected) {
+        if (typeof received === 'object') {
+            const keys = Object.keys(expected);
+            for (const k of keys) {
+                const v = k.split('.').reduce((a, b) => a[b], received);
+                try {
+                    const matching = expected[k];
+                    if (typeof matching === 'function')
+                        matching(v);
+                    else
+                        expect(v).toEqual(matching);
+                }
+                catch (e) {
+                    return {
+                        pass: false,
+                        message: () => `${k} does not match: ${e.message}`
+                    };
+                }
+            }
+        }
+        return { actual: received, pass: true, message: () => '' };
+    },
+    toBeSorted(received, compareFn) {
+        let pass = Array.isArray(received);
+        let message;
+        if (pass) {
+            const sorted = [...received];
+            sorted.sort(compareFn);
+            try {
+                expect(received).toEqual(sorted);
+            }
+            catch (e) {
+                pass = false;
+                message = () => 'Array items is not sorted as expected';
+            }
+        }
+        return {
+            actual: received,
+            message,
+            pass
+        };
+    },
+    toBeGreaterThanAny(received, expected) {
+        return compare('toBeGreaterThan', {
+            isNot: this.isNot,
+            promise: this.promise
+        }, received, expected, '>', () => received > expected);
+    },
+    toBeGreaterThanOrEqualAny(received, expected) {
+        return compare('toBeGreaterThanOrEqual', {
+            isNot: this.isNot,
+            promise: this.promise
+        }, received, expected, '>=', () => received >= expected);
+    },
+    toBeLessThanAny(received, expected) {
+        return compare('toBeLessThan', {
+            isNot: this.isNot,
+            promise: this.promise
+        }, received, expected, '<', () => received < expected);
+    },
+    toBeLessThanOrEqualAny(received, expected) {
+        return compare('toBeLessThanOrEqual', {
+            isNot: this.isNot,
+            promise: this.promise
+        }, received, expected, '<=', () => received <= expected);
+    }
+});
+function compare(matcherName, options, received, expected, operator, fn) {
+    const pass = fn(received, expected);
+    const message = () => (0, jest_matcher_utils_1.matcherHint)(matcherName, undefined, undefined, options) +
+        '\n\n' +
+        `Expected:${options.isNot ? ' not' : ''} ${operator} ${(0, jest_matcher_utils_1.printExpected)(expected)}\n` +
+        `Received:${options.isNot ? '    ' : ''}   ${(0, jest_matcher_utils_1.printReceived)(received)}`;
+    return { message, pass };
+}

package/cjs/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraTester = exports.apiExpect = exports.opraTest = void 0;
+const api_expect_js_1 = require("./expect/api-expect.js");
+const base_tester_js_1 = require("./testers/base-tester.js");
+const entity_tester_js_1 = require("./testers/entity-tester.js");
+function opraTest(app, options) {
+    return new OpraTester({
+        app,
+        ...options,
+        prefix: options?.prefix || '',
+        headers: options?.headers || {}
+    });
+}
+exports.opraTest = opraTest;
+function apiExpect(response) {
+    return new api_expect_js_1.ApiExpect(response);
+}
+exports.apiExpect = apiExpect;
+class OpraTester extends base_tester_js_1.BaseTester {
+    entity(path) {
+        return new entity_tester_js_1.OpraEntityTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            path
+        });
+    }
+}
+exports.OpraTester = OpraTester;

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/testers/base-tester.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTester = void 0;
+class BaseTester {
+    _params;
+    constructor(params) {
+        this._params = params;
+    }
+    prefix(value) {
+        this._params.prefix = value;
+        return this;
+    }
+    header(name, value) {
+        this._params.headers = this._params.headers || {};
+        this._params.headers[name] = value;
+    }
+    _prepare(test) {
+        const headers = this._params.headers;
+        if (headers)
+            Object.keys(headers).forEach(k => test.set(k, headers[k]));
+    }
+}
+exports.BaseTester = BaseTester;

package/cjs/testers/entity-create-tester.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraEntityCreateTester = void 0;
+const tslib_1 = require("tslib");
+const supertest_1 = tslib_1.__importDefault(require("supertest"));
+const url_1 = require("@opra/url");
+const base_tester_js_1 = require("./base-tester.js");
+class OpraEntityCreateTester extends base_tester_js_1.BaseTester {
+    constructor(params) {
+        super(params);
+    }
+    async send() {
+        const url = new url_1.OpraURL(this._params.path);
+        url.pathPrefix = this._params.prefix;
+        if (this._params.options.include)
+            url.searchParams.set('$include', this._params.options.include);
+        if (this._params.options.pick)
+            url.searchParams.set('$pick', this._params.options.pick);
+        if (this._params.options.omit)
+            url.searchParams.set('$omit', this._params.options.omit);
+        const req = (0, supertest_1.default)(this._params.app);
+        const test = req.post(url.toString());
+        this._prepare(test);
+        return test.send(this._params.data);
+    }
+    data(data) {
+        this._params.data = data;
+        return this;
+    }
+    omit(...fields) {
+        this._params.options.omit = fields.flat();
+        return this;
+    }
+    pick(...fields) {
+        this._params.options.pick = fields.flat();
+        return this;
+    }
+    include(...fields) {
+        this._params.options.include = fields.flat();
+        return this;
+    }
+}
+exports.OpraEntityCreateTester = OpraEntityCreateTester;

package/cjs/testers/entity-get-tester.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraEntityGetTester = void 0;
+const tslib_1 = require("tslib");
+const supertest_1 = tslib_1.__importDefault(require("supertest"));
+const url_1 = require("@opra/url");
+const base_tester_js_1 = require("./base-tester.js");
+class OpraEntityGetTester extends base_tester_js_1.BaseTester {
+    constructor(params) {
+        super(params);
+    }
+    async send() {
+        const url = new url_1.OpraURL(this._params.path);
+        url.pathPrefix = this._params.prefix;
+        url.path.get(url.path.size - 1).key = this._params.keyValue;
+        if (this._params.options.include)
+            url.searchParams.set('$include', this._params.options.include);
+        if (this._params.options.pick)
+            url.searchParams.set('$pick', this._params.options.pick);
+        if (this._params.options.omit)
+            url.searchParams.set('$omit', this._params.options.omit);
+        const req = (0, supertest_1.default)(this._params.app);
+        const test = req.get(url.toString());
+        this._prepare(test);
+        return test.send();
+    }
+    keyValue(value) {
+        this._params.keyValue = value;
+        return this;
+    }
+    omit(...fields) {
+        this._params.options.omit = fields.flat();
+        return this;
+    }
+    pick(...fields) {
+        this._params.options.pick = fields.flat();
+        return this;
+    }
+    include(...fields) {
+        this._params.options.include = fields.flat();
+        return this;
+    }
+}
+exports.OpraEntityGetTester = OpraEntityGetTester;

package/cjs/testers/entity-tester.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraEntityTester = void 0;
+const base_tester_js_1 = require("./base-tester.js");
+const entity_create_tester_js_1 = require("./entity-create-tester.js");
+const entity_get_tester_js_1 = require("./entity-get-tester.js");
+class OpraEntityTester extends base_tester_js_1.BaseTester {
+    constructor(params) {
+        super(params);
+    }
+    get(keyValue, options = {}) {
+        return new entity_get_tester_js_1.OpraEntityGetTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            keyValue,
+            options
+        });
+    }
+    create(data, options = {}) {
+        return new entity_create_tester_js_1.OpraEntityCreateTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            data,
+            options
+        });
+    }
+}
+exports.OpraEntityTester = OpraEntityTester;

package/esm/expect/api-expect-body.d.ts

@@ -0,0 +1,6 @@
+export declare class ApiExpectBody {
+    protected _toMatchObject<T extends {}>(actuals: any[], expected: T): this;
+    protected _haveKeysOnly(actuals: any[], keys: string[]): this;
+    protected _haveKeys(actuals: any[], keys: string[]): this;
+    protected _notHaveKeys(actuals: any[], keys: string[]): this;
+}

package/esm/expect/api-expect-body.js

@@ -0,0 +1,32 @@
+import _ from 'lodash';
+export class ApiExpectBody {
+    _toMatchObject(actuals, expected) {
+        const v = _.omitBy(expected, _.isNil);
+        for (const actual of actuals)
+            expect(actual).toMatchObject(v);
+        return this;
+    }
+    _haveKeysOnly(actuals, keys) {
+        for (const actual of actuals)
+            expect(actual).toEqual(expect.objectHaveKeysOnly(keys));
+        return this;
+    }
+    _haveKeys(actuals, keys) {
+        const matcher = keys.reduce((a, k) => {
+            a[k] = expect.anything();
+            return a;
+        }, {});
+        for (const actual of actuals)
+            expect(actual).toEqual(expect.objectContaining(matcher));
+        return this;
+    }
+    _notHaveKeys(actuals, keys) {
+        const matcher = keys.reduce((a, k) => {
+            a[k] = expect.anything();
+            return a;
+        }, {});
+        for (const actual of actuals)
+            expect(actual).not.toEqual(expect.objectContaining(matcher));
+        return this;
+    }
+}

package/esm/expect/api-expect-errors.d.ts

@@ -0,0 +1,6 @@
+import { ApiExpectBody } from './api-expect-body.js';
+export declare class ApiExpectErrors extends ApiExpectBody {
+    protected _body: any;
+    constructor(_body: any);
+    toBeDefined(): this;
+}

package/esm/expect/api-expect-errors.js

@@ -0,0 +1,13 @@
+import { ApiExpectBody } from './api-expect-body.js';
+export class ApiExpectErrors extends ApiExpectBody {
+    _body;
+    constructor(_body) {
+        super();
+        this._body = _body;
+    }
+    toBeDefined() {
+        expect(this._body.errors).toBeDefined();
+        expect(this._body.errors.length).toBeGreaterThan(0);
+        return this;
+    }
+}

package/esm/expect/api-expect-list.d.ts

@@ -0,0 +1,10 @@
+import { ApiExpectBody } from './api-expect-body.js';
+export declare class ApiExpectList extends ApiExpectBody {
+    protected _body: any;
+    constructor(_body: any);
+    toBeDefined(): this;
+    toMatchObject<T extends {}>(value: T): this;
+    haveKeysOnly(keys: string[]): this;
+    haveKeys(keys: string[]): this;
+    notHaveKeys(keys: string[]): this;
+}

package/esm/expect/api-expect-list.js

@@ -0,0 +1,28 @@
+import { ApiExpectBody } from './api-expect-body.js';
+export class ApiExpectList extends ApiExpectBody {
+    _body;
+    constructor(_body) {
+        super();
+        this._body = _body;
+    }
+    toBeDefined() {
+        expect(this._body).toBeDefined();
+        expect(this._body.items).toBeDefined();
+        return this;
+    }
+    toMatchObject(value) {
+        return this._toMatchObject(this._body.items || [], value);
+    }
+    haveKeysOnly(keys) {
+        this._haveKeysOnly(this._body.items || [], keys);
+        return this;
+    }
+    haveKeys(keys) {
+        this._haveKeys(this._body.items || [], keys);
+        return this;
+    }
+    notHaveKeys(keys) {
+        this._notHaveKeys(this._body.items || [], keys);
+        return this;
+    }
+}

package/esm/expect/api-expect-resource.d.ts

@@ -0,0 +1,10 @@
+import { ApiExpectBody } from './api-expect-body.js';
+export declare class ApiExpectResource extends ApiExpectBody {
+    protected _body: any;
+    constructor(_body: any);
+    toBeDefined(): this;
+    toMatchObject<T extends {}>(value: T): this;
+    haveKeysOnly(keys: string[]): this;
+    haveKeys(keys: string[]): this;
+    notHaveKeys(keys: string[]): this;
+}

package/esm/expect/api-expect-resource.js

@@ -0,0 +1,27 @@
+import { ApiExpectBody } from './api-expect-body.js';
+export class ApiExpectResource extends ApiExpectBody {
+    _body;
+    constructor(_body) {
+        super();
+        this._body = _body;
+    }
+    toBeDefined() {
+        expect(this._body).toBeDefined();
+        return this;
+    }
+    toMatchObject(value) {
+        return this._toMatchObject([this._body], value);
+    }
+    haveKeysOnly(keys) {
+        this._haveKeysOnly([this._body], keys);
+        return this;
+    }
+    haveKeys(keys) {
+        this._haveKeys([this._body], keys);
+        return this;
+    }
+    notHaveKeys(keys) {
+        this._notHaveKeys([this._body], keys);
+        return this;
+    }
+}

package/esm/expect/api-expect.d.ts

@@ -0,0 +1,16 @@
+import { Response } from 'supertest';
+import { ApiExpectErrors } from './api-expect-errors.js';
+import { ApiExpectList } from './api-expect-list.js';
+import { ApiExpectResource } from './api-expect-resource.js';
+export declare class ApiExpect {
+    readonly response: Response;
+    protected _bodyResource?: ApiExpectResource;
+    protected _bodyList?: ApiExpectList;
+    protected _bodyErrors?: ApiExpectErrors;
+    constructor(response: Response);
+    status(value: number): this;
+    get bodyAsResource(): ApiExpectResource;
+    get bodyAsList(): ApiExpectList;
+    toSuccess(status?: number): this;
+    get errors(): ApiExpectErrors;
+}

package/esm/expect/api-expect.js

@@ -0,0 +1,33 @@
+import { ApiExpectErrors } from './api-expect-errors.js';
+import { ApiExpectList } from './api-expect-list.js';
+import { ApiExpectResource } from './api-expect-resource.js';
+export class ApiExpect {
+    response;
+    _bodyResource;
+    _bodyList;
+    _bodyErrors;
+    constructor(response) {
+        this.response = response;
+    }
+    status(value) {
+        expect(this.response.status).toEqual(value);
+        return this;
+    }
+    get bodyAsResource() {
+        return this._bodyResource =
+            this._bodyResource || new ApiExpectResource(this.response.body);
+    }
+    get bodyAsList() {
+        return this._bodyList =
+            this._bodyList || new ApiExpectList(this.response.body);
+    }
+    toSuccess(status = 200) {
+        expect(this.response.body.errors).toStrictEqual(undefined);
+        expect(this.response.status).toEqual(status);
+        return this;
+    }
+    get errors() {
+        return this._bodyErrors =
+            this._bodyErrors || new ApiExpectErrors(this.response.body);
+    }
+}

package/esm/expect/jest-extend.d.ts

@@ -0,0 +1,25 @@
+declare global {
+    namespace jest {
+        interface Expect {
+            objectHaveKeysOnly(expected: string[]): any;
+            objectMatches(expected: Record<string, any>): any;
+        }
+        interface Matchers<R> {
+            toBeSorted(compareFn?: (a: any, b: any) => number): any;
+            toBeGreaterThanAny(expected: number | bigint | string | Date): any;
+            toBeGreaterThanOrEqualAny(expected: number | bigint | string | Date): any;
+            toBeLessThanAny(expected: number | bigint | string | Date): any;
+            toBeLessThanOrEqualAny(expected: number | bigint | string | Date): any;
+        }
+        interface InverseAsymmetricMatchers {
+            objectHaveKeysOnly(expected: string[]): any;
+            objectMatches(expected: Record<string, any>): any;
+            toBeSorted(compareFn?: (a: any, b: any) => number): any;
+            toBeGreaterThanAny(expected: number | bigint | string | Date): any;
+            toBeGreaterThanOrEqualAny(expected: number | bigint | string | Date): any;
+            toBeLessThanAny(expected: number | bigint | string | Date): any;
+            toBeLessThanOrEqualAny(expected: number | bigint | string | Date): any;
+        }
+    }
+}
+export {};

package/esm/expect/jest-extend.js

@@ -0,0 +1,90 @@
+import { matcherHint, printExpected, printReceived } from 'jest-matcher-utils';
+expect.extend({
+    objectHaveKeysOnly(received, expected) {
+        if (typeof received === 'object') {
+            const keys = Array.isArray(expected) ? expected : Object.keys(expected);
+            const additionalKeys = Object.keys(received).filter(x => !keys.includes(x));
+            if (additionalKeys.length) {
+                return {
+                    pass: false,
+                    message: () => `Object contains unexpected additional keys (${additionalKeys})`
+                };
+            }
+        }
+        return { actual: received, pass: true, message: () => '' };
+    },
+    objectMatches(received, expected) {
+        if (typeof received === 'object') {
+            const keys = Object.keys(expected);
+            for (const k of keys) {
+                const v = k.split('.').reduce((a, b) => a[b], received);
+                try {
+                    const matching = expected[k];
+                    if (typeof matching === 'function')
+                        matching(v);
+                    else
+                        expect(v).toEqual(matching);
+                }
+                catch (e) {
+                    return {
+                        pass: false,
+                        message: () => `${k} does not match: ${e.message}`
+                    };
+                }
+            }
+        }
+        return { actual: received, pass: true, message: () => '' };
+    },
+    toBeSorted(received, compareFn) {
+        let pass = Array.isArray(received);
+        let message;
+        if (pass) {
+            const sorted = [...received];
+            sorted.sort(compareFn);
+            try {
+                expect(received).toEqual(sorted);
+            }
+            catch (e) {
+                pass = false;
+                message = () => 'Array items is not sorted as expected';
+            }
+        }
+        return {
+            actual: received,
+            message,
+            pass
+        };
+    },
+    toBeGreaterThanAny(received, expected) {
+        return compare('toBeGreaterThan', {
+            isNot: this.isNot,
+            promise: this.promise
+        }, received, expected, '>', () => received > expected);
+    },
+    toBeGreaterThanOrEqualAny(received, expected) {
+        return compare('toBeGreaterThanOrEqual', {
+            isNot: this.isNot,
+            promise: this.promise
+        }, received, expected, '>=', () => received >= expected);
+    },
+    toBeLessThanAny(received, expected) {
+        return compare('toBeLessThan', {
+            isNot: this.isNot,
+            promise: this.promise
+        }, received, expected, '<', () => received < expected);
+    },
+    toBeLessThanOrEqualAny(received, expected) {
+        return compare('toBeLessThanOrEqual', {
+            isNot: this.isNot,
+            promise: this.promise
+        }, received, expected, '<=', () => received <= expected);
+    }
+});
+function compare(matcherName, options, received, expected, operator, fn) {
+    const pass = fn(received, expected);
+    const message = () => matcherHint(matcherName, undefined, undefined, options) +
+        '\n\n' +
+        `Expected:${options.isNot ? ' not' : ''} ${operator} ${printExpected(expected)}\n` +
+        `Received:${options.isNot ? '    ' : ''}   ${printReceived(received)}`;
+    return { message, pass };
+}

package/esm/index.d.ts

@@ -0,0 +1,9 @@
+import { Response } from 'supertest';
+import { ApiExpect } from './expect/api-expect.js';
+import { BaseTester, OpraTesterParams } from './testers/base-tester.js';
+import { OpraEntityTester } from './testers/entity-tester.js';
+export declare function opraTest(app: any, options?: Partial<Omit<OpraTesterParams, 'app'>>): OpraTester;
+export declare function apiExpect(response: Response): ApiExpect;
+export declare class OpraTester extends BaseTester {
+    entity(path: string): OpraEntityTester;
+}

package/esm/index.js

@@ -0,0 +1,23 @@
+import { ApiExpect } from './expect/api-expect.js';
+import { BaseTester } from './testers/base-tester.js';
+import { OpraEntityTester } from './testers/entity-tester.js';
+export function opraTest(app, options) {
+    return new OpraTester({
+        app,
+        ...options,
+        prefix: options?.prefix || '',
+        headers: options?.headers || {}
+    });
+}
+export function apiExpect(response) {
+    return new ApiExpect(response);
+}
+export class OpraTester extends BaseTester {
+    entity(path) {
+        return new OpraEntityTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            path
+        });
+    }
+}

package/esm/testers/base-tester.d.ts

@@ -0,0 +1,13 @@
+import { Test } from 'supertest';
+export interface OpraTesterParams {
+    app: any;
+    prefix: string;
+    headers: Record<string, string>;
+}
+export declare class BaseTester {
+    protected readonly _params: OpraTesterParams;
+    constructor(params: OpraTesterParams);
+    prefix(value: string): this;
+    header(name: string, value: string): void;
+    protected _prepare(test: Test): void;
+}

package/esm/testers/base-tester.js

@@ -0,0 +1,19 @@
+export class BaseTester {
+    _params;
+    constructor(params) {
+        this._params = params;
+    }
+    prefix(value) {
+        this._params.prefix = value;
+        return this;
+    }
+    header(name, value) {
+        this._params.headers = this._params.headers || {};
+        this._params.headers[name] = value;
+    }
+    _prepare(test) {
+        const headers = this._params.headers;
+        if (headers)
+            Object.keys(headers).forEach(k => test.set(k, headers[k]));
+    }
+}

package/esm/testers/entity-create-tester.d.ts

@@ -0,0 +1,17 @@
+import { Response } from 'supertest';
+import { CreateQueryOptions } from '@opra/core';
+import { BaseTester } from './base-tester.js';
+import type { OpraEntityTesterParams } from './entity-tester.js';
+export declare type OpraEntityCreateTesterParams = OpraEntityTesterParams & {
+    data: {};
+    options: CreateQueryOptions;
+};
+export declare class OpraEntityCreateTester extends BaseTester {
+    protected readonly _params: OpraEntityCreateTesterParams;
+    constructor(params: OpraEntityCreateTesterParams);
+    send(): Promise<Response>;
+    data(data: {}): this;
+    omit(...fields: (string | string[])[]): this;
+    pick(...fields: (string | string[])[]): this;
+    include(...fields: (string | string[])[]): this;
+}

package/esm/testers/entity-create-tester.js

@@ -0,0 +1,38 @@
+import request from 'supertest';
+import { OpraURL } from '@opra/url';
+import { BaseTester } from './base-tester.js';
+export class OpraEntityCreateTester extends BaseTester {
+    constructor(params) {
+        super(params);
+    }
+    async send() {
+        const url = new OpraURL(this._params.path);
+        url.pathPrefix = this._params.prefix;
+        if (this._params.options.include)
+            url.searchParams.set('$include', this._params.options.include);
+        if (this._params.options.pick)
+            url.searchParams.set('$pick', this._params.options.pick);
+        if (this._params.options.omit)
+            url.searchParams.set('$omit', this._params.options.omit);
+        const req = request(this._params.app);
+        const test = req.post(url.toString());
+        this._prepare(test);
+        return test.send(this._params.data);
+    }
+    data(data) {
+        this._params.data = data;
+        return this;
+    }
+    omit(...fields) {
+        this._params.options.omit = fields.flat();
+        return this;
+    }
+    pick(...fields) {
+        this._params.options.pick = fields.flat();
+        return this;
+    }
+    include(...fields) {
+        this._params.options.include = fields.flat();
+        return this;
+    }
+}

package/esm/testers/entity-get-tester.d.ts

@@ -0,0 +1,18 @@
+import { Response } from 'supertest';
+import { GetQueryOptions } from '@opra/core';
+import { ResourceKey } from '@opra/url';
+import { BaseTester } from './base-tester.js';
+import type { OpraEntityTesterParams } from './entity-tester';
+export declare type OpraEntityGetTesterParams = OpraEntityTesterParams & {
+    keyValue: ResourceKey;
+    options: GetQueryOptions;
+};
+export declare class OpraEntityGetTester extends BaseTester {
+    protected readonly _params: OpraEntityGetTesterParams;
+    constructor(params: OpraEntityGetTesterParams);
+    send(): Promise<Response>;
+    keyValue(value: ResourceKey): this;
+    omit(...fields: (string | string[])[]): this;
+    pick(...fields: (string | string[])[]): this;
+    include(...fields: (string | string[])[]): this;
+}

package/esm/testers/entity-get-tester.js

@@ -0,0 +1,39 @@
+import request from 'supertest';
+import { OpraURL } from '@opra/url';
+import { BaseTester } from './base-tester.js';
+export class OpraEntityGetTester extends BaseTester {
+    constructor(params) {
+        super(params);
+    }
+    async send() {
+        const url = new OpraURL(this._params.path);
+        url.pathPrefix = this._params.prefix;
+        url.path.get(url.path.size - 1).key = this._params.keyValue;
+        if (this._params.options.include)
+            url.searchParams.set('$include', this._params.options.include);
+        if (this._params.options.pick)
+            url.searchParams.set('$pick', this._params.options.pick);
+        if (this._params.options.omit)
+            url.searchParams.set('$omit', this._params.options.omit);
+        const req = request(this._params.app);
+        const test = req.get(url.toString());
+        this._prepare(test);
+        return test.send();
+    }
+    keyValue(value) {
+        this._params.keyValue = value;
+        return this;
+    }
+    omit(...fields) {
+        this._params.options.omit = fields.flat();
+        return this;
+    }
+    pick(...fields) {
+        this._params.options.pick = fields.flat();
+        return this;
+    }
+    include(...fields) {
+        this._params.options.include = fields.flat();
+        return this;
+    }
+}

package/esm/testers/entity-tester.d.ts

@@ -0,0 +1,14 @@
+import { CreateQueryOptions, GetQueryOptions } from '@opra/core';
+import { ResourceKey } from '@opra/url';
+import { BaseTester, OpraTesterParams } from './base-tester.js';
+import { OpraEntityCreateTester } from './entity-create-tester.js';
+import { OpraEntityGetTester } from './entity-get-tester.js';
+export declare type OpraEntityTesterParams = OpraTesterParams & {
+    path: string;
+};
+export declare class OpraEntityTester extends BaseTester {
+    protected readonly _params: OpraEntityTesterParams;
+    constructor(params: OpraEntityTesterParams);
+    get(keyValue: ResourceKey, options?: GetQueryOptions): OpraEntityGetTester;
+    create(data: {}, options?: CreateQueryOptions): OpraEntityCreateTester;
+}

package/esm/testers/entity-tester.js

@@ -0,0 +1,24 @@
+import { BaseTester } from './base-tester.js';
+import { OpraEntityCreateTester } from './entity-create-tester.js';
+import { OpraEntityGetTester } from './entity-get-tester.js';
+export class OpraEntityTester extends BaseTester {
+    constructor(params) {
+        super(params);
+    }
+    get(keyValue, options = {}) {
+        return new OpraEntityGetTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            keyValue,
+            options
+        });
+    }
+    create(data, options = {}) {
+        return new OpraEntityCreateTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            data,
+            options
+        });
+    }
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@opra/testing",
+  "version": "0.0.9",
+  "description": "Opra testing package",
+  "author": "Panates",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/testing"
+  },
+  "scripts": {
+    "compile": "tsc",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -b tsconfig-build-cjs.json",
+    "build:esm": "tsc -b tsconfig-build-esm.json",
+    "postbuild": "cp README.md package.json ../../LICENSE ../../build/testing && cp ../../package.cjs.json ../../build/testing/cjs/package.json",
+    "lint": "eslint .",
+    "test": "jest",
+    "cover": "jest --collect-coverage",
+    "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
+    "clean:src": "ts-cleanup -s src --all",
+    "clean:dist": "rimraf ../../build/testing",
+    "clean:cover": "rimraf ../../coverage/testing"
+  },
+  "dependencies": {
+    "@opra/core": "^0.0.9",
+    "@opra/url": "^0.0.9",
+    "lodash": "^4.17.21",
+    "supertest": "^6.2.4"
+  },
+  "devDependencies": {
+    "@types/supertest": "^2.0.12"
+  },
+  "type": "module",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "types": "esm/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "default": "./esm/index.js"
+    },
+    "./cjs": "./cjs/index.js",
+    "./esm": "./esm/index.js"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "bin/",
+    "cjs/",
+    "esm/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "opra",
+    "testing"
+  ]
+}