@stamhoofd/sql 2.83.5 → 2.84.1

package/dist/tests/filters/$eq.test.js

@@ -0,0 +1,986 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SQLModernFilter_1 = require("../../src/filters/modern/SQLModernFilter");
+const SQL_1 = require("../../src/SQL");
+const utils_1 = require("../utils");
+describe('$eq', () => {
+    /**
+     * Tests that should be repeated for all filter types
+     */
+    describe('Common checks', () => {
+        it('Cannot be used at the root level', async () => {
+            const filters = {
+                ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            };
+            await (0, utils_1.testMultipleErrors)({
+                testFilters: [
+                    {
+                        $eq: 'value',
+                    },
+                    {
+                        $and: [
+                            {
+                                $eq: 'value',
+                            },
+                        ],
+                    },
+                    'value',
+                ],
+                filters,
+                error: 'Cannot compare at root level',
+            });
+        });
+    });
+    it('removes caps when filtering strings', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: false }),
+        };
+        // Caps are removed
+        await (0, utils_1.test)({
+            filter: {
+                name: {
+                    $eq: 'John Doe',
+                },
+            },
+            filters,
+            query: {
+                query: '`default`.`name` = ?',
+                params: ['john doe'],
+            },
+        });
+    });
+    it('converts true to 1', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            enabled: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('enabled'), type: SQLModernFilter_1.SQLModernValueType.Boolean, nullable: false }),
+        };
+        await (0, utils_1.testMultiple)({
+            testFilters: [
+                {
+                    enabled: true,
+                },
+                {
+                    enabled: {
+                        $eq: true,
+                    },
+                },
+            ],
+            filters,
+            query: {
+                query: '`default`.`enabled` = ?',
+                params: [1],
+            },
+        });
+    });
+    it('converts false to 0', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            enabled: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('enabled'), type: SQLModernFilter_1.SQLModernValueType.Boolean, nullable: false }),
+        };
+        await (0, utils_1.testMultiple)({
+            testFilters: [
+                {
+                    enabled: false,
+                },
+                {
+                    enabled: {
+                        $eq: false,
+                    },
+                },
+            ],
+            filters,
+            query: {
+                query: '`default`.`enabled` = ?',
+                params: [0],
+            },
+        });
+    });
+    it('allows  1 as true', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            enabled: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('enabled'), type: SQLModernFilter_1.SQLModernValueType.Boolean, nullable: false }),
+        };
+        await (0, utils_1.testMultiple)({
+            testFilters: [
+                {
+                    enabled: 1,
+                },
+                {
+                    enabled: {
+                        $eq: 1,
+                    },
+                },
+            ],
+            filters,
+            query: {
+                query: '`default`.`enabled` = ?',
+                params: [1],
+            },
+        });
+    });
+    it('allows 0 as false', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            enabled: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('enabled'), type: SQLModernFilter_1.SQLModernValueType.Boolean, nullable: false }),
+        };
+        await (0, utils_1.testMultiple)({
+            testFilters: [
+                {
+                    enabled: 0,
+                },
+                {
+                    enabled: {
+                        $eq: 0,
+                    },
+                },
+            ],
+            filters,
+            query: {
+                query: '`default`.`enabled` = ?',
+                params: [0],
+            },
+        });
+    });
+    it('does not allow numbers as boolean value', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            enabled: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('enabled'), type: SQLModernFilter_1.SQLModernValueType.Boolean, nullable: false }),
+        };
+        await (0, utils_1.testMultipleErrors)({
+            testFilters: [
+                {
+                    enabled: 2,
+                },
+                {
+                    enabled: {
+                        $eq: 2,
+                    },
+                },
+                {
+                    enabled: {
+                        $eq: -1,
+                    },
+                },
+                {
+                    enabled: {
+                        $eq: NaN,
+                    },
+                },
+                {
+                    enabled: {
+                        $eq: Infinity,
+                    },
+                },
+            ],
+            filters,
+            error: 'Cannot compare a number with a boolean column',
+        });
+    });
+    it('cannot compare a number with a string', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: false }),
+        };
+        await (0, utils_1.testError)({
+            filter: {
+                name: {
+                    $eq: 5,
+                },
+            },
+            filters,
+            error: 'Cannot compare a number with a non-number column',
+        });
+    });
+    it('cannot compare a string with a number', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            age: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('age'), type: SQLModernFilter_1.SQLModernValueType.Number, nullable: false }),
+        };
+        await (0, utils_1.testError)({
+            filter: {
+                age: {
+                    $eq: 'John Doe',
+                },
+            },
+            filters,
+            error: 'Cannot compare a string with a non-string column',
+        });
+    });
+    it('cannot compare a number with a date', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            createdAt: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('createdAt'), type: SQLModernFilter_1.SQLModernValueType.Datetime, nullable: false }),
+        };
+        await (0, utils_1.testError)({
+            filter: {
+                createdAt: {
+                    $eq: 5,
+                },
+            },
+            filters,
+            error: 'Cannot compare a number with a non-number column',
+        });
+    });
+    it('cannot compare a date with a string', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: false }),
+        };
+        await (0, utils_1.testError)({
+            filter: {
+                name: {
+                    $eq: new Date(),
+                },
+            },
+            filters,
+            error: 'Cannot compare a date with a non-datetime column',
+        });
+    });
+    it('cannot compare a date magic variable with a string', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: false }),
+        };
+        await (0, utils_1.testError)({
+            filter: {
+                name: {
+                    $eq: {
+                        $: '$now',
+                    },
+                },
+            },
+            filters,
+            error: 'Cannot compare a date with a non-datetime column',
+        });
+    });
+    it('$eq filter is interpreted automatically for numbers', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            age: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('age'), type: SQLModernFilter_1.SQLModernValueType.Number, nullable: false }),
+        };
+        await (0, utils_1.test)({
+            filter: {
+                age: 5,
+            },
+            filters,
+            query: {
+                query: '`default`.`age` = ?',
+                params: [5],
+            },
+        });
+    });
+    it('$eq filter is interpreted automatically for strings', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: false }),
+        };
+        await (0, utils_1.test)({
+            filter: {
+                name: 'John Doe',
+            },
+            filters,
+            query: {
+                query: '`default`.`name` = ?',
+                params: ['john doe'],
+            },
+        });
+    });
+    it('$eq filter is interpreted automatically for null', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: true }),
+        };
+        await (0, utils_1.test)({
+            filter: {
+                name: null,
+            },
+            filters,
+            query: {
+                query: '`default`.`name` IS NULL',
+                params: [],
+            },
+        });
+    });
+    it('$eq filter is interpreted automatically for magic variables', async () => {
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            createdAt: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('createdAt'), type: SQLModernFilter_1.SQLModernValueType.Datetime, nullable: false }),
+        };
+        await (0, utils_1.test)({
+            filter: {
+                createdAt: {
+                    $: '$now',
+                },
+            },
+            filters,
+            query: {
+                query: '`default`.`createdAt` = ?',
+                params: [
+                    new Date(),
+                ],
+            },
+        });
+    });
+    describe('JSON', () => {
+        const tableDefinition = {
+            settings: {
+                type: 'json',
+                nullable: true,
+            },
+        };
+        const filters = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            'settings.name': (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.jsonValue(SQL_1.SQL.column('settings'), '$.name'), type: SQLModernFilter_1.SQLModernValueType.JSONString, nullable: false }),
+            // wip:
+            'settings.parents[*].name': (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.jsonValue(SQL_1.SQL.column('settings'), '$.parents[*].name'), type: SQLModernFilter_1.SQLModernValueType.JSONArray, nullable: false }),
+            'settings.parents[*].age': (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.jsonValue(SQL_1.SQL.column('settings'), '$.parents[*].age'), type: SQLModernFilter_1.SQLModernValueType.JSONArray, nullable: false }),
+            'settings.randomValues': (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.jsonValue(SQL_1.SQL.column('settings'), '$.randomValues'), type: SQLModernFilter_1.SQLModernValueType.JSONArray, nullable: true }),
+            'settings': (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('settings'), type: SQLModernFilter_1.SQLModernValueType.JSONObject, nullable: true }),
+            'settings.enabled': (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.jsonValue(SQL_1.SQL.column('settings'), '$.enabled'), type: SQLModernFilter_1.SQLModernValueType.JSONBoolean, nullable: true }),
+            'settings.age': (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.jsonValue(SQL_1.SQL.column('settings'), '$.age'), type: SQLModernFilter_1.SQLModernValueType.JSONNumber, nullable: true }),
+        };
+        it('JSON strings match case insensitive and whole string', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            name: 'John Doe',
+                        },
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.name': 'John Doe',
+                    },
+                    {
+                        'settings.name': {
+                            $eq: 'John Doe',
+                        },
+                    },
+                    {
+                        'settings.name': 'john doe',
+                    },
+                    {
+                        'settings.name': 'jOhn dOe',
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.name': 'Jane Doe',
+                    },
+                    {
+                        'settings.name': 'John',
+                    },
+                    {
+                        'settings.name': 'john',
+                    },
+                ],
+            });
+        });
+        it('Can search strings in a string array', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            name: 'Junior Doe',
+                            parents: [
+                                { name: 'John Doe' },
+                                { name: 'Jane Doe' },
+                            ],
+                        },
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.parents[*].name': 'John Doe',
+                    },
+                    {
+                        'settings.parents[*].name': 'Jane Doe',
+                    },
+                    {
+                        'settings.parents[*].name': 'jane doe',
+                    },
+                    {
+                        'settings.parents[*].name': 'john doe',
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.parents[*].name': 'John',
+                    },
+                    {
+                        'settings.parents[*].name': 'Jane',
+                    },
+                    {
+                        'settings.parents[*].name': 'jane',
+                    },
+                    {
+                        'settings.parents[*].name': 'john',
+                    },
+                    {
+                        'settings.parents[*].name': 'Jane Doe ',
+                    },
+                    {
+                        'settings.parents[*].name': 5,
+                    },
+                    {
+                        'settings.parents[*].name': true,
+                    },
+                ],
+            });
+        });
+        it('Can search numbers in a number array', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            name: 'Junior Doe',
+                            parents: [
+                                { name: 'John Doe', age: 50 },
+                                { name: 'Jane Doe', age: 45 },
+                            ],
+                        },
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.parents[*].age': 50,
+                    },
+                    {
+                        'settings.parents[*].age': 45,
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.parents[*].age': 51,
+                    },
+                    {
+                        'settings.parents[*].age': 49,
+                    },
+                    {
+                        'settings.parents[*].age': 45.1,
+                    },
+                    {
+                        'settings.parents[*].age': '49',
+                    },
+                    {
+                        'settings.parents[*].age': 'test',
+                    },
+                ],
+            });
+        });
+        it('Can search in a mixed array', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            name: 'Junior Doe',
+                            randomValues: [true, 0, 'tesT'],
+                        },
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.randomValues': true,
+                    },
+                    {
+                        'settings.randomValues': 0,
+                    },
+                    {
+                        'settings.randomValues': 'tesT',
+                    },
+                    {
+                        'settings.randomValues': 'Test',
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.randomValues': false,
+                    },
+                    {
+                        'settings.randomValues': 1,
+                    },
+                    {
+                        'settings.randomValues': 'tes',
+                    },
+                ],
+            });
+        });
+        it('Can search null in a JSON array', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            name: 'Junior Doe',
+                            parents: [
+                                { name: null, age: 50 },
+                                { name: 'Jane Doe', age: null },
+                            ],
+                        },
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.parents[*].age': null,
+                    },
+                    {
+                        'settings.parents[*].name': null,
+                    },
+                ],
+            });
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            name: 'Junior Doe',
+                            parents: [
+                                { name: 'Set', age: 50 },
+                                { name: 'Jane Doe', age: 45 },
+                            ],
+                        },
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.parents[*].age': null,
+                    },
+                    {
+                        'settings.parents[*].name': null,
+                    },
+                ],
+            });
+        });
+        it('Can check JSON booleans', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            enabled: true,
+                        },
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.enabled': true,
+                    },
+                    {
+                        'settings.enabled': 1,
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.enabled': false,
+                    },
+                    {
+                        'settings.enabled': null,
+                    },
+                ],
+            });
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            enabled: false,
+                        },
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.enabled': false,
+                    },
+                    {
+                        'settings.enabled': 0,
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.enabled': true,
+                    },
+                    {
+                        'settings.enabled': null,
+                    },
+                ],
+            });
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            enabled: null,
+                        },
+                    },
+                    {
+                        settings: {},
+                    },
+                    {
+                        settings: null,
+                    },
+                    {
+                        settings: 'null',
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.enabled': null,
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.enabled': true,
+                    },
+                    {
+                        'settings.enabled': false,
+                    },
+                ],
+            });
+        });
+        it('Can compare JSON numbers', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            age: 10,
+                        },
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.age': 10,
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.age': 11,
+                    },
+                    {
+                        'settings.age': 9,
+                    },
+                ],
+            });
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            age: null,
+                        },
+                    },
+                    {
+                        settings: {},
+                    },
+                    {
+                        settings: null,
+                    },
+                    {
+                        settings: 'null',
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.age': null,
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.age': 0,
+                    },
+                ],
+            });
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            enabled: null,
+                        },
+                    },
+                    {
+                        settings: {},
+                    },
+                    {
+                        settings: null,
+                    },
+                    {
+                        settings: 'null',
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.enabled': null,
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.enabled': true,
+                    },
+                    {
+                        'settings.enabled': false,
+                    },
+                ],
+            });
+        });
+        it('Checking a json value for null also matches if the key does not exist', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: null,
+                    },
+                    {
+                        settings: {
+                            something: false,
+                        },
+                    },
+                    {
+                        settings: {
+                            name: null,
+                        },
+                    },
+                    {
+                        settings: {
+                            parents: [
+                                { name: null },
+                            ],
+                        },
+                    },
+                    {
+                        settings: {
+                            parents: [
+                                { age: null },
+                            ],
+                        },
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.name': null,
+                    },
+                    {
+                        'settings.parents[*].age': null,
+                    },
+                    {
+                        'settings.parents[*].name': null,
+                    },
+                ],
+            });
+        });
+        it('Can check if a json string is null', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            name: null,
+                        },
+                    },
+                    {
+                        settings: null,
+                    },
+                    {
+                        settings: {},
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.name': null,
+                    },
+                ],
+            });
+        });
+        it('Can check if a json number is null', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            age: null,
+                        },
+                    },
+                    {
+                        settings: null,
+                    },
+                    {
+                        settings: {},
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.age': null,
+                    },
+                ],
+            });
+        });
+        it('Can differentiate null string vs json null when comparing to null', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            name: 'null',
+                        },
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.name': null,
+                    },
+                ],
+            });
+        });
+        it('Can differentiate 0 number vs json null when comparing to null', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            age: 0,
+                        },
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.age': null,
+                    },
+                ],
+            });
+        });
+        it('can check if a json object column is null', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: 'null',
+                    },
+                    {
+                        settings: null,
+                    },
+                ],
+                doMatch: [
+                    {
+                        settings: {
+                            $eq: null,
+                        },
+                    },
+                    {
+                        settings: null,
+                    },
+                ],
+            });
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {},
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        settings: {
+                            $eq: null,
+                        },
+                    },
+                    {
+                        settings: null,
+                    },
+                ],
+            });
+        });
+        it('can check if a JSON array column is null', async () => {
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: 'null',
+                    },
+                    {
+                        settings: null,
+                    },
+                    {
+                        settings: {},
+                    },
+                    {
+                        settings: {
+                            randomValues: null,
+                        },
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.randomValues': {
+                            $eq: null,
+                        },
+                    },
+                    {
+                        'settings.randomValues': null,
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.randomValues': {
+                            $neq: null,
+                        },
+                    },
+                ],
+            });
+            await (0, utils_1.testMatch)({
+                tableDefinition,
+                filters,
+                rows: [
+                    {
+                        settings: {
+                            randomValues: [],
+                        },
+                    },
+                ],
+                doNotMatch: [
+                    {
+                        'settings.randomValues': {
+                            $eq: null,
+                        },
+                    },
+                    {
+                        'settings.randomValues': null,
+                    },
+                ],
+                doMatch: [
+                    {
+                        'settings.randomValues': {
+                            $neq: null,
+                        },
+                    },
+                ],
+            });
+        });
+    });
+});
+//# sourceMappingURL=$eq.test.js.map