@opra/testing 0.1.1 → 0.3.0

package/cjs/expect/utils/print-errors.util.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printErrors = void 0;
+const colorReset = "\u001B[0m";
+const colorFgYellow = "\u001B[33m";
+function printErrors(errors) {
+    let i = 1;
+    return errors.map((e) => {
+        let j = 0;
+        return '    ' + colorFgYellow + (i++) + '-' + colorReset +
+            Object.keys(e).map(k => (j++ ? '        ' : '  ') +
+                k + ': ' + e[k]).join('\n');
+    }).join('\n');
+}
+exports.printErrors = printErrors;

package/cjs/index.js

@@ -1,10 +1,9 @@
 "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");
+exports.OpraTester = exports.opraTestClient = void 0;
 const base_tester_js_1 = require("./testers/base-tester.js");
 const entity_tester_js_1 = require("./testers/entity-tester.js");
-function opraTest(app, options) {
+function opraTestClient(app, options) {
     return new OpraTester({
         app,
         ...options,
@@ -12,11 +11,7 @@ function opraTest(app, options) {
         headers: options?.headers || {}
     });
 }
-exports.opraTest = opraTest;
-function apiExpect(response) {
-    return new api_expect_js_1.ApiExpect(response);
-}
-exports.apiExpect = apiExpect;
+exports.opraTestClient = opraTestClient;
 class OpraTester extends base_tester_js_1.BaseTester {
     entity(path) {
         return new entity_tester_js_1.OpraEntityTester({

package/cjs/testers/base-operation-tester.js

@@ -1,16 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseOperationTester = void 0;
-const api_expect_js_1 = require("../expect/api-expect.js");
+const api_response_js_1 = require("../api-response.js");
 const base_tester_js_1 = require("./base-tester.js");
 class BaseOperationTester extends base_tester_js_1.BaseTester {
     async send(fn) {
-        const resp = await this._send();
+        const response = await this._send();
+        const apiResponse = new api_response_js_1.ApiResponse({
+            status: response.status,
+            body: response.body,
+            headers: response.headers,
+            rawBody: response.text,
+            contentType: response.type,
+            charset: response.charset
+        });
         if (fn) {
-            fn(new api_expect_js_1.ApiExpect(resp));
+            fn(apiResponse);
             return;
         }
-        return resp;
+        return apiResponse;
     }
 }
 exports.BaseOperationTester = BaseOperationTester;

package/cjs/testers/entity-delete-many-tester.js

@@ -9,6 +9,10 @@ class OpraEntityDeleteManyTester extends base_operation_tester_js_1.BaseOperatio
     constructor(params) {
         super(params);
     }
+    filter(value) {
+        this._params.options.filter = value;
+        return this;
+    }
     async _send() {
         const url = new url_1.OpraURL(this._params.path);
         url.pathPrefix = this._params.prefix;

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

@@ -8,6 +8,8 @@ const base_operation_tester_js_1 = require("./base-operation-tester.js");
 class OpraEntityDeleteTester extends base_operation_tester_js_1.BaseOperationTester {
     constructor(params) {
         super(params);
+        if (!params.keyValue)
+            throw new Error(`You must provide "keyValue"`);
     }
     async _send() {
         const url = new url_1.OpraURL(this._params.path);

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

@@ -8,6 +8,8 @@ const base_operation_tester_js_1 = require("./base-operation-tester.js");
 class OpraEntityGetTester extends base_operation_tester_js_1.BaseOperationTester {
     constructor(params) {
         super(params);
+        if (!params.keyValue)
+            throw new Error(`You must provide "keyValue"`);
     }
     keyValue(value) {
         this._params.keyValue = value;

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

@@ -17,7 +17,7 @@ class OpraEntitySearchTester extends base_operation_tester_js_1.BaseOperationTes
         this._params.options.skip = value;
         return this;
     }
-    count(value) {
+    count(value = true) {
         this._params.options.count = value;
         return this;
     }

package/cjs/testers/entity-update-many-tester.js

@@ -13,6 +13,10 @@ class OpraEntityUpdateManyTester extends base_operation_tester_js_1.BaseOperatio
         this._params.data = data;
         return this;
     }
+    filter(value) {
+        this._params.options.filter = value;
+        return this;
+    }
     async _send() {
         const url = new url_1.OpraURL(this._params.path);
         url.pathPrefix = this._params.prefix;

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

@@ -8,6 +8,8 @@ const base_operation_tester_js_1 = require("./base-operation-tester.js");
 class OpraEntityUpdateTester extends base_operation_tester_js_1.BaseOperationTester {
     constructor(params) {
         super(params);
+        if (!params.keyValue)
+            throw new Error(`You must provide "keyValue"`);
     }
     data(data) {
         this._params.data = data;

package/esm/api-response.d.ts

@@ -0,0 +1,12 @@
+import { ApiExpect } from './expect/api-expect.js';
+export declare class ApiResponse {
+    status: number;
+    body: any;
+    rawBody: string;
+    headers: Record<string, string>;
+    contentType: string;
+    charset: string;
+    readonly expect: ApiExpect;
+    constructor(args: Pick<ApiResponse, 'status' | 'body' | 'headers' | 'rawBody' | 'contentType' | 'charset'>);
+    get(header: string): string;
+}

package/esm/api-response.js

@@ -0,0 +1,18 @@
+import { ApiExpect } from './expect/api-expect.js';
+export class ApiResponse {
+    status;
+    body;
+    rawBody;
+    headers;
+    contentType;
+    charset;
+    expect;
+    constructor(args) {
+        Object.assign(this, args);
+        this.expect = new ApiExpect(this);
+    }
+    get(header) {
+        const key = Object.keys(this.headers).find(k => k.toLowerCase() === header.toLowerCase());
+        return (key && this.headers[key]) || '';
+    }
+}

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

@@ -0,0 +1,17 @@
+import { Expression } from '@opra/url';
+import type { ApiResponse } from '../api-response';
+export declare class ApiExpectArray {
+    readonly response: ApiResponse;
+    constructor(response: ApiResponse);
+    toMatch<T extends {}>(expected: T): this;
+    toContainAllKeys(keys: string[]): this;
+    toContainKeys(keys: string[]): this;
+    notToContainKeys(keys: string[]): this;
+    toHaveProperty(keyPath: any, value?: any): this;
+    toBeSortedBy(...fields: string[]): this;
+    toBeFilteredBy(filter: string | Expression): this;
+    toHaveExactItems(expected: number): this;
+    toHaveMaxItems(expected: number): this;
+    toHaveMinItems(expected: number): this;
+}
+export declare function convertFilter(str: string | Expression | undefined): any;

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

@@ -0,0 +1,180 @@
+import _ from 'lodash';
+import ruleJudgment from 'rule-judgment';
+import { $parse, ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from '@opra/url';
+export class ApiExpectArray {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+    toMatch(expected) {
+        try {
+            const v = _.omitBy(expected, _.isNil);
+            for (const item of this.response.body) {
+                expect(item).toMatchObject(v);
+            }
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toMatch);
+            throw e;
+        }
+        return this;
+    }
+    toContainAllKeys(keys) {
+        try {
+            for (const item of this.response.body) {
+                expect(item).toContainAllKeys(keys);
+            }
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainAllKeys);
+            throw e;
+        }
+        return this;
+    }
+    toContainKeys(keys) {
+        try {
+            for (const item of this.response.body) {
+                expect(item).toContainKeys(keys);
+            }
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainKeys);
+            throw e;
+        }
+        return this;
+    }
+    notToContainKeys(keys) {
+        try {
+            for (const item of this.response.body) {
+                expect(item).not.toContainKeys(keys);
+            }
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.notToContainKeys);
+            throw e;
+        }
+        return this;
+    }
+    toHaveProperty(keyPath, value) {
+        try {
+            for (const item of this.response.body) {
+                expect(item).toHaveProperty(keyPath, value);
+            }
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toHaveProperty);
+            throw e;
+        }
+        return this;
+    }
+    toBeSortedBy(...fields) {
+        try {
+            expect(this.response.body).toBeSortedBy(fields);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toBeSortedBy);
+            throw e;
+        }
+        return this;
+    }
+    toBeFilteredBy(filter) {
+        const f = convertFilter(filter);
+        if (f) {
+            const j = ruleJudgment(f);
+            const filtered = this.response.body.filter(j);
+            try {
+                expect(this.response.body).toStrictEqual(filtered);
+            }
+            catch (e) {
+                Error.captureStackTrace(e, this.toBeFilteredBy);
+                throw e;
+            }
+        }
+        return this;
+    }
+    toHaveExactItems(expected) {
+        try {
+            expect(this.response.body).toHaveLength(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toHaveExactItems);
+            throw e;
+        }
+        return this;
+    }
+    toHaveMaxItems(expected) {
+        try {
+            expect(this.response.body.length).toBeLessThanOrEqual(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toHaveMaxItems);
+            throw e;
+        }
+        return this;
+    }
+    toHaveMinItems(expected) {
+        try {
+            expect(this.response.body.length).toBeGreaterThanOrEqual(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toHaveMinItems);
+            throw e;
+        }
+        return this;
+    }
+}
+export function convertFilter(str) {
+    const ast = typeof str === 'string' ? $parse(str) : str;
+    if (!ast)
+        return;
+    if (ast instanceof ComparisonExpression) {
+        const left = convertFilter(ast.left);
+        const right = convertFilter(ast.right);
+        switch (ast.op) {
+            case '=':
+                return { $eq: { [left]: right } };
+            case '!=':
+                return { $ne: { [left]: right } };
+            case '>':
+                return { $gt: { [left]: right } };
+            case '>=':
+                return { $gte: { [left]: right } };
+            case '<':
+                return { $lt: { [left]: right } };
+            case '<=':
+                return { $lte: { [left]: right } };
+            case 'in':
+                return { $in: { [left]: right } };
+            case '!in':
+                return { $nin: { [left]: right } };
+            default:
+                throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
+        }
+    }
+    if (ast instanceof QualifiedIdentifier) {
+        return ast.value;
+    }
+    if (ast instanceof NumberLiteral ||
+        ast instanceof StringLiteral ||
+        ast instanceof BooleanLiteral ||
+        ast instanceof NullLiteral ||
+        ast instanceof DateLiteral ||
+        ast instanceof TimeLiteral) {
+        return ast.value;
+    }
+    if (ast instanceof ArrayExpression) {
+        return ast.items.map(convertFilter);
+    }
+    if (ast instanceof LogicalExpression) {
+        if (ast.op === 'or')
+            return { $or: ast.items.map(convertFilter) };
+        return { $and: ast.items.map(convertFilter) };
+    }
+    if (ast instanceof ArrayExpression) {
+        return ast.items.map(convertFilter);
+    }
+    if (ast instanceof ParenthesesExpression) {
+        return convertFilter(ast.expression);
+    }
+    throw new Error(`${ast.kind} is not implemented yet`);
+}

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

@@ -0,0 +1,14 @@
+import type { ApiResponse } from '../api-response';
+import { ApiExpectObject } from './api-expect-object.js';
+export declare class ApiExpectError extends ApiExpectObject {
+    readonly response: ApiResponse;
+    constructor(response: ApiResponse);
+    toContainDetail(...matching: any[]): void;
+}
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            apiErrorDetailToContain(...issue: any[]): any;
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+import matcherUtils from 'jest-matcher-utils';
+import { ApiExpectObject } from './api-expect-object.js';
+import { objectMatches } from './utils/object-matches.util.js';
+export class ApiExpectError extends ApiExpectObject {
+    response;
+    constructor(response) {
+        super(response);
+        this.response = response;
+    }
+    toContainDetail(...matching) {
+        try {
+            expect(this.response.body['@@Schema']).toStrictEqual('Opra:Exception');
+            expect(this.response.body.issues).toBeDefined();
+            expect(this.response.body.issues).apiErrorDetailToContain(matching);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainDetail);
+            throw e;
+        }
+    }
+}
+expect.extend({
+    apiErrorDetailToContain(received, issues) {
+        try {
+            expect(typeof received).toStrictEqual('object');
+            expect(Array.isArray(received)).toStrictEqual(true);
+        }
+        catch (e) {
+            return {
+                pass: false,
+                message: () => e.message
+            };
+        }
+        for (const m of issues) {
+            let matched = false;
+            for (const detail of received) {
+                if (typeof m === 'object') {
+                    try {
+                        objectMatches(detail, m);
+                        matched = true;
+                        break;
+                    }
+                    catch {
+                        //
+                    }
+                }
+            }
+            if (!matched) {
+                return {
+                    pass: false,
+                    message: () => `Object does not match: \n` + matcherUtils.stringify(m)
+                };
+            }
+        }
+        return { actual: true, pass: true, message: () => '' };
+    },
+});

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

@@ -1,10 +1,12 @@
-import { ApiExpectBody } from './api-expect-body.js';
-export declare class ApiExpectObject extends ApiExpectBody {
-    protected _body: any;
-    constructor(_body: any);
-    toBeDefined(): this;
-    toMatch<T extends {}>(value: T): this;
-    haveKeysOnly(keys: string[]): this;
-    haveKeys(keys: string[]): this;
-    notHaveKeys(keys: string[]): this;
+import type { ApiResponse } from '../api-response';
+export declare class ApiExpectObject {
+    readonly response: ApiResponse;
+    constructor(response: ApiResponse);
+    get body(): any;
+    toMatch<T extends {}>(expected: T): this;
+    toContainAllKeys(keys: string[]): this;
+    toContainKeys(keys: string[]): this;
+    notToContainKeys(keys: string[]): this;
+    toHaveProperty(keyPath: any, value?: any): this;
+    notToHaveProperty(keyPath: any, value?: any): this;
 }

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

@@ -1,27 +1,71 @@
-import { ApiExpectBody } from './api-expect-body.js';
-export class ApiExpectObject extends ApiExpectBody {
-    _body;
-    constructor(_body) {
-        super();
-        this._body = _body;
-    }
-    toBeDefined() {
-        expect(this._body).toBeDefined();
+import _ from 'lodash';
+export class ApiExpectObject {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+    get body() {
+        return this.response.body;
+    }
+    toMatch(expected) {
+        try {
+            const v = _.omitBy(expected, _.isNil);
+            expect(this.response.body).toMatchObject(v);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toMatch);
+            throw e;
+        }
         return this;
     }
-    toMatch(value) {
-        return this._toMatchObject([this._body], value);
+    toContainAllKeys(keys) {
+        try {
+            expect(this.response.body).toContainAllKeys(keys);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainAllKeys);
+            throw e;
+        }
+        return this;
+    }
+    toContainKeys(keys) {
+        try {
+            expect(this.response.body).toContainKeys(keys);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainKeys);
+            throw e;
+        }
+        return this;
     }
-    haveKeysOnly(keys) {
-        this._haveKeysOnly([this._body], keys);
+    notToContainKeys(keys) {
+        try {
+            expect(this.response.body).not.toContainKeys(keys);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.notToContainKeys);
+            throw e;
+        }
         return this;
     }
-    haveKeys(keys) {
-        this._haveKeys([this._body], keys);
+    toHaveProperty(keyPath, value) {
+        try {
+            expect(this.response.body).toHaveProperty(keyPath, value);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainKeys);
+            throw e;
+        }
         return this;
     }
-    notHaveKeys(keys) {
-        this._notHaveKeys([this._body], keys);
+    notToHaveProperty(keyPath, value) {
+        try {
+            expect(this.response.body).not.toHaveProperty(keyPath, value);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainKeys);
+            throw e;
+        }
         return this;
     }
 }

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

@@ -0,0 +1,9 @@
+import type { ApiResponse } from '../api-response';
+export declare class ApiExpectOperationResult {
+    readonly response: ApiResponse;
+    constructor(response: ApiResponse);
+    get body(): any;
+    toBeAffectedExact(expected: number): this;
+    toBeAffectedMin(expected: number): this;
+    toBeAffectedMax(expected: number): this;
+}

package/esm/expect/api-expect-operation-result.js

@@ -0,0 +1,39 @@
+export class ApiExpectOperationResult {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+    get body() {
+        return this.response.body;
+    }
+    toBeAffectedExact(expected) {
+        try {
+            expect(this.response.body.affected).toStrictEqual(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toBeAffectedExact);
+            throw e;
+        }
+        return this;
+    }
+    toBeAffectedMin(expected) {
+        try {
+            expect(this.response.body.affected).toBeGreaterThanOrEqual(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toBeAffectedMin);
+            throw e;
+        }
+        return this;
+    }
+    toBeAffectedMax(expected) {
+        try {
+            expect(this.response.body.affected).toBeLessThanOrEqual(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toBeAffectedMax);
+            throw e;
+        }
+        return this;
+    }
+}

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

@@ -1,13 +1,16 @@
-import './jest-extend.js';
-import { Response } from 'supertest';
-import { ApiExpectFail } from './api-expect-fail.js';
-import { ApiExpectList } from './api-expect-list.js';
+import './jest-extend/common.extend.js';
+import type { ApiResponse } from '../api-response';
+import { ApiExpectArray } from './api-expect-array.js';
+import { ApiExpectError } from './api-expect-error.js';
 import { ApiExpectObject } from './api-expect-object.js';
+import { ApiExpectOperationResult } from './api-expect-operation-result.js';
 export declare class ApiExpect {
-    readonly response: Response;
-    constructor(response: Response);
+    readonly response: ApiResponse;
+    constructor(response: ApiResponse);
+    get body(): any;
     toSuccess(status?: number): this;
-    toReturnObject(fn: (body: ApiExpectObject) => void): this;
-    toReturnList(fn: (body: ApiExpectList) => void): this;
-    toFail(status?: number, fn?: (errors: ApiExpectFail) => void): this;
+    toFail(status?: number): ApiExpectError;
+    toReturnOperationResult(): ApiExpectOperationResult;
+    toReturnObject(): ApiExpectObject;
+    toReturnArray(): ApiExpectArray;
 }