@opra/testing 0.29.0 → 0.30.0

package/cjs/jest-extend/common.extend.js

@@ -38,65 +38,6 @@ expect.extend({
             message: () => 'Value is not an array'
         };
     },
-    toBeSorted(received, compareFn) {
-        let pass = true;
-        let message;
-        if (pass) {
-            const sorted = [...(received || [])];
-            sorted.sort(compareFn);
-            try {
-                expect(received).toEqual(sorted);
-            }
-            catch (e) {
-                pass = false;
-                message = () => 'Array items is not sorted as expected';
-            }
-        }
-        return {
-            actual: received,
-            message,
-            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/utils/object-matches.util.js

@@ -20,13 +20,15 @@ function _objectMatches(received, expected, path) {
                 throw new Error(`Property "${k}" does not match`);
             }
         }
-        if (ev && typeof ev === 'object')
+        else 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`);
         }
+        else
+            try {
+                expect(rv).toEqual(ev);
+            }
+            catch {
+                throw new Error(`Property "${k}" does not match`);
+            }
     }
 }

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

@@ -0,0 +1,13 @@
+import '../jest-extend/index.js';
+export class ApiExpectBase {
+    constructor(response, isNot) {
+        this.response = response;
+        this.isNot = isNot;
+    }
+    _expect(expected) {
+        const out = expect(expected);
+        if (this.isNot)
+            return out.not;
+        return out;
+    }
+}

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

@@ -1,28 +1,61 @@
-import '../jest-extend/index.js';
 import isNil from 'lodash.isnil';
 import omitBy from 'lodash.omitby';
 import ruleJudgmentLib from 'rule-judgment';
 import { OpraFilter } from '@opra/common';
+import { ApiExpectBase } from './api-expect-base.js';
 // @ts-ignore
 const ruleJudgment = typeof ruleJudgmentLib === 'object' ? ruleJudgmentLib.default : ruleJudgmentLib;
-export class ApiExpectCollection {
-    constructor(response, _isNot = false) {
-        this.response = response;
-        this._isNot = _isNot;
-    }
+export class ApiExpectCollection extends ApiExpectBase {
     get not() {
-        return new ApiExpectCollection(this.response, !this._isNot);
+        return new ApiExpectCollection(this.response, !this.isNot);
+    }
+    /**
+     * Tests if Collection have number of items in payload
+     * @param min Minimum number of items. Default 1
+     * @param max Maximum number of items
+     */
+    toReturnItems(min, max) {
+        let msg = '';
+        try {
+            msg += `The length of payload array do not match. `;
+            const l = this.response.body.payload.length;
+            this._expect(l).toBeGreaterThanOrEqual(min || 1);
+            if (max)
+                this._expect(l).toBeLessThanOrEqual(max);
+        }
+        catch (e) {
+            if (msg)
+                e.message = msg + '\n\n' + e.message;
+            Error.captureStackTrace(e, this.toReturnItems);
+            throw e;
+        }
+        return this;
     }
-    forEach(callbackfn) {
-        this.response.body.forEach(callbackfn);
+    toContainTotalMatches(min, max) {
+        let msg = '';
+        try {
+            msg += `The value of "totalMatches" do not match. `;
+            const l = this.response.body.totalMatches;
+            this._expect(l).toBeGreaterThanOrEqual(min || 1);
+            if (max)
+                this._expect(l).toBeLessThanOrEqual(max);
+        }
+        catch (e) {
+            if (msg)
+                e.message = msg + '\n\n' + e.message;
+            Error.captureStackTrace(e, this.toReturnItems);
+            throw e;
+        }
         return this;
     }
+    /**
+     * Tests if Collection items matches given object
+     * @param expected
+     */
     toMatch(expected) {
         try {
-            const v = omitBy(expected, isNil);
-            for (const item of this.response.body.payload) {
-                this._expect(item).toMatchObject(v);
-            }
+            expected = omitBy(expected, isNil);
+            this._expect(this.response.body.payload).toEqual(expect.arrayContaining([expect.objectContaining(expected)]));
         }
         catch (e) {
             Error.captureStackTrace(e, this.toMatch);
@@ -30,46 +63,49 @@ export class ApiExpectCollection {
         }
         return this;
     }
-    toHaveFields(keys) {
+    /**
+     * Tests if Collection items has all of provided fields.
+     * @param fields
+     */
+    toContainFields(fields) {
         try {
+            fields = Array.isArray(fields) ? fields : [fields];
             for (const item of this.response.body.payload) {
-                this._expect(item).toHaveFields(keys);
+                this._expect(Object.keys(item)).toEqual(expect.arrayContaining(fields));
             }
         }
         catch (e) {
-            Error.captureStackTrace(e, this.toHaveFields);
+            Error.captureStackTrace(e, this.toContainFields);
             throw e;
         }
         return this;
     }
-    toHaveFieldsOnly(keys) {
+    /**
+     * Tests if Collection items only contains all of provided fields.
+     * @param fields
+     */
+    toContainAllFields(fields) {
         try {
+            fields = Array.isArray(fields) ? fields : [fields];
             for (const item of this.response.body.payload) {
-                this._expect(item).toHaveFieldsOnly(keys);
+                this._expect(Object.keys(item)).toEqual(fields);
             }
         }
         catch (e) {
-            Error.captureStackTrace(e, this.toHaveFieldsOnly);
+            Error.captureStackTrace(e, this.toContainAllFields);
             throw e;
         }
         return this;
     }
-    //
-    // toHaveProperty(keyPath, value?): this {
-    //   try {
-    //     for (const item of this.response.payload) {
-    //       this._expect(item).toHaveProperty(keyPath, value);
-    //     }
-    //
-    //   } catch (e: any) {
-    //     Error.captureStackTrace(e, this.toHaveProperty);
-    //     throw e;
-    //   }
-    //   return this;
-    // }
-    toBeSortedBy(...fields) {
+    /**
+     * Tests if Collection is sorted by given field(s).
+     * @param fields
+     */
+    toBeSortedBy(fields) {
         try {
-            this._expect(this.response.body.payload).toBeSortedBy(fields);
+            fields = Array.isArray(fields) ? fields : [fields];
+            this._expect(this.response.body.payload)
+                .opraCollectionToBeSortedBy(fields);
         }
         catch (e) {
             Error.captureStackTrace(e, this.toBeSortedBy);
@@ -77,6 +113,10 @@ export class ApiExpectCollection {
         }
         return this;
     }
+    /**
+     * Tests if Collection is filtered by given condition.
+     * @param filter
+     */
     toBeFilteredBy(filter) {
         const f = convertFilter(filter);
         if (f) {
@@ -92,43 +132,48 @@ export class ApiExpectCollection {
         }
         return this;
     }
-    toHaveExactItems(expected) {
-        try {
-            this._expect(this.response.body.dapayloadta).toHaveLength(expected);
-        }
-        catch (e) {
-            Error.captureStackTrace(e, this.toHaveExactItems);
-            throw e;
-        }
-        return this;
-    }
-    toHaveMaxItems(expected) {
-        try {
-            this._expect(this.response.body.payload.length).toBeLessThanOrEqual(expected);
-        }
-        catch (e) {
-            Error.captureStackTrace(e, this.toHaveMaxItems);
-            throw e;
-        }
-        return this;
-    }
-    toHaveMinItems(expected) {
-        try {
-            this._expect(this.response.body.payload.length).toBeGreaterThanOrEqual(expected);
-        }
-        catch (e) {
-            Error.captureStackTrace(e, this.toHaveMinItems);
-            throw e;
-        }
-        return this;
-    }
-    _expect(expected) {
-        const out = expect(expected);
-        if (this._isNot)
-            return out.not;
-        return out;
-    }
 }
+expect.extend({
+    opraCollectionToBeSortedBy(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 = () => 'Items are not sorted as expected';
+            }
+        }
+        return {
+            actual: received,
+            message,
+            pass
+        };
+    },
+});
 export function convertFilter(str) {
     const ast = typeof str === 'string' ? OpraFilter.parse(str) : str;
     if (!ast)

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

@@ -1,57 +1,21 @@
 import '../jest-extend/index.js';
-import matcherUtils from 'jest-matcher-utils';
-import { objectMatches } from '../utils/object-matches.util.js';
-import { ApiExpectObject } from './api-expect-object.js';
-export class ApiExpectError extends ApiExpectObject {
-    constructor(response) {
-        super(response);
-        this.response = response;
-    }
-    toContainDetail(...matching) {
+import isNil from 'lodash.isnil';
+import omitBy from 'lodash.omitby';
+import { ApiExpectBase } from './api-expect-base.js';
+export class ApiExpectError extends ApiExpectBase {
+    toMatch(expected) {
         try {
-            expect(this.response.body).toBeDefined();
-            expect(this.response.body.issues).toBeDefined();
-            expect(this.response.body.issues).apiErrorDetailToContain(matching);
+            if (typeof expected === 'string')
+                expected = { message: expected };
+            else if (expected instanceof RegExp)
+                expected = { message: expect.stringMatching(expected) };
+            expected = omitBy(expected, isNil);
+            this._expect(this.response.body.errors).toEqual(expect.arrayContaining([expect.objectContaining(expected)]));
         }
         catch (e) {
-            Error.captureStackTrace(e, this.toContainDetail);
+            Error.captureStackTrace(e, this.toMatch);
             throw e;
         }
+        return this;
     }
 }
-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 {
-                        objectMatches(detail, m);
-                        matched = true;
-                        break;
-                    }
-                    catch {
-                        //
-                    }
-                }
-            }
-            if (!matched) {
-                return {
-                    pass: false,
-                    message: () => `Object does not match: \n` + matcherUtils.stringify(m)
-                };
-            }
-        }
-        return { actual: true, pass: true, message: () => '' };
-    },
-});

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

@@ -1,18 +1,18 @@
-import '../jest-extend/index.js';
 import isNil from 'lodash.isnil';
 import omitBy from 'lodash.omitby';
-export class ApiExpectObject {
-    constructor(response, _isNot = false) {
-        this.response = response;
-        this._isNot = _isNot;
-    }
+import { ApiExpectBase } from './api-expect-base.js';
+export class ApiExpectObject extends ApiExpectBase {
     get not() {
-        return new ApiExpectObject(this.response, !this._isNot);
+        return new ApiExpectObject(this.response, !this.isNot);
     }
+    /**
+     * Tests if Response payload matches given object
+     * @param expected
+     */
     toMatch(expected) {
         try {
-            const v = omitBy(expected, isNil);
-            this._expect(this.response.body.payload).toMatchObject(v);
+            expected = omitBy(expected, isNil);
+            this._expect(this.response.body.payload).toEqual(expect.objectContaining(expected));
         }
         catch (e) {
             Error.captureStackTrace(e, this.toMatch);
@@ -20,30 +20,36 @@ export class ApiExpectObject {
         }
         return this;
     }
-    toHaveFields(fields) {
+    /**
+     * Tests if Response payload has all of provided fields.
+     * @param fields
+     */
+    toContainFields(fields) {
         try {
-            this._expect(this.response.body.payload).toHaveFields(fields);
+            fields = Array.isArray(fields) ? fields : [fields];
+            this._expect(Object.keys(this.response.body.payload))
+                .toEqual(expect.arrayContaining(fields));
         }
         catch (e) {
-            Error.captureStackTrace(e, this.toHaveFields);
+            Error.captureStackTrace(e, this.toContainFields);
             throw e;
         }
         return this;
     }
-    toHaveFieldsOnly(fields) {
+    /**
+     * Tests if Response payload only contains all of provided fields.
+     * @param fields
+     */
+    toContainAllFields(fields) {
         try {
-            this._expect(this.response.body.payload).toHaveFieldsOnly(fields);
+            fields = Array.isArray(fields) ? fields : [fields];
+            this._expect(Object.keys(this.response.body.payload))
+                .toEqual(fields);
         }
         catch (e) {
-            Error.captureStackTrace(e, this.toHaveFieldsOnly);
+            Error.captureStackTrace(e, this.toContainAllFields);
             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.js

@@ -1,46 +1,24 @@
 import '../jest-extend/index.js';
-export class ApiExpectOperationResult {
-    constructor(response, _isNot = false) {
-        this.response = response;
-        this._isNot = _isNot;
-    }
+import { ApiExpectBase } from './api-expect-base.js';
+export class ApiExpectOperationResult extends ApiExpectBase {
     get not() {
-        return new ApiExpectOperationResult(this.response, !this._isNot);
-    }
-    toBeAffectedExact(expected) {
-        try {
-            this._expect(this.response.body.affected).toStrictEqual(expected);
-        }
-        catch (e) {
-            Error.captureStackTrace(e, this.toBeAffectedExact);
-            throw e;
-        }
-        return this;
+        return new ApiExpectOperationResult(this.response, !this.isNot);
     }
-    toBeAffectedMin(expected) {
+    toBeAffected(min, max) {
+        let msg = '';
         try {
-            this._expect(this.response.body.affected).toBeGreaterThanOrEqual(expected);
+            msg += `The value of "affected" do not match. `;
+            const l = this.response.body.affected;
+            this._expect(l).toBeGreaterThanOrEqual(min || 1);
+            if (max)
+                this._expect(l).toBeLessThanOrEqual(max);
         }
         catch (e) {
-            Error.captureStackTrace(e, this.toBeAffectedMin);
+            if (msg)
+                e.message = msg + '\n\n' + e.message;
+            Error.captureStackTrace(e, this.toBeAffected);
             throw e;
         }
         return this;
     }
-    toBeAffectedMax(expected) {
-        try {
-            this._expect(this.response.body.affected).toBeLessThanOrEqual(expected);
-        }
-        catch (e) {
-            Error.captureStackTrace(e, this.toBeAffectedMax);
-            throw e;
-        }
-        return this;
-    }
-    _expect(expected) {
-        const out = expect(expected);
-        if (this._isNot)
-            return out.not;
-        return out;
-    }
 }