@opra/testing 0.2.0 → 0.4.0

package/esm/{expect/api-expect-array.js → api-expect/api-expect-collection.js}

@@ -1,77 +1,73 @@
 import _ from 'lodash';
 import ruleJudgment from 'rule-judgment';
 import { $parse, ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from '@opra/url';
-export class ApiExpectArray {
+export class ApiExpectCollection {
     response;
-    constructor(response) {
+    _isNot;
+    constructor(response, _isNot = false) {
         this.response = response;
+        this._isNot = _isNot;
     }
-    toMatch(expected) {
-        try {
-            const v = _.omitBy(expected, _.isNil);
-            for (const item of this.response.body) {
-                expect(item).toMatchObject(v);
-            }
-        }
-        catch (e) {
-            Error.captureStackTrace(e, this.toMatch);
-            throw e;
-        }
-        return this;
+    get not() {
+        return new ApiExpectCollection(this.response, !this._isNot);
     }
-    toContainAllKeys(keys) {
-        try {
-            for (const item of this.response.body) {
-                expect(item).toContainAllKeys(keys);
-            }
-        }
-        catch (e) {
-            Error.captureStackTrace(e, this.toContainAllKeys);
-            throw e;
-        }
+    forEach(callbackfn) {
+        this.response.data.forEach(callbackfn);
         return this;
     }
-    toContainKeys(keys) {
+    toMatch(expected) {
         try {
-            for (const item of this.response.body) {
-                expect(item).toContainKeys(keys);
+            const v = _.omitBy(expected, _.isNil);
+            for (const item of this.response.data) {
+                this._expect(item).toMatchObject(v);
             }
         }
         catch (e) {
-            Error.captureStackTrace(e, this.toContainKeys);
+            Error.captureStackTrace(e, this.toMatch);
             throw e;
         }
         return this;
     }
-    notToContainKeys(keys) {
+    toHaveFields(keys) {
         try {
-            for (const item of this.response.body) {
-                expect(item).not.toContainKeys(keys);
+            for (const item of this.response.data) {
+                this._expect(item).toHaveFields(keys);
             }
         }
         catch (e) {
-            Error.captureStackTrace(e, this.notToContainKeys);
+            Error.captureStackTrace(e, this.toHaveFields);
             throw e;
         }
         return this;
     }
-    toHaveProperty(keyPath, value) {
+    toHaveFieldsOnly(keys) {
         try {
-            for (const item of this.response.body) {
-                expect(item).toHaveProperty(keyPath, value);
+            for (const item of this.response.data) {
+                this._expect(item).toHaveFieldsOnly(keys);
             }
         }
         catch (e) {
-            Error.captureStackTrace(e, this.toHaveProperty);
+            Error.captureStackTrace(e, this.toHaveFieldsOnly);
             throw e;
         }
         return this;
     }
+    //
+    // toHaveProperty(keyPath, value?): this {
+    //   try {
+    //     for (const item of this.response.data) {
+    //       this._expect(item).toHaveProperty(keyPath, value);
+    //     }
+    //
+    //   } catch (e: any) {
+    //     Error.captureStackTrace(e, this.toHaveProperty);
+    //     throw e;
+    //   }
+    //   return this;
+    // }
     toBeSortedBy(...fields) {
         try {
-            for (const item of this.response.body) {
-                expect(item).toBeSortedBy(fields);
-            }
+            this._expect(this.response.data).toBeSortedBy(fields);
         }
         catch (e) {
             Error.captureStackTrace(e, this.toBeSortedBy);
@@ -83,9 +79,9 @@ export class ApiExpectArray {
         const f = convertFilter(filter);
         if (f) {
             const j = ruleJudgment(f);
-            const filtered = this.response.body.filter(j);
+            const filtered = this.response.data.filter(j);
             try {
-                expect(this.response.body).toStrictEqual(filtered);
+                this._expect(this.response.data).toStrictEqual(filtered);
             }
             catch (e) {
                 Error.captureStackTrace(e, this.toBeFilteredBy);
@@ -96,7 +92,7 @@ export class ApiExpectArray {
     }
     toHaveExactItems(expected) {
         try {
-            expect(this.response.body).toHaveLength(expected);
+            this._expect(this.response.data).toHaveLength(expected);
         }
         catch (e) {
             Error.captureStackTrace(e, this.toHaveExactItems);
@@ -106,7 +102,7 @@ export class ApiExpectArray {
     }
     toHaveMaxItems(expected) {
         try {
-            expect(this.response.body.length).toBeLessThanOrEqual(expected);
+            this._expect(this.response.data.length).toBeLessThanOrEqual(expected);
         }
         catch (e) {
             Error.captureStackTrace(e, this.toHaveMaxItems);
@@ -116,7 +112,7 @@ export class ApiExpectArray {
     }
     toHaveMinItems(expected) {
         try {
-            expect(this.response.body.length).toBeGreaterThanOrEqual(expected);
+            this._expect(this.response.data.length).toBeGreaterThanOrEqual(expected);
         }
         catch (e) {
             Error.captureStackTrace(e, this.toHaveMinItems);
@@ -124,6 +120,12 @@ export class ApiExpectArray {
         }
         return this;
     }
+    _expect(expected) {
+        const out = expect(expected);
+        if (this._isNot)
+            return out.not;
+        return out;
+    }
 }
 export function convertFilter(str) {
     const ast = typeof str === 'string' ? $parse(str) : str;

package/esm/{expect → api-expect}/api-expect-error.d.ts

@@ -1,8 +1,8 @@
-import type { ApiResponse } from '../api-response';
+import { OpraResponse } from '@opra/client';
 import { ApiExpectObject } from './api-expect-object.js';
 export declare class ApiExpectError extends ApiExpectObject {
-    readonly response: ApiResponse;
-    constructor(response: ApiResponse);
+    readonly response: OpraResponse;
+    constructor(response: OpraResponse);
     toContainDetail(...matching: any[]): void;
 }
 declare global {

package/esm/{expect → api-expect}/api-expect-error.js

@@ -1,6 +1,6 @@
 import matcherUtils from 'jest-matcher-utils';
+import { objectMatches } from '../utils/object-matches.util.js';
 import { ApiExpectObject } from './api-expect-object.js';
-import { objectMatches } from './utils/object-matches.util.js';
 export class ApiExpectError extends ApiExpectObject {
     response;
     constructor(response) {
@@ -9,9 +9,8 @@ export class ApiExpectError extends ApiExpectObject {
     }
     toContainDetail(...matching) {
         try {
-            expect(this.response.body['@@Schema']).toStrictEqual('Opra:Exception');
-            expect(this.response.body.issues).toBeDefined();
-            expect(this.response.body.issues).apiErrorDetailToContain(matching);
+            expect(this.response.data.issues).toBeDefined();
+            expect(this.response.data.issues).apiErrorDetailToContain(matching);
         }
         catch (e) {
             Error.captureStackTrace(e, this.toContainDetail);

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

@@ -0,0 +1,11 @@
+import { OpraResponse } from '@opra/client';
+export declare class ApiExpectObject {
+    readonly response: OpraResponse;
+    protected _isNot: boolean;
+    constructor(response: OpraResponse, _isNot?: boolean);
+    get not(): ApiExpectObject;
+    toMatch<T extends {}>(expected: T): this;
+    toHaveFields(fields: string[]): this;
+    toHaveFieldsOnly(fields: string[]): this;
+    protected _expect(expected: any): jest.Matchers<any>;
+}

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

@@ -0,0 +1,49 @@
+import _ from 'lodash';
+export class ApiExpectObject {
+    response;
+    _isNot;
+    constructor(response, _isNot = false) {
+        this.response = response;
+        this._isNot = _isNot;
+    }
+    get not() {
+        return new ApiExpectObject(this.response, !this._isNot);
+    }
+    toMatch(expected) {
+        try {
+            const v = _.omitBy(expected, _.isNil);
+            this._expect(this.response.data).toMatchObject(v);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toMatch);
+            throw e;
+        }
+        return this;
+    }
+    toHaveFields(fields) {
+        try {
+            this._expect(this.response.data).toHaveFields(fields);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toHaveFields);
+            throw e;
+        }
+        return this;
+    }
+    toHaveFieldsOnly(fields) {
+        try {
+            this._expect(this.response.data).toHaveFieldsOnly(fields);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toHaveFieldsOnly);
+            throw e;
+        }
+        return this;
+    }
+    _expect(expected) {
+        const out = expect(expected);
+        if (this._isNot)
+            return out.not;
+        return out;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { OpraResponse } from '@opra/client';
+export declare class ApiExpectOperationResult {
+    readonly response: OpraResponse;
+    protected _isNot: boolean;
+    constructor(response: OpraResponse, _isNot?: boolean);
+    get not(): ApiExpectOperationResult;
+    toBeAffectedExact(expected: number): this;
+    toBeAffectedMin(expected: number): this;
+    toBeAffectedMax(expected: number): this;
+    protected _expect(expected: any): jest.Matchers<any>;
+}

package/esm/{expect → api-expect}/api-expect-operation-result.js

@@ -1,14 +1,16 @@
 export class ApiExpectOperationResult {
     response;
-    constructor(response) {
+    _isNot;
+    constructor(response, _isNot = false) {
         this.response = response;
+        this._isNot = _isNot;
     }
-    get body() {
-        return this.response.body;
+    get not() {
+        return new ApiExpectOperationResult(this.response, !this._isNot);
     }
     toBeAffectedExact(expected) {
         try {
-            expect(this.response.body.affected).toStrictEqual(expected);
+            this._expect(this.response.data.affected).toStrictEqual(expected);
         }
         catch (e) {
             Error.captureStackTrace(e, this.toBeAffectedExact);
@@ -18,7 +20,7 @@ export class ApiExpectOperationResult {
     }
     toBeAffectedMin(expected) {
         try {
-            expect(this.response.body.affected).toBeGreaterThanOrEqual(expected);
+            this._expect(this.response.data.affected).toBeGreaterThanOrEqual(expected);
         }
         catch (e) {
             Error.captureStackTrace(e, this.toBeAffectedMin);
@@ -28,7 +30,7 @@ export class ApiExpectOperationResult {
     }
     toBeAffectedMax(expected) {
         try {
-            expect(this.response.body.affected).toBeLessThanOrEqual(expected);
+            this._expect(this.response.data.affected).toBeLessThanOrEqual(expected);
         }
         catch (e) {
             Error.captureStackTrace(e, this.toBeAffectedMax);
@@ -36,4 +38,10 @@ export class ApiExpectOperationResult {
         }
         return this;
     }
+    _expect(expected) {
+        const out = expect(expected);
+        if (this._isNot)
+            return out.not;
+        return out;
+    }
 }

package/esm/{expect → api-expect}/api-expect.d.ts

@@ -1,16 +1,17 @@
-import './jest-extend/common.extend.js';
-import type { ApiResponse } from '../api-response';
-import { ApiExpectArray } from './api-expect-array.js';
+import { OpraResponse } from '@opra/client';
+import { ApiExpectCollection } from './api-expect-collection.js';
 import { ApiExpectError } from './api-expect-error.js';
 import { ApiExpectObject } from './api-expect-object.js';
 import { ApiExpectOperationResult } from './api-expect-operation-result.js';
 export declare class ApiExpect {
-    readonly response: ApiResponse;
-    constructor(response: ApiResponse);
-    get body(): any;
+    readonly response: OpraResponse;
+    protected _isNot: boolean;
+    constructor(response: OpraResponse, _isNot?: boolean);
+    get not(): ApiExpect;
     toSuccess(status?: number): this;
     toFail(status?: number): ApiExpectError;
     toReturnOperationResult(): ApiExpectOperationResult;
     toReturnObject(): ApiExpectObject;
-    toReturnArray(): ApiExpectArray;
+    toReturnCollection(): ApiExpectCollection;
+    protected _expect(expected: any): jest.Matchers<any>;
 }

package/esm/{expect → api-expect}/api-expect.js

@@ -1,21 +1,22 @@
-import './jest-extend/common.extend.js';
-import { ApiExpectArray } from './api-expect-array.js';
+import { ApiExpectCollection } from './api-expect-collection.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) {
+    _isNot;
+    constructor(response, _isNot = false) {
         this.response = response;
+        this._isNot = _isNot;
     }
-    get body() {
-        return this.response.body;
+    get not() {
+        return new ApiExpect(this.response, !this._isNot);
     }
     toSuccess(status = 200) {
-        let msg = ';';
+        let msg = '';
         try {
-            msg = 'Response "status" is not valid';
-            expect(this.response.status).toStrictEqual(status);
+            msg = 'Unexpected "status" returned';
+            this._expect(this.response.status).toStrictEqual(status);
         }
         catch (e) {
             if (msg)
@@ -26,7 +27,7 @@ export class ApiExpect {
         return this;
     }
     toFail(status = 400) {
-        let msg = ';';
+        let msg = '';
         try {
             msg = 'Response "status" does not match';
             if (status) {
@@ -37,8 +38,8 @@ export class ApiExpect {
                 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);
+            expect(this.response.data.errors).toBeArray();
+            expect(this.response.data.errors.length).toBeGreaterThan(0);
         }
         catch (e) {
             if (msg)
@@ -49,26 +50,26 @@ export class ApiExpect {
         return new ApiExpectError(this.response);
     }
     toReturnOperationResult() {
-        let msg = ';';
+        let msg = '';
         try {
             msg = '"body" is empty';
-            expect(this.response.body).toBeDefined();
+            expect(this.response.data).toBeDefined();
             msg = '"operation" property is empty';
-            expect(this.response.body.operation).toBeDefined();
+            expect(this.response.data.operation).toBeDefined();
         }
         catch (e) {
             if (msg)
                 e.message = msg + '\n\n' + e.message;
-            Error.captureStackTrace(e, this.toReturnObject);
+            Error.captureStackTrace(e, this.toReturnOperationResult);
             throw e;
         }
         return new ApiExpectOperationResult(this.response);
     }
     toReturnObject() {
-        let msg = ';';
+        let msg = '';
         try {
             msg = '"body" is empty';
-            expect(this.response.body).toBeDefined();
+            expect(this.response.data).toBeDefined();
         }
         catch (e) {
             if (msg)
@@ -78,20 +79,26 @@ export class ApiExpect {
         }
         return new ApiExpectObject(this.response);
     }
-    toReturnArray() {
-        let msg = ';';
+    toReturnCollection() {
+        let msg = '';
         try {
             msg = '"body" is empty';
-            expect(this.response.body).toBeDefined();
+            expect(this.response.data).toBeDefined();
             msg = '"body" is not an array';
-            expect(this.response.body).toBeArray();
+            expect(this.response.data).toBeArray();
         }
         catch (e) {
             if (msg)
                 e.message = msg + '\n\n' + e.message;
-            Error.captureStackTrace(e, this.toReturnArray);
+            Error.captureStackTrace(e, this.toReturnCollection);
             throw e;
         }
-        return new ApiExpectArray(this.response);
+        return new ApiExpectCollection(this.response);
+    }
+    _expect(expected) {
+        const out = expect(expected);
+        if (this._isNot)
+            return out.not;
+        return out;
     }
 }

package/esm/constants.d.ts

@@ -0,0 +1 @@
+export declare const expectSymbolTag: unique symbol;

package/esm/constants.js

@@ -0,0 +1 @@
+export const expectSymbolTag = Symbol('opra.test.expect');

package/esm/index.d.ts

@@ -1,6 +1,2 @@
-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 class OpraTester extends BaseTester {
-    entity(path: string): OpraEntityTester;
-}
+import './jest-extend/common.extend.js';
+export * from './test-client.js';

package/esm/index.js

@@ -1,19 +1,2 @@
-import { BaseTester } from './testers/base-tester.js';
-import { OpraEntityTester } from './testers/entity-tester.js';
-export function opraTest(app, options) {
-    return new OpraTester({
-        app,
-        ...options,
-        prefix: options?.prefix || '',
-        headers: options?.headers || {}
-    });
-}
-export class OpraTester extends BaseTester {
-    entity(path) {
-        return new OpraEntityTester({
-            ...this._params,
-            headers: { ...this._params.headers },
-            path
-        });
-    }
-}
+import './jest-extend/common.extend.js';
+export * from './test-client.js';

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

@@ -1,8 +1,8 @@
 declare global {
     namespace jest {
         interface Matchers<R> {
-            toContainKeys(expected: string[]): any;
-            toContainAllKeys(expected: string[]): any;
+            toHaveFields(expected: string[]): any;
+            toHaveFieldsOnly(expected: string[]): any;
             toBeArray(): any;
             toBeSorted(compareFn?: (a: any, b: any) => number): any;
             toBeSortedBy(properties: string[]): any;

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

@@ -1,30 +1,30 @@
+import colors from "ansi-colors";
 import { matcherHint, printExpected, printReceived } from 'jest-matcher-utils';
 expect.extend({
-    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 (!Object.keys(received).find(x => keys.includes(x))) {
-                return {
-                    pass: false,
-                    message: () => `Object contains unexpected additional keys (${additionalKeys})`
-                };
-            }
+    toHaveFields(received, expected) {
+        const expectedKeys = (Array.isArray(expected) ? expected : Object.keys(expected)).map(x => x.toLowerCase());
+        const objectKeys = Object.keys(received).map(x => x.toLowerCase());
+        const filteredKeys = expectedKeys.filter(x => !objectKeys.includes(x));
+        const pass = !filteredKeys.length === !this.isNot;
+        if (!pass) {
+            const message = () => `Expects keys to${this.isNot ? ' not' : ''} contain: ${colors.yellow('' + expectedKeys)}\n` +
+                `${this.isNot ? 'Unsolicited' : 'Missing'} fields: ${colors.yellow('' + filteredKeys)}\n`;
+            return { message, pass: !!this.isNot };
         }
-        return { actual: received, pass: true, message: () => '' };
+        return { actual: received, pass: !this.isNot, message: () => '' };
     },
-    toContainAllKeys(received, expected) {
-        if (typeof received === 'object') {
-            const keys = Array.isArray(expected) ? expected : Object.keys(expected);
-            const additionalKeys = Object.keys(received).filter(x => !keys.includes(x));
-            if (additionalKeys.length) {
-                return {
-                    pass: false,
-                    message: () => `Object contains unexpected additional keys (${additionalKeys})`
-                };
-            }
+    toHaveFieldsOnly(received, expected) {
+        const expectedKeys = (Array.isArray(expected) ? expected : Object.keys(expected)).map(x => x.toLowerCase());
+        const objectKeys = Object.keys(received).map(x => x.toLowerCase());
+        const filteredKeys = objectKeys.filter(x => !expectedKeys.includes(x));
+        const pass = !filteredKeys.length === !this.isNot;
+        if (!pass) {
+            const message = () => `${!this.isNot ? 'Do not expects' : 'Expects'} additional keys other than: ${colors.yellow('' + expectedKeys)}\n` +
+                (filteredKeys ? `Additional keys received: ${colors.yellow('' + filteredKeys)}\n` :
+                    'No additional keys received\n');
+            return { message, pass };
         }
-        return { actual: received, pass: true, message: () => '' };
+        return { actual: received, pass: !this.isNot, message: () => '' };
     },
     toBeArray(received) {
         if (Array.isArray(received)) {
@@ -36,10 +36,10 @@ expect.extend({
         };
     },
     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);
@@ -65,10 +65,10 @@ expect.extend({
             }
             return v;
         };
-        let pass = Array.isArray(received);
+        let pass = true;
         let message;
         if (pass) {
-            const sorted = [...received];
+            const sorted = [...(received || [])];
             sorted.sort((a, b) => {
                 for (const sortField of fieldsMap) {
                     const l = getValue(a, sortField);

package/esm/test-client.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { AxiosRequestConfig } from 'axios';
+import { IncomingMessage, Server, ServerResponse } from 'http';
+import { CollectionService, CommonRequestOptions, OpraClient, OpraClientOptions, OpraResponse } from '@opra/client';
+import { SingletonService } from '@opra/client/src/services/singleton-service';
+import { ApiExpect } from './api-expect/api-expect.js';
+declare type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
+declare type Handler = RequestListener | Server;
+declare type OpraTestResponse<T = any> = OpraResponse<T> & {
+    expect: ApiExpect;
+};
+export declare class OpraTestClient extends OpraClient {
+    collection<T = any, TResponse extends OpraTestResponse<T> = OpraTestResponse<T>>(name: string): CollectionService<T, TResponse>;
+    singleton<T = any, TResponse extends OpraTestResponse<T> = OpraTestResponse<T>>(name: string): SingletonService<T, TResponse>;
+    protected _send(req: AxiosRequestConfig, options: CommonRequestOptions): Promise<OpraTestResponse>;
+    static create(app: Handler, options?: OpraClientOptions): Promise<OpraTestClient>;
+}
+export {};

package/esm/test-client.js

@@ -0,0 +1,27 @@
+import * as axiosist from 'axiosist';
+import { OpraClient } from '@opra/client';
+import { ApiExpect } from './api-expect/api-expect.js';
+export class OpraTestClient extends OpraClient {
+    // @ts-ignore
+    collection(name) {
+        return super.collection(name);
+    }
+    // @ts-ignore
+    singleton(name) {
+        return super.singleton(name);
+    }
+    async _send(req, options) {
+        const resp = (await super._send(req, options));
+        resp.expect = new ApiExpect(resp);
+        return resp;
+    }
+    static async create(app, options) {
+        const instance = await super.create('/', {
+            validateStatus: false,
+            ...options,
+            adapter: axiosist.createAdapter(app)
+        });
+        Object.setPrototypeOf(instance, OpraTestClient.prototype);
+        return instance;
+    }
+}