@opra/testing 0.1.1 → 0.3.0

package/cjs/api-response.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiResponse = void 0;
+const api_expect_js_1 = require("./expect/api-expect.js");
+class ApiResponse {
+    status;
+    body;
+    rawBody;
+    headers;
+    contentType;
+    charset;
+    expect;
+    constructor(args) {
+        Object.assign(this, args);
+        this.expect = new api_expect_js_1.ApiExpect(this);
+    }
+    get(header) {
+        const key = Object.keys(this.headers).find(k => k.toLowerCase() === header.toLowerCase());
+        return (key && this.headers[key]) || '';
+    }
+}
+exports.ApiResponse = ApiResponse;

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

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFilter = exports.ApiExpectArray = 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 {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+    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;
+    }
+    toContainAllKeys(keys) {
+        try {
+            for (const item of this.response.body) {
+                expect(item).toContainAllKeys(keys);
+            }
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainAllKeys);
+            throw e;
+        }
+        return this;
+    }
+    toContainKeys(keys) {
+        try {
+            for (const item of this.response.body) {
+                expect(item).toContainKeys(keys);
+            }
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainKeys);
+            throw e;
+        }
+        return this;
+    }
+    notToContainKeys(keys) {
+        try {
+            for (const item of this.response.body) {
+                expect(item).not.toContainKeys(keys);
+            }
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.notToContainKeys);
+            throw e;
+        }
+        return this;
+    }
+    toHaveProperty(keyPath, value) {
+        try {
+            for (const item of this.response.body) {
+                expect(item).toHaveProperty(keyPath, value);
+            }
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toHaveProperty);
+            throw e;
+        }
+        return this;
+    }
+    toBeSortedBy(...fields) {
+        try {
+            expect(this.response.body).toBeSortedBy(fields);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toBeSortedBy);
+            throw e;
+        }
+        return this;
+    }
+    toBeFilteredBy(filter) {
+        const f = convertFilter(filter);
+        if (f) {
+            const j = (0, rule_judgment_1.default)(f);
+            const filtered = this.response.body.filter(j);
+            try {
+                expect(this.response.body).toStrictEqual(filtered);
+            }
+            catch (e) {
+                Error.captureStackTrace(e, this.toBeFilteredBy);
+                throw e;
+            }
+        }
+        return this;
+    }
+    toHaveExactItems(expected) {
+        try {
+            expect(this.response.body).toHaveLength(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toHaveExactItems);
+            throw e;
+        }
+        return this;
+    }
+    toHaveMaxItems(expected) {
+        try {
+            expect(this.response.body.length).toBeLessThanOrEqual(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toHaveMaxItems);
+            throw e;
+        }
+        return this;
+    }
+    toHaveMinItems(expected) {
+        try {
+            expect(this.response.body.length).toBeGreaterThanOrEqual(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toHaveMinItems);
+            throw e;
+        }
+        return this;
+    }
+}
+exports.ApiExpectArray = ApiExpectArray;
+function convertFilter(str) {
+    const ast = typeof str === 'string' ? (0, url_1.$parse)(str) : str;
+    if (!ast)
+        return;
+    if (ast instanceof url_1.ComparisonExpression) {
+        const left = convertFilter(ast.left);
+        const right = convertFilter(ast.right);
+        switch (ast.op) {
+            case '=':
+                return { $eq: { [left]: right } };
+            case '!=':
+                return { $ne: { [left]: right } };
+            case '>':
+                return { $gt: { [left]: right } };
+            case '>=':
+                return { $gte: { [left]: right } };
+            case '<':
+                return { $lt: { [left]: right } };
+            case '<=':
+                return { $lte: { [left]: right } };
+            case 'in':
+                return { $in: { [left]: right } };
+            case '!in':
+                return { $nin: { [left]: right } };
+            default:
+                throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
+        }
+    }
+    if (ast instanceof url_1.QualifiedIdentifier) {
+        return ast.value;
+    }
+    if (ast instanceof url_1.NumberLiteral ||
+        ast instanceof url_1.StringLiteral ||
+        ast instanceof url_1.BooleanLiteral ||
+        ast instanceof url_1.NullLiteral ||
+        ast instanceof url_1.DateLiteral ||
+        ast instanceof url_1.TimeLiteral) {
+        return ast.value;
+    }
+    if (ast instanceof url_1.ArrayExpression) {
+        return ast.items.map(convertFilter);
+    }
+    if (ast instanceof url_1.LogicalExpression) {
+        if (ast.op === 'or')
+            return { $or: ast.items.map(convertFilter) };
+        return { $and: ast.items.map(convertFilter) };
+    }
+    if (ast instanceof url_1.ArrayExpression) {
+        return ast.items.map(convertFilter);
+    }
+    if (ast instanceof url_1.ParenthesesExpression) {
+        return convertFilter(ast.expression);
+    }
+    throw new Error(`${ast.kind} is not implemented yet`);
+}
+exports.convertFilter = convertFilter;

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

@@ -0,0 +1,62 @@
+"use strict";
+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 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) {
+        super(response);
+        this.response = response;
+    }
+    toContainDetail(...matching) {
+        try {
+            expect(this.response.body['@@Schema']).toStrictEqual('Opra:Exception');
+            expect(this.response.body.issues).toBeDefined();
+            expect(this.response.body.issues).apiErrorDetailToContain(matching);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainDetail);
+            throw e;
+        }
+    }
+}
+exports.ApiExpectError = ApiExpectError;
+expect.extend({
+    apiErrorDetailToContain(received, issues) {
+        try {
+            expect(typeof received).toStrictEqual('object');
+            expect(Array.isArray(received)).toStrictEqual(true);
+        }
+        catch (e) {
+            return {
+                pass: false,
+                message: () => e.message
+            };
+        }
+        for (const m of issues) {
+            let matched = false;
+            for (const detail of received) {
+                if (typeof m === 'object') {
+                    try {
+                        (0, object_matches_util_js_1.objectMatches)(detail, m);
+                        matched = true;
+                        break;
+                    }
+                    catch {
+                        //
+                    }
+                }
+            }
+            if (!matched) {
+                return {
+                    pass: false,
+                    message: () => `Object does not match: \n` + jest_matcher_utils_1.default.stringify(m)
+                };
+            }
+        }
+        return { actual: true, pass: true, message: () => '' };
+    },
+});

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

@@ -1,30 +1,75 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiExpectObject = void 0;
-const api_expect_body_js_1 = require("./api-expect-body.js");
-class ApiExpectObject extends api_expect_body_js_1.ApiExpectBody {
-    _body;
-    constructor(_body) {
-        super();
-        this._body = _body;
-    }
-    toBeDefined() {
-        expect(this._body).toBeDefined();
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+class ApiExpectObject {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+    get body() {
+        return this.response.body;
+    }
+    toMatch(expected) {
+        try {
+            const v = lodash_1.default.omitBy(expected, lodash_1.default.isNil);
+            expect(this.response.body).toMatchObject(v);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toMatch);
+            throw e;
+        }
         return this;
     }
-    toMatch(value) {
-        return this._toMatchObject([this._body], value);
+    toContainAllKeys(keys) {
+        try {
+            expect(this.response.body).toContainAllKeys(keys);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainAllKeys);
+            throw e;
+        }
+        return this;
+    }
+    toContainKeys(keys) {
+        try {
+            expect(this.response.body).toContainKeys(keys);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainKeys);
+            throw e;
+        }
+        return this;
     }
-    haveKeysOnly(keys) {
-        this._haveKeysOnly([this._body], keys);
+    notToContainKeys(keys) {
+        try {
+            expect(this.response.body).not.toContainKeys(keys);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.notToContainKeys);
+            throw e;
+        }
         return this;
     }
-    haveKeys(keys) {
-        this._haveKeys([this._body], keys);
+    toHaveProperty(keyPath, value) {
+        try {
+            expect(this.response.body).toHaveProperty(keyPath, value);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainKeys);
+            throw e;
+        }
         return this;
     }
-    notHaveKeys(keys) {
-        this._notHaveKeys([this._body], keys);
+    notToHaveProperty(keyPath, value) {
+        try {
+            expect(this.response.body).not.toHaveProperty(keyPath, value);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toContainKeys);
+            throw e;
+        }
         return this;
     }
 }

package/cjs/expect/api-expect-operation-result.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExpectOperationResult = void 0;
+class ApiExpectOperationResult {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+    get body() {
+        return this.response.body;
+    }
+    toBeAffectedExact(expected) {
+        try {
+            expect(this.response.body.affected).toStrictEqual(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toBeAffectedExact);
+            throw e;
+        }
+        return this;
+    }
+    toBeAffectedMin(expected) {
+        try {
+            expect(this.response.body.affected).toBeGreaterThanOrEqual(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toBeAffectedMin);
+            throw e;
+        }
+        return this;
+    }
+    toBeAffectedMax(expected) {
+        try {
+            expect(this.response.body.affected).toBeLessThanOrEqual(expected);
+        }
+        catch (e) {
+            Error.captureStackTrace(e, this.toBeAffectedMax);
+            throw e;
+        }
+        return this;
+    }
+}
+exports.ApiExpectOperationResult = ApiExpectOperationResult;

package/cjs/expect/api-expect.js

@@ -1,42 +1,101 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiExpect = void 0;
-require("./jest-extend.js");
-const api_expect_fail_js_1 = require("./api-expect-fail.js");
-const api_expect_list_js_1 = require("./api-expect-list.js");
+require("./jest-extend/common.extend.js");
+const api_expect_array_js_1 = require("./api-expect-array.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) {
         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 api_expect_object_js_1.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 api_expect_error_js_1.ApiExpectError(this.response);
     }
-    toReturnList(fn) {
-        expect(this.response.body).toBeDefined();
-        expect(this.response.body.items).toBeDefined();
-        fn(new api_expect_list_js_1.ApiExpectList(this.response.body));
-        return this;
+    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 api_expect_operation_result_js_1.ApiExpectOperationResult(this.response);
     }
-    toFail(status = 400, fn) {
-        expect(this.response.body.errors).toBeDefined();
-        expect(this.response.status).toEqual(status);
-        if (fn)
-            fn(new api_expect_fail_js_1.ApiExpectFail(this.response.body.errors));
-        return this;
+    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 api_expect_object_js_1.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 api_expect_array_js_1.ApiExpectArray(this.response);
     }
 }
 exports.ApiExpect = ApiExpect;

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

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const jest_matcher_utils_1 = require("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})`
@@ -15,33 +15,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);
@@ -57,6 +57,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/cjs/expect/utils/object-matches.util.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectMatches = void 0;
+function objectMatches(received, expected) {
+    _objectMatches(received, expected, '');
+}
+exports.objectMatches = objectMatches;
+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`);
+        }
+    }
+}