@opra/testing 0.1.1 → 0.3.0

package/esm/expect/api-expect.js

@@ -1,38 +1,97 @@
-import './jest-extend.js';
-import { ApiExpectFail } from './api-expect-fail.js';
-import { ApiExpectList } from './api-expect-list.js';
+import './jest-extend/common.extend.js';
+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 class ApiExpect {
     response;
     constructor(response) {
         this.response = response;
     }
-    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);
+    get body() {
+        return this.response.body;
+    }
+    toSuccess(status = 200) {
+        let msg = ';';
+        try {
+            msg = 'Response "status" is not valid';
+            expect(this.response.status).toStrictEqual(status);
+        }
+        catch (e) {
+            if (msg)
+                e.message = msg + '\n\n' + e.message;
+            Error.captureStackTrace(e, this.toSuccess);
+            throw e;
         }
         return this;
     }
-    toReturnObject(fn) {
-        expect(this.response.body).toBeDefined();
-        fn(new ApiExpectObject(this.response.body));
-        return this;
+    toFail(status = 400) {
+        let msg = ';';
+        try {
+            msg = 'Response "status" does not match';
+            if (status) {
+                expect(this.response.status).toStrictEqual(status);
+            }
+            else {
+                expect(this.response.status).toBeGreaterThanOrEqual(400);
+                expect(this.response.status).toBeLessThanOrEqual(599);
+            }
+            msg = 'Api did not returned "errors"';
+            expect(this.response.body.errors).toBeArray();
+            expect(this.response.body.errors.length).toBeGreaterThan(0);
+        }
+        catch (e) {
+            if (msg)
+                e.message = msg + '\n\n' + e.message;
+            Error.captureStackTrace(e, this.toFail);
+            throw e;
+        }
+        return new ApiExpectError(this.response);
     }
-    toReturnList(fn) {
-        expect(this.response.body).toBeDefined();
-        expect(this.response.body.items).toBeDefined();
-        fn(new ApiExpectList(this.response.body));
-        return this;
+    toReturnOperationResult() {
+        let msg = ';';
+        try {
+            msg = '"body" is empty';
+            expect(this.response.body).toBeDefined();
+            msg = '"operation" property is empty';
+            expect(this.response.body.operation).toBeDefined();
+        }
+        catch (e) {
+            if (msg)
+                e.message = msg + '\n\n' + e.message;
+            Error.captureStackTrace(e, this.toReturnObject);
+            throw e;
+        }
+        return new ApiExpectOperationResult(this.response);
     }
-    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;
+    toReturnObject() {
+        let msg = ';';
+        try {
+            msg = '"body" is empty';
+            expect(this.response.body).toBeDefined();
+        }
+        catch (e) {
+            if (msg)
+                e.message = msg + '\n\n' + e.message;
+            Error.captureStackTrace(e, this.toReturnObject);
+            throw e;
+        }
+        return new ApiExpectObject(this.response);
+    }
+    toReturnArray() {
+        let msg = ';';
+        try {
+            msg = '"body" is empty';
+            expect(this.response.body).toBeDefined();
+            msg = '"body" is not an array';
+            expect(this.response.body).toBeArray();
+        }
+        catch (e) {
+            if (msg)
+                e.message = msg + '\n\n' + e.message;
+            Error.captureStackTrace(e, this.toReturnArray);
+            throw e;
+        }
+        return new ApiExpectArray(this.response);
     }
 }

package/esm/expect/{jest-extend.d.ts → jest-extend/common.extend.d.ts}

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

package/esm/expect/{jest-extend.js → jest-extend/common.extend.js}

@@ -1,10 +1,10 @@
 import { matcherHint, printExpected, printReceived } from 'jest-matcher-utils';
 expect.extend({
-    objectHaveKeysOnly(received, expected) {
+    toContainKeys(received, expected) {
         if (typeof received === 'object') {
             const keys = Array.isArray(expected) ? expected : Object.keys(expected);
             const additionalKeys = Object.keys(received).filter(x => !keys.includes(x));
-            if (additionalKeys.length) {
+            if (!Object.keys(received).find(x => keys.includes(x))) {
                 return {
                     pass: false,
                     message: () => `Object contains unexpected additional keys (${additionalKeys})`
@@ -13,33 +13,33 @@ expect.extend({
         }
         return { actual: received, pass: true, message: () => '' };
     },
-    objectMatches(received, expected) {
+    toContainAllKeys(received, expected) {
         if (typeof received === 'object') {
-            const keys = Object.keys(expected);
-            for (const k of keys) {
-                const v = k.split('.').reduce((a, b) => a[b], received);
-                try {
-                    const matching = expected[k];
-                    if (typeof matching === 'function')
-                        matching(v);
-                    else
-                        expect(v).toEqual(matching);
-                }
-                catch (e) {
-                    return {
-                        pass: false,
-                        message: () => `${k} does not match: ${e.message}`
-                    };
-                }
+            const keys = Array.isArray(expected) ? expected : Object.keys(expected);
+            const additionalKeys = Object.keys(received).filter(x => !keys.includes(x));
+            if (additionalKeys.length) {
+                return {
+                    pass: false,
+                    message: () => `Object contains unexpected additional keys (${additionalKeys})`
+                };
             }
         }
         return { actual: received, pass: true, message: () => '' };
     },
+    toBeArray(received) {
+        if (Array.isArray(received)) {
+            return { actual: received, pass: true, message: () => '' };
+        }
+        return {
+            pass: false,
+            message: () => 'Value is not an array'
+        };
+    },
     toBeSorted(received, compareFn) {
-        let pass = Array.isArray(received);
+        let pass = true;
         let message;
         if (pass) {
-            const sorted = [...received];
+            const sorted = [...(received || [])];
             sorted.sort(compareFn);
             try {
                 expect(received).toEqual(sorted);
@@ -55,6 +55,45 @@ expect.extend({
             pass
         };
     },
+    toBeSortedBy(received, properties) {
+        const fieldsMap = properties.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;
+        };
+        let pass = true;
+        let message;
+        if (pass) {
+            const sorted = [...(received || [])];
+            sorted.sort((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;
+            });
+            try {
+                expect(received).toEqual(sorted);
+            }
+            catch (e) {
+                pass = false;
+                message = () => 'Array items is not sorted as expected';
+            }
+        }
+        return {
+            actual: received,
+            message,
+            pass
+        };
+    },
     toBeGreaterThanAny(received, expected) {
         return compare('toBeGreaterThan', {
             isNot: this.isNot,

package/esm/expect/utils/object-matches.util.d.ts

@@ -0,0 +1 @@
+export declare function objectMatches(received: any, expected: any): void;

package/esm/expect/utils/object-matches.util.js

@@ -0,0 +1,28 @@
+export function objectMatches(received, expected) {
+    _objectMatches(received, expected, '');
+}
+function _objectMatches(received, expected, path) {
+    if (typeof received !== typeof expected)
+        expect(typeof received).toStrictEqual('object');
+    const keys = Object.keys(expected);
+    for (const k of keys) {
+        const rv = received[k];
+        const ev = expected[k];
+        if (ev instanceof RegExp) {
+            try {
+                expect(rv).toMatch(ev);
+            }
+            catch {
+                throw new Error(`Property "${k}" does not match`);
+            }
+        }
+        if (ev && typeof ev === 'object')
+            _objectMatches(rv, ev, path ? path + '.' + k : k);
+        try {
+            expect(rv).toStrictEqual(ev);
+        }
+        catch {
+            throw new Error(`Property "${k}" does not match`);
+        }
+    }
+}

package/esm/expect/utils/print-errors.util.d.ts

@@ -0,0 +1 @@
+export declare function printErrors(errors: any[]): string;

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

@@ -0,0 +1,11 @@
+const colorReset = "\u001B[0m";
+const colorFgYellow = "\u001B[33m";
+export 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');
+}

package/esm/index.d.ts

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

package/esm/index.js

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

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

@@ -1,12 +1,8 @@
 import { Response } from 'supertest';
+import { ApiResponse } from '../api-response.js';
 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>;
+    send(): Promise<ApiResponse>;
+    send(fn: (expect: ApiResponse) => void): Promise<void>;
     protected abstract _send(): Promise<Response>;
 }

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

@@ -1,12 +1,20 @@
-import { ApiExpect } from '../expect/api-expect.js';
+import { ApiResponse } from '../api-response.js';
 import { BaseTester } from './base-tester.js';
 export class BaseOperationTester extends BaseTester {
     async send(fn) {
-        const resp = await this._send();
+        const response = await this._send();
+        const apiResponse = new ApiResponse({
+            status: response.status,
+            body: response.body,
+            headers: response.headers,
+            rawBody: response.text,
+            contentType: response.type,
+            charset: response.charset
+        });
         if (fn) {
-            fn(new ApiExpect(resp));
+            fn(apiResponse);
             return;
         }
-        return resp;
+        return apiResponse;
     }
 }

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

@@ -1,10 +1,10 @@
 import { Response } from 'supertest';
-import { CreateQueryOptions } from '@opra/core';
+import { CreateInstanceQueryOptions } from '@opra/schema';
 import { BaseOperationTester } from './base-operation-tester.js';
 import type { OpraEntityTesterParams } from './entity-tester.js';
 export declare type OpraEntityCreateTesterParams = OpraEntityTesterParams & {
     data: {};
-    options: CreateQueryOptions;
+    options: CreateInstanceQueryOptions;
 };
 export declare class OpraEntityCreateTester extends BaseOperationTester {
     protected readonly _params: OpraEntityCreateTesterParams;

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

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

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

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

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

@@ -1,11 +1,11 @@
 import { Response } from 'supertest';
-import { CreateQueryOptions } from '@opra/core';
+import { CreateInstanceQueryOptions } from '@opra/schema';
 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;
+    options: CreateInstanceQueryOptions;
 };
 export declare class OpraEntityDeleteTester extends BaseOperationTester {
     protected readonly _params: OpraEntityDeleteTesterParams;

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

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

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

@@ -1,11 +1,11 @@
 import { Response } from 'supertest';
-import { GetEntityQueryOptions } from '@opra/core';
+import { GetInstanceQueryOptions } from '@opra/schema';
 import { ResourceKey } from '@opra/url';
 import { BaseOperationTester } from './base-operation-tester.js';
 import type { OpraEntityTesterParams } from './entity-tester';
 export declare type OpraEntityGetTesterParams = OpraEntityTesterParams & {
     keyValue: ResourceKey;
-    options: GetEntityQueryOptions;
+    options: GetInstanceQueryOptions;
 };
 export declare class OpraEntityGetTester extends BaseOperationTester {
     protected readonly _params: OpraEntityGetTesterParams;

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

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

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

@@ -1,17 +1,17 @@
 import { Response } from 'supertest';
-import { SearchQueryOptions } from '@opra/core';
+import { SearchCollectionQueryOptions } from '@opra/schema';
 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;
+    options: SearchCollectionQueryOptions;
 };
 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;
+    count(value?: boolean): this;
     distinct(value: boolean): this;
     sort(...fields: (string | string[])[]): this;
     filter(value: string | Expression): this;

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

@@ -13,7 +13,7 @@ export class OpraEntitySearchTester extends BaseOperationTester {
         this._params.options.skip = value;
         return this;
     }
-    count(value) {
+    count(value = true) {
         this._params.options.count = value;
         return this;
     }

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

@@ -1,4 +1,4 @@
-import { CreateQueryOptions, DeleteManyQueryOption, DeleteQueryOptions, GetEntityQueryOptions, UpdateManyQueryOptions, UpdateQueryOptions } from '@opra/core';
+import { CreateInstanceQueryOptions, DeleteCollectionQueryOption, DeleteInstanceQueryOptions, GetInstanceQueryOptions, UpdateCollectionQueryOptions, UpdateInstanceQueryOptions } from '@opra/schema';
 import { ResourceKey } from '@opra/url';
 import { BaseTester, OpraTesterParams } from './base-tester.js';
 import { OpraEntityCreateTester } from './entity-create-tester.js';
@@ -14,11 +14,11 @@ export declare type OpraEntityTesterParams = OpraTesterParams & {
 export declare class OpraEntityTester extends BaseTester {
     protected readonly _params: OpraEntityTesterParams;
     constructor(params: OpraEntityTesterParams);
-    create(data: {}, options?: CreateQueryOptions): OpraEntityCreateTester;
-    get(keyValue: ResourceKey, options?: GetEntityQueryOptions): OpraEntityGetTester;
-    search(options?: GetEntityQueryOptions): OpraEntitySearchTester;
-    update(keyValue: ResourceKey, data: {}, options?: UpdateQueryOptions): OpraEntityUpdateTester;
-    updateMany(data: {}, options?: UpdateManyQueryOptions): OpraEntityUpdateManyTester;
-    delete(keyValue: ResourceKey, options?: DeleteQueryOptions): OpraEntityDeleteTester;
-    deleteMany(options?: DeleteManyQueryOption): OpraEntityDeleteManyTester;
+    create(data: {}, options?: CreateInstanceQueryOptions): OpraEntityCreateTester;
+    get(keyValue: ResourceKey, options?: GetInstanceQueryOptions): OpraEntityGetTester;
+    search(options?: GetInstanceQueryOptions): OpraEntitySearchTester;
+    update(keyValue: ResourceKey, data: {}, options?: UpdateInstanceQueryOptions): OpraEntityUpdateTester;
+    updateMany(data: {}, options?: UpdateCollectionQueryOptions): OpraEntityUpdateManyTester;
+    delete(keyValue: ResourceKey, options?: DeleteInstanceQueryOptions): OpraEntityDeleteTester;
+    deleteMany(options?: DeleteCollectionQueryOption): OpraEntityDeleteManyTester;
 }

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

@@ -1,14 +1,16 @@
 import { Response } from 'supertest';
-import { UpdateManyQueryOptions } from '@opra/core';
+import { UpdateCollectionQueryOptions } from '@opra/schema';
+import { Expression } from '@opra/url';
 import { BaseOperationTester } from './base-operation-tester.js';
 import type { OpraEntityTesterParams } from './entity-tester.js';
 export declare type OpraEntityUpdateManyTesterParams = OpraEntityTesterParams & {
     data: {};
-    options: UpdateManyQueryOptions;
+    options: UpdateCollectionQueryOptions;
 };
 export declare class OpraEntityUpdateManyTester extends BaseOperationTester {
     protected readonly _params: OpraEntityUpdateManyTesterParams;
     constructor(params: OpraEntityUpdateManyTesterParams);
     data(data: {}): this;
+    filter(value: string | Expression): this;
     protected _send(): Promise<Response>;
 }

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

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

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

@@ -1,12 +1,12 @@
 import { Response } from 'supertest';
-import { UpdateQueryOptions } from '@opra/core';
+import { UpdateInstanceQueryOptions } from '@opra/schema';
 import { ResourceKey } from '@opra/url';
 import { BaseOperationTester } from './base-operation-tester.js';
 import type { OpraEntityTesterParams } from './entity-tester.js';
 export declare type OpraEntityUpdateTesterParams = OpraEntityTesterParams & {
     keyValue: ResourceKey;
     data: {};
-    options: UpdateQueryOptions;
+    options: UpdateInstanceQueryOptions;
 };
 export declare class OpraEntityUpdateTester extends BaseOperationTester {
     protected readonly _params: OpraEntityUpdateTesterParams;

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

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

package/package.json

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

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

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