@opra/testing 0.0.9 → 0.0.11

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExpectFail = void 0;
+const api_expect_body_js_1 = require("./api-expect-body.js");
+class ApiExpectFail extends api_expect_body_js_1.ApiExpectBody {
+    _errors;
+    constructor(_errors) {
+        super();
+        this._errors = _errors;
+    }
+    toContain(...issue) {
+        expect(this._errors).toEqual(expect.arrayContaining(issue.map(o => expect.objectContaining(o))));
+    }
+}
+exports.ApiExpectFail = ApiExpectFail;

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiExpectList = void 0;
+exports.convertFilter = exports.ApiExpectList = void 0;
+const tslib_1 = require("tslib");
+const rule_judgment_1 = tslib_1.__importDefault(require("rule-judgment"));
+const url_1 = require("@opra/url");
 const api_expect_body_js_1 = require("./api-expect-body.js");
 class ApiExpectList extends api_expect_body_js_1.ApiExpectBody {
     _body;
@@ -8,12 +11,10 @@ class ApiExpectList extends api_expect_body_js_1.ApiExpectBody {
         super();
         this._body = _body;
     }
-    toBeDefined() {
-        expect(this._body).toBeDefined();
-        expect(this._body.items).toBeDefined();
-        return this;
+    get items() {
+        return this._body.items;
     }
-    toMatchObject(value) {
+    toMatch(value) {
         return this._toMatchObject(this._body.items || [], value);
     }
     haveKeysOnly(keys) {
@@ -28,5 +29,102 @@ class ApiExpectList extends api_expect_body_js_1.ApiExpectBody {
         this._notHaveKeys(this._body.items || [], keys);
         return this;
     }
+    toBeSortedBy(...fields) {
+        const fieldsMap = fields.map(x => x.split('.'));
+        const getValue = (obj, fieldMap) => {
+            let v = obj;
+            let i = 0;
+            while (v && i < fieldMap.length) {
+                v = v[fieldMap[i++]];
+            }
+            return v;
+        };
+        expect(this._body.items).toBeSorted((a, b) => {
+            for (const sortField of fieldsMap) {
+                const l = getValue(a, sortField);
+                const r = getValue(b, sortField);
+                if (l < r)
+                    return -1;
+                if (l > r)
+                    return 1;
+            }
+            return 0;
+        });
+        return this;
+    }
+    toBeFilteredBy(filter) {
+        const f = convertFilter(filter);
+        if (f) {
+            const j = (0, rule_judgment_1.default)(f);
+            const filtered = this._body.items.filter(j);
+            expect(this._body.items).toStrictEqual(filtered);
+        }
+        return this;
+    }
+    toHaveExactItems(expected) {
+        return expect(this._body.items.length).toStrictEqual(expected);
+    }
+    toHaveMaxItems(expected) {
+        return expect(this._body.items.length).toBeLessThanOrEqual(expected);
+    }
+    toHaveMinItems(expected) {
+        return expect(this._body.items.length).toBeGreaterThanOrEqual(expected);
+    }
 }
 exports.ApiExpectList = ApiExpectList;
+function convertFilter(str) {
+    const ast = typeof str === 'string' ? (0, url_1.$parse)(str) : str;
+    if (!ast)
+        return;
+    if (ast instanceof url_1.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 url_1.QualifiedIdentifier) {
+        return ast.value;
+    }
+    if (ast instanceof url_1.NumberLiteral ||
+        ast instanceof url_1.StringLiteral ||
+        ast instanceof url_1.BooleanLiteral ||
+        ast instanceof url_1.NullLiteral ||
+        ast instanceof url_1.DateLiteral ||
+        ast instanceof url_1.TimeLiteral) {
+        return ast.value;
+    }
+    if (ast instanceof url_1.ArrayExpression) {
+        return ast.items.map(convertFilter);
+    }
+    if (ast instanceof url_1.LogicalExpression) {
+        if (ast.op === 'or')
+            return { $or: ast.items.map(convertFilter) };
+        return { $and: ast.items.map(convertFilter) };
+    }
+    if (ast instanceof url_1.ArrayExpression) {
+        return ast.items.map(convertFilter);
+    }
+    if (ast instanceof url_1.ParenthesesExpression) {
+        return convertFilter(ast.expression);
+    }
+    throw new Error(`${ast.type} is not implemented yet`);
+}
+exports.convertFilter = convertFilter;

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

@@ -12,7 +12,7 @@ class ApiExpectResource extends api_expect_body_js_1.ApiExpectBody {
         expect(this._body).toBeDefined();
         return this;
     }
-    toMatchObject(value) {
+    toMatch(value) {
         return this._toMatchObject([this._body], value);
     }
     haveKeysOnly(keys) {

package/cjs/expect/api-expect.js

@@ -1,37 +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");
+require("./jest-extend.js");
+const api_expect_fail_js_1 = require("./api-expect-fail.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);
+    toSuccess(status = 200) {
+        expect(this.response.body.errors).toStrictEqual(undefined);
+        expect(this.response.status).toEqual(status);
         return this;
     }
-    get bodyAsResource() {
-        return this._bodyResource =
-            this._bodyResource || new api_expect_resource_js_1.ApiExpectResource(this.response.body);
+    toReturnResource(fn) {
+        expect(this.response.body).toBeDefined();
+        fn(new api_expect_resource_js_1.ApiExpectResource(this.response.body));
+        return this;
     }
-    get bodyAsList() {
-        return this._bodyList =
-            this._bodyList || new api_expect_list_js_1.ApiExpectList(this.response.body);
+    toReturnList(fn) {
+        expect(this.response.body).toBeDefined();
+        expect(this.response.body.items).toBeDefined();
+        fn(new api_expect_list_js_1.ApiExpectList(this.response.body));
+        return this;
     }
-    toSuccess(status = 200) {
-        expect(this.response.body.errors).toStrictEqual(undefined);
+    toFail(status = 400, fn) {
+        expect(this.response.body.errors).toBeDefined();
         expect(this.response.status).toEqual(status);
+        if (fn)
+            fn(new api_expect_fail_js_1.ApiExpectFail(this.response.body.errors));
         return this;
     }
-    get errors() {
-        return this._bodyErrors =
-            this._bodyErrors || new api_expect_errors_js_1.ApiExpectErrors(this.response.body);
-    }
 }
 exports.ApiExpect = ApiExpect;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseOperationTester = void 0;
+const api_expect_js_1 = require("../expect/api-expect.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();
+        if (fn) {
+            fn(new api_expect_js_1.ApiExpect(resp));
+            return;
+        }
+        return resp;
+    }
+}
+exports.BaseOperationTester = BaseOperationTester;

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

@@ -4,25 +4,11 @@ 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 {
+const base_operation_tester_js_1 = require("./base-operation-tester.js");
+class OpraEntityCreateTester extends base_operation_tester_js_1.BaseOperationTester {
     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;
@@ -39,5 +25,19 @@ class OpraEntityCreateTester extends base_tester_js_1.BaseTester {
         this._params.options.include = fields.flat();
         return this;
     }
+    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);
+    }
 }
 exports.OpraEntityCreateTester = OpraEntityCreateTester;

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

@@ -4,26 +4,11 @@ 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 {
+const base_operation_tester_js_1 = require("./base-operation-tester.js");
+class OpraEntityGetTester extends base_operation_tester_js_1.BaseOperationTester {
     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;
@@ -40,5 +25,20 @@ class OpraEntityGetTester extends base_tester_js_1.BaseTester {
         this._params.options.include = fields.flat();
         return this;
     }
+    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();
+    }
 }
 exports.OpraEntityGetTester = OpraEntityGetTester;

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraEntitySearchTester = void 0;
+const tslib_1 = require("tslib");
+const supertest_1 = tslib_1.__importDefault(require("supertest"));
+const url_1 = require("@opra/url");
+const base_operation_tester_js_1 = require("./base-operation-tester.js");
+class OpraEntitySearchTester extends base_operation_tester_js_1.BaseOperationTester {
+    constructor(params) {
+        super(params);
+    }
+    limit(value) {
+        this._params.options.limit = value;
+        return this;
+    }
+    skip(value) {
+        this._params.options.skip = value;
+        return this;
+    }
+    count(value) {
+        this._params.options.count = value;
+        return this;
+    }
+    distinct(value) {
+        this._params.options.distinct = value;
+        return this;
+    }
+    sort(...fields) {
+        this._params.options.sort = fields.flat();
+        return this;
+    }
+    filter(value) {
+        this._params.options.filter = 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;
+    }
+    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);
+        if (this._params.options.sort)
+            url.searchParams.set('$sort', this._params.options.sort);
+        if (this._params.options.filter)
+            url.searchParams.set('$filter', this._params.options.filter);
+        if (this._params.options.limit != null)
+            url.searchParams.set('$limit', this._params.options.limit);
+        if (this._params.options.skip != null)
+            url.searchParams.set('$skip', this._params.options.skip);
+        if (this._params.options.count != null)
+            url.searchParams.set('$count', this._params.options.count);
+        if (this._params.options.distinct != null)
+            url.searchParams.set('$distinct', this._params.options.distinct);
+        const req = (0, supertest_1.default)(this._params.app);
+        const test = req.get(url.toString());
+        this._prepare(test);
+        return test.send();
+    }
+}
+exports.OpraEntitySearchTester = OpraEntitySearchTester;

package/cjs/testers/entity-tester.js

@@ -4,10 +4,20 @@ 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");
+const entity_search_tester_js_1 = require("./entity-search-tester.js");
+const entity_update_tester_js_1 = require("./entity-update-tester.js");
 class OpraEntityTester extends base_tester_js_1.BaseTester {
     constructor(params) {
         super(params);
     }
+    create(data, options = {}) {
+        return new entity_create_tester_js_1.OpraEntityCreateTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            data,
+            options
+        });
+    }
     get(keyValue, options = {}) {
         return new entity_get_tester_js_1.OpraEntityGetTester({
             ...this._params,
@@ -16,9 +26,17 @@ class OpraEntityTester extends base_tester_js_1.BaseTester {
             options
         });
     }
-    create(data, options = {}) {
-        return new entity_create_tester_js_1.OpraEntityCreateTester({
+    search(options = {}) {
+        return new entity_search_tester_js_1.OpraEntitySearchTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            options
+        });
+    }
+    update(keyValue, data, options = {}) {
+        return new entity_update_tester_js_1.OpraEntityUpdateTester({
             ...this._params,
+            keyValue,
             headers: { ...this._params.headers },
             data,
             options

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraEntityUpdateTester = void 0;
+const tslib_1 = require("tslib");
+const supertest_1 = tslib_1.__importDefault(require("supertest"));
+const url_1 = require("@opra/url");
+const base_operation_tester_js_1 = require("./base-operation-tester.js");
+class OpraEntityUpdateTester extends base_operation_tester_js_1.BaseOperationTester {
+    constructor(params) {
+        super(params);
+    }
+    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;
+    }
+    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.post(url.toString());
+        this._prepare(test);
+        return test.send(this._params.data);
+    }
+}
+exports.OpraEntityUpdateTester = OpraEntityUpdateTester;

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

@@ -0,0 +1,6 @@
+import { ApiExpectBody } from './api-expect-body.js';
+export declare class ApiExpectFail extends ApiExpectBody {
+    protected _errors: any;
+    constructor(_errors: any);
+    toContain(...issue: any[]): void;
+}

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

@@ -0,0 +1,11 @@
+import { ApiExpectBody } from './api-expect-body.js';
+export class ApiExpectFail extends ApiExpectBody {
+    _errors;
+    constructor(_errors) {
+        super();
+        this._errors = _errors;
+    }
+    toContain(...issue) {
+        expect(this._errors).toEqual(expect.arrayContaining(issue.map(o => expect.objectContaining(o))));
+    }
+}

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

@@ -1,10 +1,17 @@
+import { Expression } from '@opra/url';
 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;
+    get items(): any;
+    toMatch<T extends {}>(value: T): this;
     haveKeysOnly(keys: string[]): this;
     haveKeys(keys: string[]): this;
     notHaveKeys(keys: string[]): this;
+    toBeSortedBy(...fields: string[]): this;
+    toBeFilteredBy(filter: string | Expression): this;
+    toHaveExactItems(expected: number): void;
+    toHaveMaxItems(expected: number): void;
+    toHaveMinItems(expected: number): void;
 }
+export declare function convertFilter(str: string | Expression | undefined): any;

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

@@ -1,3 +1,5 @@
+import ruleJudgment from 'rule-judgment';
+import { $parse, ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from '@opra/url';
 import { ApiExpectBody } from './api-expect-body.js';
 export class ApiExpectList extends ApiExpectBody {
     _body;
@@ -5,12 +7,10 @@ export class ApiExpectList extends ApiExpectBody {
         super();
         this._body = _body;
     }
-    toBeDefined() {
-        expect(this._body).toBeDefined();
-        expect(this._body.items).toBeDefined();
-        return this;
+    get items() {
+        return this._body.items;
     }
-    toMatchObject(value) {
+    toMatch(value) {
         return this._toMatchObject(this._body.items || [], value);
     }
     haveKeysOnly(keys) {
@@ -25,4 +25,100 @@ export class ApiExpectList extends ApiExpectBody {
         this._notHaveKeys(this._body.items || [], keys);
         return this;
     }
+    toBeSortedBy(...fields) {
+        const fieldsMap = fields.map(x => x.split('.'));
+        const getValue = (obj, fieldMap) => {
+            let v = obj;
+            let i = 0;
+            while (v && i < fieldMap.length) {
+                v = v[fieldMap[i++]];
+            }
+            return v;
+        };
+        expect(this._body.items).toBeSorted((a, b) => {
+            for (const sortField of fieldsMap) {
+                const l = getValue(a, sortField);
+                const r = getValue(b, sortField);
+                if (l < r)
+                    return -1;
+                if (l > r)
+                    return 1;
+            }
+            return 0;
+        });
+        return this;
+    }
+    toBeFilteredBy(filter) {
+        const f = convertFilter(filter);
+        if (f) {
+            const j = ruleJudgment(f);
+            const filtered = this._body.items.filter(j);
+            expect(this._body.items).toStrictEqual(filtered);
+        }
+        return this;
+    }
+    toHaveExactItems(expected) {
+        return expect(this._body.items.length).toStrictEqual(expected);
+    }
+    toHaveMaxItems(expected) {
+        return expect(this._body.items.length).toBeLessThanOrEqual(expected);
+    }
+    toHaveMinItems(expected) {
+        return expect(this._body.items.length).toBeGreaterThanOrEqual(expected);
+    }
+}
+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.type} is not implemented yet`);
 }

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

@@ -3,7 +3,7 @@ export declare class ApiExpectResource extends ApiExpectBody {
     protected _body: any;
     constructor(_body: any);
     toBeDefined(): this;
-    toMatchObject<T extends {}>(value: T): this;
+    toMatch<T extends {}>(value: T): this;
     haveKeysOnly(keys: string[]): this;
     haveKeys(keys: string[]): this;
     notHaveKeys(keys: string[]): this;

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

@@ -9,7 +9,7 @@ export class ApiExpectResource extends ApiExpectBody {
         expect(this._body).toBeDefined();
         return this;
     }
-    toMatchObject(value) {
+    toMatch(value) {
         return this._toMatchObject([this._body], value);
     }
     haveKeysOnly(keys) {

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

@@ -1,16 +1,13 @@
+import './jest-extend.js';
 import { Response } from 'supertest';
-import { ApiExpectErrors } from './api-expect-errors.js';
+import { ApiExpectFail } from './api-expect-fail.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;
+    toReturnResource(fn: (body: ApiExpectResource) => void): this;
+    toReturnList(fn: (body: ApiExpectList) => void): this;
+    toFail(status?: number, fn?: (errors: ApiExpectFail) => void): this;
 }

package/esm/expect/api-expect.js

@@ -1,33 +1,33 @@
-import { ApiExpectErrors } from './api-expect-errors.js';
+import './jest-extend.js';
+import { ApiExpectFail } from './api-expect-fail.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);
+    toSuccess(status = 200) {
+        expect(this.response.body.errors).toStrictEqual(undefined);
+        expect(this.response.status).toEqual(status);
         return this;
     }
-    get bodyAsResource() {
-        return this._bodyResource =
-            this._bodyResource || new ApiExpectResource(this.response.body);
+    toReturnResource(fn) {
+        expect(this.response.body).toBeDefined();
+        fn(new ApiExpectResource(this.response.body));
+        return this;
     }
-    get bodyAsList() {
-        return this._bodyList =
-            this._bodyList || new ApiExpectList(this.response.body);
+    toReturnList(fn) {
+        expect(this.response.body).toBeDefined();
+        expect(this.response.body.items).toBeDefined();
+        fn(new ApiExpectList(this.response.body));
+        return this;
     }
-    toSuccess(status = 200) {
-        expect(this.response.body.errors).toStrictEqual(undefined);
+    toFail(status = 400, fn) {
+        expect(this.response.body.errors).toBeDefined();
         expect(this.response.status).toEqual(status);
+        if (fn)
+            fn(new ApiExpectFail(this.response.body.errors));
         return this;
     }
-    get errors() {
-        return this._bodyErrors =
-            this._bodyErrors || new ApiExpectErrors(this.response.body);
-    }
 }

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

@@ -0,0 +1,12 @@
+import { Response } from 'supertest';
+import { BaseTester } from './base-tester.js';
+export interface OpraTesterParams {
+    app: any;
+    prefix: string;
+    headers: Record<string, string>;
+}
+export declare abstract class BaseOperationTester extends BaseTester {
+    send(): Promise<Response>;
+    send(fn: (expect: any) => void): Promise<void>;
+    protected abstract _send(): Promise<Response>;
+}

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

@@ -0,0 +1,12 @@
+import { ApiExpect } from '../expect/api-expect.js';
+import { BaseTester } from './base-tester.js';
+export class BaseOperationTester extends BaseTester {
+    async send(fn) {
+        const resp = await this._send();
+        if (fn) {
+            fn(new ApiExpect(resp));
+            return;
+        }
+        return resp;
+    }
+}

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

@@ -4,7 +4,7 @@ export interface OpraTesterParams {
     prefix: string;
     headers: Record<string, string>;
 }
-export declare class BaseTester {
+export declare abstract class BaseTester {
     protected readonly _params: OpraTesterParams;
     constructor(params: OpraTesterParams);
     prefix(value: string): this;

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

@@ -1,17 +1,17 @@
 import { Response } from 'supertest';
 import { CreateQueryOptions } from '@opra/core';
-import { BaseTester } from './base-tester.js';
+import { BaseOperationTester } from './base-operation-tester.js';
 import type { OpraEntityTesterParams } from './entity-tester.js';
 export declare type OpraEntityCreateTesterParams = OpraEntityTesterParams & {
     data: {};
     options: CreateQueryOptions;
 };
-export declare class OpraEntityCreateTester extends BaseTester {
+export declare class OpraEntityCreateTester extends BaseOperationTester {
     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;
+    protected _send(): Promise<Response>;
 }

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

@@ -1,24 +1,10 @@
 import request from 'supertest';
 import { OpraURL } from '@opra/url';
-import { BaseTester } from './base-tester.js';
-export class OpraEntityCreateTester extends BaseTester {
+import { BaseOperationTester } from './base-operation-tester.js';
+export class OpraEntityCreateTester extends BaseOperationTester {
     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;
@@ -35,4 +21,18 @@ export class OpraEntityCreateTester extends BaseTester {
         this._params.options.include = fields.flat();
         return this;
     }
+    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);
+    }
 }

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

@@ -1,18 +1,18 @@
 import { Response } from 'supertest';
 import { GetQueryOptions } from '@opra/core';
 import { ResourceKey } from '@opra/url';
-import { BaseTester } from './base-tester.js';
+import { BaseOperationTester } from './base-operation-tester.js';
 import type { OpraEntityTesterParams } from './entity-tester';
 export declare type OpraEntityGetTesterParams = OpraEntityTesterParams & {
     keyValue: ResourceKey;
     options: GetQueryOptions;
 };
-export declare class OpraEntityGetTester extends BaseTester {
+export declare class OpraEntityGetTester extends BaseOperationTester {
     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;
+    protected _send(): Promise<Response>;
 }

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

@@ -1,25 +1,10 @@
 import request from 'supertest';
 import { OpraURL } from '@opra/url';
-import { BaseTester } from './base-tester.js';
-export class OpraEntityGetTester extends BaseTester {
+import { BaseOperationTester } from './base-operation-tester.js';
+export class OpraEntityGetTester extends BaseOperationTester {
     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;
@@ -36,4 +21,19 @@ export class OpraEntityGetTester extends BaseTester {
         this._params.options.include = fields.flat();
         return this;
     }
+    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();
+    }
 }

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

@@ -0,0 +1,22 @@
+import { Response } from 'supertest';
+import { SearchQueryOptions } from '@opra/core';
+import { Expression } from '@opra/url';
+import { BaseOperationTester } from './base-operation-tester.js';
+import type { OpraEntityTesterParams } from './entity-tester';
+export declare type OpraEntitySearchTesterParams = OpraEntityTesterParams & {
+    options: SearchQueryOptions;
+};
+export declare class OpraEntitySearchTester extends BaseOperationTester {
+    protected readonly _params: OpraEntitySearchTesterParams;
+    constructor(params: OpraEntitySearchTesterParams);
+    limit(value: number): this;
+    skip(value: number): this;
+    count(value: boolean): this;
+    distinct(value: boolean): this;
+    sort(...fields: (string | string[])[]): this;
+    filter(value: string | Expression): this;
+    omit(...fields: (string | string[])[]): this;
+    pick(...fields: (string | string[])[]): this;
+    include(...fields: (string | string[])[]): this;
+    protected _send(): Promise<Response>;
+}

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

@@ -0,0 +1,70 @@
+import request from 'supertest';
+import { OpraURL } from '@opra/url';
+import { BaseOperationTester } from './base-operation-tester.js';
+export class OpraEntitySearchTester extends BaseOperationTester {
+    constructor(params) {
+        super(params);
+    }
+    limit(value) {
+        this._params.options.limit = value;
+        return this;
+    }
+    skip(value) {
+        this._params.options.skip = value;
+        return this;
+    }
+    count(value) {
+        this._params.options.count = value;
+        return this;
+    }
+    distinct(value) {
+        this._params.options.distinct = value;
+        return this;
+    }
+    sort(...fields) {
+        this._params.options.sort = fields.flat();
+        return this;
+    }
+    filter(value) {
+        this._params.options.filter = 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;
+    }
+    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);
+        if (this._params.options.sort)
+            url.searchParams.set('$sort', this._params.options.sort);
+        if (this._params.options.filter)
+            url.searchParams.set('$filter', this._params.options.filter);
+        if (this._params.options.limit != null)
+            url.searchParams.set('$limit', this._params.options.limit);
+        if (this._params.options.skip != null)
+            url.searchParams.set('$skip', this._params.options.skip);
+        if (this._params.options.count != null)
+            url.searchParams.set('$count', this._params.options.count);
+        if (this._params.options.distinct != null)
+            url.searchParams.set('$distinct', this._params.options.distinct);
+        const req = request(this._params.app);
+        const test = req.get(url.toString());
+        this._prepare(test);
+        return test.send();
+    }
+}

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

@@ -1,14 +1,18 @@
-import { CreateQueryOptions, GetQueryOptions } from '@opra/core';
+import { CreateQueryOptions, GetQueryOptions, UpdateQueryOptions } 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';
+import { OpraEntitySearchTester } from './entity-search-tester.js';
+import { OpraEntityUpdateTester } from './entity-update-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;
+    get(keyValue: ResourceKey, options?: GetQueryOptions): OpraEntityGetTester;
+    search(options?: GetQueryOptions): OpraEntitySearchTester;
+    update(keyValue: ResourceKey, data: {}, options?: UpdateQueryOptions): OpraEntityUpdateTester;
 }

package/esm/testers/entity-tester.js

@@ -1,10 +1,20 @@
 import { BaseTester } from './base-tester.js';
 import { OpraEntityCreateTester } from './entity-create-tester.js';
 import { OpraEntityGetTester } from './entity-get-tester.js';
+import { OpraEntitySearchTester } from './entity-search-tester.js';
+import { OpraEntityUpdateTester } from './entity-update-tester.js';
 export class OpraEntityTester extends BaseTester {
     constructor(params) {
         super(params);
     }
+    create(data, options = {}) {
+        return new OpraEntityCreateTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            data,
+            options
+        });
+    }
     get(keyValue, options = {}) {
         return new OpraEntityGetTester({
             ...this._params,
@@ -13,9 +23,17 @@ export class OpraEntityTester extends BaseTester {
             options
         });
     }
-    create(data, options = {}) {
-        return new OpraEntityCreateTester({
+    search(options = {}) {
+        return new OpraEntitySearchTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            options
+        });
+    }
+    update(keyValue, data, options = {}) {
+        return new OpraEntityUpdateTester({
             ...this._params,
+            keyValue,
             headers: { ...this._params.headers },
             data,
             options

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

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

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

@@ -0,0 +1,39 @@
+import request from 'supertest';
+import { OpraURL } from '@opra/url';
+import { BaseOperationTester } from './base-operation-tester.js';
+export class OpraEntityUpdateTester extends BaseOperationTester {
+    constructor(params) {
+        super(params);
+    }
+    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;
+    }
+    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.post(url.toString());
+        this._prepare(test);
+        return test.send(this._params.data);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/testing",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Opra testing package",
   "author": "Panates",
   "license": "MIT",
@@ -25,9 +25,10 @@
     "clean:cover": "rimraf ../../coverage/testing"
   },
   "dependencies": {
-    "@opra/core": "^0.0.9",
-    "@opra/url": "^0.0.9",
+    "@opra/core": "^0.0.11",
+    "@opra/url": "^0.0.11",
     "lodash": "^4.17.21",
+    "rule-judgment": "^1.1.5",
     "supertest": "^6.2.4"
   },
   "devDependencies": {

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

@@ -1,17 +0,0 @@
-"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/esm/expect/api-expect-errors.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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;
-    }
-}