@opra/testing 0.0.9 → 0.0.12

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 → api-expect-object.d.ts}

@@ -1,9 +1,9 @@
 import { ApiExpectBody } from './api-expect-body.js';
-export declare class ApiExpectResource extends ApiExpectBody {
+export declare class ApiExpectObject 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 → api-expect-object.js}

@@ -1,5 +1,5 @@
 import { ApiExpectBody } from './api-expect-body.js';
-export class ApiExpectResource extends ApiExpectBody {
+export class ApiExpectObject extends ApiExpectBody {
     _body;
     constructor(_body) {
         super();
@@ -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';
+import { ApiExpectObject } from './api-expect-object.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;
+    toReturnObject(fn: (body: ApiExpectObject) => 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,38 @@
-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';
+import { ApiExpectObject } from './api-expect-object.js';
 export class ApiExpect {
     response;
-    _bodyResource;
-    _bodyList;
-    _bodyErrors;
     constructor(response) {
         this.response = response;
     }
-    status(value) {
-        expect(this.response.status).toEqual(value);
+    toSuccess(status) {
+        expect(this.response.body.errors).toStrictEqual(undefined);
+        if (status)
+            expect(this.response.status).toEqual(status);
+        else {
+            expect(this.response.status).toBeGreaterThanOrEqual(200);
+            expect(this.response.status).toBeLessThan(300);
+        }
         return this;
     }
-    get bodyAsResource() {
-        return this._bodyResource =
-            this._bodyResource || new ApiExpectResource(this.response.body);
+    toReturnObject(fn) {
+        expect(this.response.body).toBeDefined();
+        fn(new ApiExpectObject(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-delete-many-tester.d.ts

@@ -0,0 +1,12 @@
+import { Response } from 'supertest';
+import { DeleteManyQueryOption } from '@opra/core';
+import { BaseOperationTester } from './base-operation-tester.js';
+import type { OpraEntityTesterParams } from './entity-tester.js';
+export declare type OpraEntityDeleteManyTesterParams = OpraEntityTesterParams & {
+    options: DeleteManyQueryOption;
+};
+export declare class OpraEntityDeleteManyTester extends BaseOperationTester {
+    protected readonly _params: OpraEntityDeleteManyTesterParams;
+    constructor(params: OpraEntityDeleteManyTesterParams);
+    protected _send(): Promise<Response>;
+}

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

@@ -0,0 +1,18 @@
+import request from 'supertest';
+import { OpraURL } from '@opra/url';
+import { BaseOperationTester } from './base-operation-tester.js';
+export class OpraEntityDeleteManyTester extends BaseOperationTester {
+    constructor(params) {
+        super(params);
+    }
+    async _send() {
+        const url = new OpraURL(this._params.path);
+        url.pathPrefix = this._params.prefix;
+        if (this._params.options.filter)
+            url.searchParams.set('$filter', this._params.options.filter);
+        const req = request(this._params.app);
+        const test = req.delete(url.toString());
+        this._prepare(test);
+        return test.send();
+    }
+}

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

@@ -0,0 +1,14 @@
+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 OpraEntityDeleteTesterParams = OpraEntityTesterParams & {
+    keyValue: ResourceKey;
+    options: CreateQueryOptions;
+};
+export declare class OpraEntityDeleteTester extends BaseOperationTester {
+    protected readonly _params: OpraEntityDeleteTesterParams;
+    constructor(params: OpraEntityDeleteTesterParams);
+    protected _send(): Promise<Response>;
+}

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

@@ -0,0 +1,17 @@
+import request from 'supertest';
+import { OpraURL } from '@opra/url';
+import { BaseOperationTester } from './base-operation-tester.js';
+export class OpraEntityDeleteTester 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;
+        const req = request(this._params.app);
+        const test = req.delete(url.toString());
+        this._prepare(test);
+        return test.send();
+    }
+}

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,24 @@
-import { CreateQueryOptions, GetQueryOptions } from '@opra/core';
+import { CreateQueryOptions, DeleteManyQueryOption, DeleteQueryOptions, GetQueryOptions, UpdateManyQueryOptions, UpdateQueryOptions } from '@opra/core';
 import { ResourceKey } from '@opra/url';
 import { BaseTester, OpraTesterParams } from './base-tester.js';
 import { OpraEntityCreateTester } from './entity-create-tester.js';
+import { OpraEntityDeleteManyTester } from './entity-delete-many-tester.js';
+import { OpraEntityDeleteTester } from './entity-delete-tester.js';
 import { OpraEntityGetTester } from './entity-get-tester.js';
+import { OpraEntitySearchTester } from './entity-search-tester.js';
+import { OpraEntityUpdateManyTester } from './entity-update-many-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;
+    updateMany(data: {}, options?: UpdateManyQueryOptions): OpraEntityUpdateManyTester;
+    delete(keyValue: ResourceKey, options?: DeleteQueryOptions): OpraEntityDeleteTester;
+    deleteMany(options?: DeleteManyQueryOption): OpraEntityDeleteManyTester;
 }

package/esm/testers/entity-tester.js

@@ -1,10 +1,23 @@
 import { BaseTester } from './base-tester.js';
 import { OpraEntityCreateTester } from './entity-create-tester.js';
+import { OpraEntityDeleteManyTester } from './entity-delete-many-tester.js';
+import { OpraEntityDeleteTester } from './entity-delete-tester.js';
 import { OpraEntityGetTester } from './entity-get-tester.js';
+import { OpraEntitySearchTester } from './entity-search-tester.js';
+import { OpraEntityUpdateManyTester } from './entity-update-many-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,12 +26,43 @@ 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
         });
     }
+    updateMany(data, options = {}) {
+        return new OpraEntityUpdateManyTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            data,
+            options
+        });
+    }
+    delete(keyValue, options = {}) {
+        return new OpraEntityDeleteTester({
+            ...this._params,
+            keyValue,
+            headers: { ...this._params.headers },
+            options
+        });
+    }
+    deleteMany(options = {}) {
+        return new OpraEntityDeleteManyTester({
+            ...this._params,
+            headers: { ...this._params.headers },
+            options
+        });
+    }
 }