@opra/testing 0.2.0 → 0.4.0

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

@@ -1,81 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertFilter = exports.ApiExpectArray = void 0;
+exports.convertFilter = exports.ApiExpectCollection = void 0;
 const tslib_1 = require("tslib");
 const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const rule_judgment_1 = tslib_1.__importDefault(require("rule-judgment"));
 const url_1 = require("@opra/url");
-class ApiExpectArray {
+class ApiExpectCollection {
     response;
-    constructor(response) {
+    _isNot;
+    constructor(response, _isNot = false) {
         this.response = response;
+        this._isNot = _isNot;
     }
-    toMatch(expected) {
-        try {
-            const v = lodash_1.default.omitBy(expected, lodash_1.default.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 = lodash_1.default.omitBy(expected, lodash_1.default.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);
@@ -87,9 +83,9 @@ class ApiExpectArray {
         const f = convertFilter(filter);
         if (f) {
             const j = (0, rule_judgment_1.default)(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);
@@ -100,7 +96,7 @@ 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);
@@ -110,7 +106,7 @@ 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);
@@ -120,7 +116,7 @@ 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);
@@ -128,8 +124,14 @@ class ApiExpectArray {
         }
         return this;
     }
+    _expect(expected) {
+        const out = expect(expected);
+        if (this._isNot)
+            return out.not;
+        return out;
+    }
 }
-exports.ApiExpectArray = ApiExpectArray;
+exports.ApiExpectCollection = ApiExpectCollection;
 function convertFilter(str) {
     const ast = typeof str === 'string' ? (0, url_1.$parse)(str) : str;
     if (!ast)

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

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiExpectError = void 0;
 const tslib_1 = require("tslib");
 const jest_matcher_utils_1 = tslib_1.__importDefault(require("jest-matcher-utils"));
+const object_matches_util_js_1 = require("../utils/object-matches.util.js");
 const api_expect_object_js_1 = require("./api-expect-object.js");
-const object_matches_util_js_1 = require("./utils/object-matches.util.js");
 class ApiExpectError extends api_expect_object_js_1.ApiExpectObject {
     response;
     constructor(response) {
@@ -13,9 +13,8 @@ class ApiExpectError extends api_expect_object_js_1.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/cjs/api-expect/api-expect-object.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExpectObject = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+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 = lodash_1.default.omitBy(expected, lodash_1.default.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;
+    }
+}
+exports.ApiExpectObject = ApiExpectObject;

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

@@ -3,15 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiExpectOperationResult = void 0;
 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);
@@ -21,7 +23,7 @@ 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);
@@ -31,7 +33,7 @@ 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);
@@ -39,5 +41,11 @@ class ApiExpectOperationResult {
         }
         return this;
     }
+    _expect(expected) {
+        const out = expect(expected);
+        if (this._isNot)
+            return out.not;
+        return out;
+    }
 }
 exports.ApiExpectOperationResult = ApiExpectOperationResult;

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

@@ -1,24 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiExpect = void 0;
-require("./jest-extend/common.extend.js");
-const api_expect_array_js_1 = require("./api-expect-array.js");
+const api_expect_collection_js_1 = require("./api-expect-collection.js");
 const api_expect_error_js_1 = require("./api-expect-error.js");
 const api_expect_object_js_1 = require("./api-expect-object.js");
 const api_expect_operation_result_js_1 = require("./api-expect-operation-result.js");
 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)
@@ -29,7 +30,7 @@ class ApiExpect {
         return this;
     }
     toFail(status = 400) {
-        let msg = ';';
+        let msg = '';
         try {
             msg = 'Response "status" does not match';
             if (status) {
@@ -40,8 +41,8 @@ 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)
@@ -52,26 +53,26 @@ class ApiExpect {
         return new api_expect_error_js_1.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 api_expect_operation_result_js_1.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)
@@ -81,21 +82,27 @@ class ApiExpect {
         }
         return new api_expect_object_js_1.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 api_expect_array_js_1.ApiExpectArray(this.response);
+        return new api_expect_collection_js_1.ApiExpectCollection(this.response);
+    }
+    _expect(expected) {
+        const out = expect(expected);
+        if (this._isNot)
+            return out.not;
+        return out;
     }
 }
 exports.ApiExpect = ApiExpect;

package/cjs/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectSymbolTag = void 0;
+exports.expectSymbolTag = Symbol('opra.test.expect');

package/cjs/index.js

@@ -1,24 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraTester = exports.opraTest = void 0;
-const base_tester_js_1 = require("./testers/base-tester.js");
-const entity_tester_js_1 = require("./testers/entity-tester.js");
-function opraTest(app, options) {
-    return new OpraTester({
-        app,
-        ...options,
-        prefix: options?.prefix || '',
-        headers: options?.headers || {}
-    });
-}
-exports.opraTest = opraTest;
-class OpraTester extends base_tester_js_1.BaseTester {
-    entity(path) {
-        return new entity_tester_js_1.OpraEntityTester({
-            ...this._params,
-            headers: { ...this._params.headers },
-            path
-        });
-    }
-}
-exports.OpraTester = OpraTester;
+const tslib_1 = require("tslib");
+require("./jest-extend/common.extend.js");
+tslib_1.__exportStar(require("./test-client.js"), exports);

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

@@ -1,32 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const ansi_colors_1 = tslib_1.__importDefault(require("ansi-colors"));
 const jest_matcher_utils_1 = require("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: ${ansi_colors_1.default.yellow('' + expectedKeys)}\n` +
+                `${this.isNot ? 'Unsolicited' : 'Missing'} fields: ${ansi_colors_1.default.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: ${ansi_colors_1.default.yellow('' + expectedKeys)}\n` +
+                (filteredKeys ? `Additional keys received: ${ansi_colors_1.default.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)) {
@@ -38,10 +39,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);
@@ -67,10 +68,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/cjs/test-client.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraTestClient = void 0;
+const tslib_1 = require("tslib");
+const axiosist = tslib_1.__importStar(require("axiosist"));
+const client_1 = require("@opra/client");
+const api_expect_js_1 = require("./api-expect/api-expect.js");
+class OpraTestClient extends client_1.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 api_expect_js_1.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;
+    }
+}
+exports.OpraTestClient = OpraTestClient;

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

@@ -0,0 +1,19 @@
+import { OpraResponse } from '@opra/client';
+import { Expression } from '@opra/url';
+export declare class ApiExpectCollection {
+    readonly response: OpraResponse;
+    protected _isNot: boolean;
+    constructor(response: OpraResponse, _isNot?: boolean);
+    get not(): ApiExpectCollection;
+    forEach(callbackfn: (v: any) => void): this;
+    toMatch<T extends {}>(expected: T): this;
+    toHaveFields(keys: string[]): this;
+    toHaveFieldsOnly(keys: string[]): this;
+    toBeSortedBy(...fields: string[]): this;
+    toBeFilteredBy(filter: string | Expression): this;
+    toHaveExactItems(expected: number): this;
+    toHaveMaxItems(expected: number): this;
+    toHaveMinItems(expected: number): this;
+    protected _expect(expected: any): jest.Matchers<any>;
+}
+export declare function convertFilter(str: string | Expression | undefined): any;