@opra/testing 0.1.1 → 0.2.0

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

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiExpectFail = void 0;
-const api_expect_body_js_1 = require("./api-expect-body.js");
-class ApiExpectFail extends api_expect_body_js_1.ApiExpectBody {
-    _errors;
-    constructor(_errors) {
-        super();
-        this._errors = _errors;
-    }
-    toContain(...issue) {
-        expect(this._errors).toEqual(expect.arrayContaining(issue.map(o => expect.objectContaining(o))));
-    }
-}
-exports.ApiExpectFail = ApiExpectFail;

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

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertFilter = exports.ApiExpectList = void 0;
-const tslib_1 = require("tslib");
-const rule_judgment_1 = tslib_1.__importDefault(require("rule-judgment"));
-const url_1 = require("@opra/url");
-const api_expect_body_js_1 = require("./api-expect-body.js");
-class ApiExpectList extends api_expect_body_js_1.ApiExpectBody {
-    _body;
-    constructor(_body) {
-        super();
-        this._body = _body;
-    }
-    get items() {
-        return this._body.items;
-    }
-    toMatch(value) {
-        return this._toMatchObject(this._body.items || [], value);
-    }
-    haveKeysOnly(keys) {
-        this._haveKeysOnly(this._body.items || [], keys);
-        return this;
-    }
-    haveKeys(keys) {
-        this._haveKeys(this._body.items || [], keys);
-        return this;
-    }
-    notHaveKeys(keys) {
-        this._notHaveKeys(this._body.items || [], keys);
-        return this;
-    }
-    toBeSortedBy(...fields) {
-        const fieldsMap = fields.map(x => x.split('.'));
-        const getValue = (obj, fieldMap) => {
-            let v = obj;
-            let i = 0;
-            while (v && i < fieldMap.length) {
-                v = v[fieldMap[i++]];
-            }
-            return v;
-        };
-        expect(this._body.items).toBeSorted((a, b) => {
-            for (const sortField of fieldsMap) {
-                const l = getValue(a, sortField);
-                const r = getValue(b, sortField);
-                if (l < r)
-                    return -1;
-                if (l > r)
-                    return 1;
-            }
-            return 0;
-        });
-        return this;
-    }
-    toBeFilteredBy(filter) {
-        const f = convertFilter(filter);
-        if (f) {
-            const j = (0, rule_judgment_1.default)(f);
-            const filtered = this._body.items.filter(j);
-            expect(this._body.items).toStrictEqual(filtered);
-        }
-        return this;
-    }
-    toHaveExactItems(expected) {
-        return expect(this._body.items.length).toStrictEqual(expected);
-    }
-    toHaveMaxItems(expected) {
-        return expect(this._body.items.length).toBeLessThanOrEqual(expected);
-    }
-    toHaveMinItems(expected) {
-        return expect(this._body.items.length).toBeGreaterThanOrEqual(expected);
-    }
-}
-exports.ApiExpectList = ApiExpectList;
-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.type} is not implemented yet`);
-}
-exports.convertFilter = convertFilter;

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

@@ -1,6 +0,0 @@
-export declare class ApiExpectBody {
-    protected _toMatchObject<T extends {}>(actuals: any[], expected: T): this;
-    protected _haveKeysOnly(actuals: any[], keys: string[]): this;
-    protected _haveKeys(actuals: any[], keys: string[]): this;
-    protected _notHaveKeys(actuals: any[], keys: string[]): this;
-}

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

@@ -1,32 +0,0 @@
-import _ from 'lodash';
-export class ApiExpectBody {
-    _toMatchObject(actuals, expected) {
-        const v = _.omitBy(expected, _.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;
-    }
-}

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

@@ -1,6 +0,0 @@
-import { ApiExpectBody } from './api-expect-body.js';
-export declare class ApiExpectFail extends ApiExpectBody {
-    protected _errors: any;
-    constructor(_errors: any);
-    toContain(...issue: any[]): void;
-}

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

@@ -1,11 +0,0 @@
-import { ApiExpectBody } from './api-expect-body.js';
-export class ApiExpectFail extends ApiExpectBody {
-    _errors;
-    constructor(_errors) {
-        super();
-        this._errors = _errors;
-    }
-    toContain(...issue) {
-        expect(this._errors).toEqual(expect.arrayContaining(issue.map(o => expect.objectContaining(o))));
-    }
-}

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

@@ -1,17 +0,0 @@
-import { Expression } from '@opra/url';
-import { ApiExpectBody } from './api-expect-body.js';
-export declare class ApiExpectList extends ApiExpectBody {
-    protected _body: any;
-    constructor(_body: any);
-    get items(): any;
-    toMatch<T extends {}>(value: T): this;
-    haveKeysOnly(keys: string[]): this;
-    haveKeys(keys: string[]): this;
-    notHaveKeys(keys: string[]): this;
-    toBeSortedBy(...fields: string[]): this;
-    toBeFilteredBy(filter: string | Expression): this;
-    toHaveExactItems(expected: number): void;
-    toHaveMaxItems(expected: number): void;
-    toHaveMinItems(expected: number): void;
-}
-export declare function convertFilter(str: string | Expression | undefined): any;

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

@@ -1,124 +0,0 @@
-import ruleJudgment from 'rule-judgment';
-import { $parse, ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from '@opra/url';
-import { ApiExpectBody } from './api-expect-body.js';
-export class ApiExpectList extends ApiExpectBody {
-    _body;
-    constructor(_body) {
-        super();
-        this._body = _body;
-    }
-    get items() {
-        return this._body.items;
-    }
-    toMatch(value) {
-        return this._toMatchObject(this._body.items || [], value);
-    }
-    haveKeysOnly(keys) {
-        this._haveKeysOnly(this._body.items || [], keys);
-        return this;
-    }
-    haveKeys(keys) {
-        this._haveKeys(this._body.items || [], keys);
-        return this;
-    }
-    notHaveKeys(keys) {
-        this._notHaveKeys(this._body.items || [], keys);
-        return this;
-    }
-    toBeSortedBy(...fields) {
-        const fieldsMap = fields.map(x => x.split('.'));
-        const getValue = (obj, fieldMap) => {
-            let v = obj;
-            let i = 0;
-            while (v && i < fieldMap.length) {
-                v = v[fieldMap[i++]];
-            }
-            return v;
-        };
-        expect(this._body.items).toBeSorted((a, b) => {
-            for (const sortField of fieldsMap) {
-                const l = getValue(a, sortField);
-                const r = getValue(b, sortField);
-                if (l < r)
-                    return -1;
-                if (l > r)
-                    return 1;
-            }
-            return 0;
-        });
-        return this;
-    }
-    toBeFilteredBy(filter) {
-        const f = convertFilter(filter);
-        if (f) {
-            const j = ruleJudgment(f);
-            const filtered = this._body.items.filter(j);
-            expect(this._body.items).toStrictEqual(filtered);
-        }
-        return this;
-    }
-    toHaveExactItems(expected) {
-        return expect(this._body.items.length).toStrictEqual(expected);
-    }
-    toHaveMaxItems(expected) {
-        return expect(this._body.items.length).toBeLessThanOrEqual(expected);
-    }
-    toHaveMinItems(expected) {
-        return expect(this._body.items.length).toBeGreaterThanOrEqual(expected);
-    }
-}
-export function convertFilter(str) {
-    const ast = typeof str === 'string' ? $parse(str) : str;
-    if (!ast)
-        return;
-    if (ast instanceof ComparisonExpression) {
-        const left = convertFilter(ast.left);
-        const right = convertFilter(ast.right);
-        switch (ast.op) {
-            case '=':
-                return { $eq: { [left]: right } };
-            case '!=':
-                return { $ne: { [left]: right } };
-            case '>':
-                return { $gt: { [left]: right } };
-            case '>=':
-                return { $gte: { [left]: right } };
-            case '<':
-                return { $lt: { [left]: right } };
-            case '<=':
-                return { $lte: { [left]: right } };
-            case 'in':
-                return { $in: { [left]: right } };
-            case '!in':
-                return { $nin: { [left]: right } };
-            default:
-                throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
-        }
-    }
-    if (ast instanceof QualifiedIdentifier) {
-        return ast.value;
-    }
-    if (ast instanceof NumberLiteral ||
-        ast instanceof StringLiteral ||
-        ast instanceof BooleanLiteral ||
-        ast instanceof NullLiteral ||
-        ast instanceof DateLiteral ||
-        ast instanceof TimeLiteral) {
-        return ast.value;
-    }
-    if (ast instanceof ArrayExpression) {
-        return ast.items.map(convertFilter);
-    }
-    if (ast instanceof LogicalExpression) {
-        if (ast.op === 'or')
-            return { $or: ast.items.map(convertFilter) };
-        return { $and: ast.items.map(convertFilter) };
-    }
-    if (ast instanceof ArrayExpression) {
-        return ast.items.map(convertFilter);
-    }
-    if (ast instanceof ParenthesesExpression) {
-        return convertFilter(ast.expression);
-    }
-    throw new Error(`${ast.type} is not implemented yet`);
-}