@redocly/openapi-core 1.0.0 → 1.0.1

package/src/rules/common/assertions/__tests__/asserts.test.ts

@@ -0,0 +1,869 @@
+import { Location } from '../../../../ref-utils';
+import { Source } from '../../../../resolve';
+import { AssertionFnContext, Asserts, asserts, buildAssertCustomFunction } from '../asserts';
+
+let baseLocation = new Location(jest.fn() as any as Source, 'pointer');
+
+const assertionProperties = {
+  baseLocation: baseLocation,
+} as AssertionFnContext;
+
+describe('oas3 assertions', () => {
+  describe('generic rules', () => {
+    const fakeNode = {
+      foo: '',
+      bar: '',
+      baz: '',
+    };
+
+    describe('pattern', () => {
+      it('value should match regex pattern', () => {
+        expect(asserts.pattern('test string', '/test/', assertionProperties)).toEqual([]);
+        expect(asserts.pattern('test string', '/test me/', assertionProperties)).toEqual([
+          { location: baseLocation, message: '"test string" should match a regex /test me/' },
+        ]);
+        expect(asserts.pattern(['test string', 'test me'], '/test/', assertionProperties)).toEqual(
+          []
+        );
+        expect(
+          asserts.pattern(['test string', 'test me'], '/test me/', assertionProperties)
+        ).toEqual([
+          {
+            message: '"test string" should match a regex /test me/',
+            location: baseLocation.key(),
+          },
+        ]);
+        expect(
+          asserts.pattern(
+            './components/smth/test.yaml',
+            '/^(./)?components/.*.yaml$/',
+            assertionProperties
+          )
+        ).toEqual([]);
+        expect(
+          asserts.pattern('./other.yaml', '/^(./)?components/.*.yaml$/', assertionProperties)
+        ).toEqual([
+          {
+            message: '"./other.yaml" should match a regex /^(./)?components/.*.yaml$/',
+            location: baseLocation,
+          },
+        ]);
+      });
+    });
+
+    describe('notPattern', () => {
+      it('value should not match regex pattern', () => {
+        expect(asserts.notPattern('test string', '/test me/', assertionProperties)).toEqual([]);
+        expect(asserts.notPattern('test string', '/test/', assertionProperties)).toEqual([
+          { location: baseLocation, message: '"test string" should not match a regex /test/' },
+        ]);
+        expect(
+          asserts.notPattern(['test string', 'test me'], '/test other/', assertionProperties)
+        ).toEqual([]);
+        expect(
+          asserts.notPattern(['test string', 'test me'], '/test me/', assertionProperties)
+        ).toEqual([
+          {
+            message: '"test me" should not match a regex /test me/',
+            location: baseLocation.key(),
+          },
+        ]);
+      });
+    });
+
+    describe('ref', () => {
+      it('value should have ref', () => {
+        expect(
+          asserts.ref({ $ref: 'text' }, true, {
+            ...assertionProperties,
+            rawValue: { $ref: 'text' },
+          })
+        ).toEqual([]);
+        expect(asserts.ref({}, true, { ...assertionProperties, rawValue: {} })).toEqual([
+          {
+            message: 'should use $ref',
+            location: baseLocation.key(),
+          },
+        ]);
+      });
+
+      it('value should not have ref', () => {
+        expect(
+          asserts.ref({ $ref: 'text' }, false, {
+            ...assertionProperties,
+            rawValue: { $ref: 'text' },
+          })
+        ).toEqual([
+          {
+            message: 'should not use $ref',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.ref({}, false, { ...assertionProperties, rawValue: {} })).toEqual([]);
+      });
+
+      it('value should match regex pattern', () => {
+        expect(
+          asserts.ref({ $ref: 'test string' }, '/test/', {
+            ...assertionProperties,
+            rawValue: { $ref: 'test string' },
+          })
+        ).toEqual([]);
+        expect(
+          asserts.ref({ $ref: 'test string' }, '/test me/', {
+            ...assertionProperties,
+            rawValue: { $ref: 'text' },
+          })
+        ).toEqual([{ message: '$ref value should match /test me/', location: baseLocation }]);
+        expect(
+          asserts.ref({ $ref: './components/smth/test.yaml' }, '/^(./)?components/.*.yaml$/', {
+            ...assertionProperties,
+            rawValue: { $ref: './components/smth/test.yaml' },
+          })
+        ).toEqual([]);
+        expect(
+          asserts.ref({ $ref: './paths/smth/test.yaml' }, '/^(./)?components/.*.yaml$/', {
+            ...assertionProperties,
+            rawValue: { $ref: './paths/smth/test.yaml' },
+          })
+        ).toEqual([
+          {
+            message: '$ref value should match /^(./)?components/.*.yaml$/',
+            location: baseLocation,
+          },
+        ]);
+      });
+    });
+
+    describe('enum', () => {
+      it('value should be among predefined keys', () => {
+        expect(asserts.enum('test', ['test', 'example'], assertionProperties)).toEqual([]);
+        expect(asserts.enum(['test'], ['test', 'example'], assertionProperties)).toEqual([]);
+        expect(asserts.enum(['test', 'example'], ['test', 'example'], assertionProperties)).toEqual(
+          []
+        );
+        expect(
+          asserts.enum(['test', 'example', 'foo'], ['test', 'example'], assertionProperties)
+        ).toEqual([
+          {
+            message: '"foo" should be one of the predefined values',
+            location: baseLocation.child('foo').key(),
+          },
+        ]);
+        expect(asserts.enum('test', ['foo', 'example'], assertionProperties)).toEqual([
+          {
+            message: '"test" should be one of the predefined values',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.enum(['test', 'foo'], ['test', 'example'], assertionProperties)).toEqual([
+          {
+            message: '"foo" should be one of the predefined values',
+            location: baseLocation.child('foo').key(),
+          },
+        ]);
+      });
+    });
+
+    describe('defined', () => {
+      it('value should be defined', () => {
+        expect(asserts.defined('test', true, assertionProperties)).toEqual([]);
+        expect(asserts.defined(undefined, true, assertionProperties)).toEqual([
+          {
+            message: 'Should be defined',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('value should be undefined', () => {
+        expect(asserts.defined(undefined, false, assertionProperties)).toEqual([]);
+        expect(asserts.defined('test', false, assertionProperties)).toEqual([
+          {
+            message: 'Should be not defined',
+            location: baseLocation,
+          },
+        ]);
+      });
+    });
+
+    describe('undefined', () => {
+      it('value should be undefined', () => {
+        expect(asserts.undefined(undefined, true, assertionProperties)).toEqual([]);
+        expect(asserts.undefined('test', true, assertionProperties)).toEqual([
+          {
+            message: 'Should not be defined',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('value should be defined', () => {
+        expect(asserts.undefined('test', false, assertionProperties)).toEqual([]);
+        expect(asserts.undefined(undefined, false, assertionProperties)).toEqual([
+          {
+            message: 'Should be defined',
+            location: baseLocation,
+          },
+        ]);
+      });
+    });
+
+    describe('required', () => {
+      it('values should be required', () => {
+        expect(
+          asserts.required(['one', 'two', 'three'], ['one', 'two'], assertionProperties)
+        ).toEqual([]);
+        expect(
+          asserts.required(['one', 'two'], ['one', 'two', 'three'], assertionProperties)
+        ).toEqual([
+          {
+            message: 'three is required',
+            location: baseLocation.key(),
+          },
+        ]);
+      });
+    });
+
+    describe('nonEmpty', () => {
+      it('value should not be empty', () => {
+        expect(asserts.nonEmpty('test', true, assertionProperties)).toEqual([]);
+        expect(asserts.nonEmpty('', true, assertionProperties)).toEqual([
+          {
+            message: 'Should not be empty',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.nonEmpty(null, true, assertionProperties)).toEqual([
+          {
+            message: 'Should not be empty',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.nonEmpty(undefined, true, assertionProperties)).toEqual([
+          {
+            message: 'Should not be empty',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('value should be empty', () => {
+        expect(asserts.nonEmpty('', false, assertionProperties)).toEqual([]);
+        expect(asserts.nonEmpty(null, false, assertionProperties)).toEqual([]);
+        expect(asserts.nonEmpty(undefined, false, assertionProperties)).toEqual([]);
+        expect(asserts.nonEmpty('test', false, assertionProperties)).toEqual([
+          {
+            message: 'Should be empty',
+            location: baseLocation,
+          },
+        ]);
+      });
+    });
+
+    describe('minLength', () => {
+      it('value should have less or equal than 5 symbols length', () => {
+        expect(asserts.minLength('test', 5, assertionProperties)).toEqual([
+          {
+            message: 'Should have at least 5 characters',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.minLength([1, 2, 3, 4], 5, assertionProperties)).toEqual([
+          {
+            message: 'Should have at least 5 characters',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.minLength([1, 2, 3, 4, 5], 5, assertionProperties)).toEqual([]);
+        expect(asserts.minLength([1, 2, 3, 4, 5, 6], 5, assertionProperties)).toEqual([]);
+        expect(asserts.minLength('example', 5, assertionProperties)).toEqual([]);
+        expect(asserts.minLength([], 5, assertionProperties)).toEqual([
+          {
+            message: 'Should have at least 5 characters',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.minLength('', 5, assertionProperties)).toEqual([
+          {
+            message: 'Should have at least 5 characters',
+            location: baseLocation,
+          },
+        ]);
+      });
+    });
+
+    describe('maxLength', () => {
+      it('value should have more or equal than 5 symbols length', () => {
+        expect(asserts.maxLength('test', 5, assertionProperties)).toEqual([]);
+        expect(asserts.maxLength([1, 2, 3, 4], 5, assertionProperties)).toEqual([]);
+        expect(asserts.maxLength([1, 2, 3, 4, 5], 5, assertionProperties)).toEqual([]);
+        expect(asserts.maxLength([1, 2, 3, 4, 5, 6], 5, assertionProperties)).toEqual([
+          {
+            message: 'Should have at most 5 characters',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.maxLength('example', 5, assertionProperties)).toEqual([
+          {
+            message: 'Should have at most 5 characters',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.maxLength([], 5, assertionProperties)).toEqual([]);
+        expect(asserts.maxLength('', 5, assertionProperties)).toEqual([]);
+      });
+    });
+
+    describe('casing', () => {
+      it('value should be camelCase', () => {
+        expect(asserts.casing(['testExample', 'fooBar'], 'camelCase', assertionProperties)).toEqual(
+          []
+        );
+        expect(asserts.casing(['testExample', 'FooBar'], 'camelCase', assertionProperties)).toEqual(
+          [
+            {
+              message: '"FooBar" should use camelCase',
+              location: baseLocation.child('FooBar').key(),
+            },
+          ]
+        );
+        expect(asserts.casing('testExample', 'camelCase', assertionProperties)).toEqual([]);
+        expect(asserts.casing('TestExample', 'camelCase', assertionProperties)).toEqual([
+          {
+            message: '"TestExample" should use camelCase',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('test-example', 'camelCase', assertionProperties)).toEqual([
+          {
+            message: '"test-example" should use camelCase',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('test_example', 'camelCase', assertionProperties)).toEqual([
+          {
+            message: '"test_example" should use camelCase',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('value should be PascalCase', () => {
+        expect(asserts.casing('TestExample', 'PascalCase', assertionProperties)).toEqual([]);
+        expect(
+          asserts.casing(['TestExample', 'FooBar'], 'PascalCase', assertionProperties)
+        ).toEqual([]);
+        expect(
+          asserts.casing(['TestExample', 'fooBar'], 'PascalCase', assertionProperties)
+        ).toEqual([
+          {
+            message: '"fooBar" should use PascalCase',
+            location: baseLocation.child('fooBar').key(),
+          },
+        ]);
+        expect(asserts.casing('testExample', 'PascalCase', assertionProperties)).toEqual([
+          {
+            message: '"testExample" should use PascalCase',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('test-example', 'PascalCase', assertionProperties)).toEqual([
+          {
+            message: '"test-example" should use PascalCase',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('test_example', 'PascalCase', assertionProperties)).toEqual([
+          {
+            message: '"test_example" should use PascalCase',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('value should be kebab-case', () => {
+        expect(asserts.casing('test-example', 'kebab-case', assertionProperties)).toEqual([]);
+        expect(
+          asserts.casing(['test-example', 'foo-bar'], 'kebab-case', assertionProperties)
+        ).toEqual([]);
+        expect(
+          asserts.casing(['test-example', 'foo_bar'], 'kebab-case', assertionProperties)
+        ).toEqual([
+          {
+            message: '"foo_bar" should use kebab-case',
+            location: baseLocation.child('foo_bar').key(),
+          },
+        ]);
+        expect(asserts.casing('testExample', 'kebab-case', assertionProperties)).toEqual([
+          {
+            message: '"testExample" should use kebab-case',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('TestExample', 'kebab-case', assertionProperties)).toEqual([
+          {
+            message: '"TestExample" should use kebab-case',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('test_example', 'kebab-case', assertionProperties)).toEqual([
+          {
+            message: '"test_example" should use kebab-case',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('value should be snake_case', () => {
+        expect(asserts.casing('test_example', 'snake_case', assertionProperties)).toEqual([]);
+        expect(
+          asserts.casing(['test_example', 'foo_bar'], 'snake_case', assertionProperties)
+        ).toEqual([]);
+        expect(
+          asserts.casing(['test_example', 'foo-bar'], 'snake_case', assertionProperties)
+        ).toEqual([
+          {
+            message: '"foo-bar" should use snake_case',
+            location: baseLocation.child('foo-bar').key(),
+          },
+        ]);
+        expect(asserts.casing('testExample', 'snake_case', assertionProperties)).toEqual([
+          {
+            message: '"testExample" should use snake_case',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('TestExample', 'snake_case', assertionProperties)).toEqual([
+          {
+            message: '"TestExample" should use snake_case',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('test-example', 'snake_case', assertionProperties)).toEqual([
+          {
+            message: '"test-example" should use snake_case',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('value should be MACRO_CASE', () => {
+        expect(asserts.casing('TEST_EXAMPLE', 'MACRO_CASE', assertionProperties)).toEqual([]);
+        expect(
+          asserts.casing(['TEST_EXAMPLE', 'FOO_BAR'], 'MACRO_CASE', assertionProperties)
+        ).toEqual([]);
+        expect(
+          asserts.casing(['TEST_EXAMPLE', 'FOO-BAR'], 'MACRO_CASE', assertionProperties)
+        ).toEqual([
+          {
+            message: '"FOO-BAR" should use MACRO_CASE',
+            location: baseLocation.child('FOO-BAR').key(),
+          },
+        ]);
+        expect(asserts.casing('TEST_EXAMPLE_', 'MACRO_CASE', assertionProperties)).toEqual([
+          {
+            message: '"TEST_EXAMPLE_" should use MACRO_CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('_TEST_EXAMPLE', 'MACRO_CASE', assertionProperties)).toEqual([
+          {
+            message: '"_TEST_EXAMPLE" should use MACRO_CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('TEST__EXAMPLE', 'MACRO_CASE', assertionProperties)).toEqual([
+          {
+            message: '"TEST__EXAMPLE" should use MACRO_CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('TEST-EXAMPLE', 'MACRO_CASE', assertionProperties)).toEqual([
+          {
+            message: '"TEST-EXAMPLE" should use MACRO_CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('testExample', 'MACRO_CASE', assertionProperties)).toEqual([
+          {
+            message: '"testExample" should use MACRO_CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('TestExample', 'MACRO_CASE', assertionProperties)).toEqual([
+          {
+            message: '"TestExample" should use MACRO_CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('test-example', 'MACRO_CASE', assertionProperties)).toEqual([
+          {
+            message: '"test-example" should use MACRO_CASE',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('value should be COBOL-CASE', () => {
+        expect(asserts.casing('TEST-EXAMPLE', 'COBOL-CASE', assertionProperties)).toEqual([]);
+        expect(
+          asserts.casing(['TEST-EXAMPLE', 'FOO-BAR'], 'COBOL-CASE', assertionProperties)
+        ).toEqual([]);
+        expect(
+          asserts.casing(['TEST-EXAMPLE', 'FOO_BAR'], 'COBOL-CASE', assertionProperties)
+        ).toEqual([
+          {
+            message: '"FOO_BAR" should use COBOL-CASE',
+            location: baseLocation.child('FOO_BAR').key(),
+          },
+        ]);
+        expect(asserts.casing('TEST-EXAMPLE-', 'COBOL-CASE', assertionProperties)).toEqual([
+          {
+            message: '"TEST-EXAMPLE-" should use COBOL-CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('0TEST-EXAMPLE', 'COBOL-CASE', assertionProperties)).toEqual([
+          {
+            message: '"0TEST-EXAMPLE" should use COBOL-CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('-TEST-EXAMPLE', 'COBOL-CASE', assertionProperties)).toEqual([
+          {
+            message: '"-TEST-EXAMPLE" should use COBOL-CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('TEST--EXAMPLE', 'COBOL-CASE', assertionProperties)).toEqual([
+          {
+            message: '"TEST--EXAMPLE" should use COBOL-CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('TEST_EXAMPLE', 'COBOL-CASE', assertionProperties)).toEqual([
+          {
+            message: '"TEST_EXAMPLE" should use COBOL-CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('testExample', 'COBOL-CASE', assertionProperties)).toEqual([
+          {
+            message: '"testExample" should use COBOL-CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('TestExample', 'COBOL-CASE', assertionProperties)).toEqual([
+          {
+            message: '"TestExample" should use COBOL-CASE',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('test-example', 'COBOL-CASE', assertionProperties)).toEqual([
+          {
+            message: '"test-example" should use COBOL-CASE',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('value should be flatcase', () => {
+        expect(asserts.casing('testexample', 'flatcase', assertionProperties)).toEqual([]);
+        expect(asserts.casing(['testexample', 'foobar'], 'flatcase', assertionProperties)).toEqual(
+          []
+        );
+        expect(asserts.casing(['testexample', 'foo_bar'], 'flatcase', assertionProperties)).toEqual(
+          [
+            {
+              message: '"foo_bar" should use flatcase',
+              location: baseLocation.child('foo_bar').key(),
+            },
+          ]
+        );
+        expect(asserts.casing('testexample_', 'flatcase', assertionProperties)).toEqual([
+          {
+            message: '"testexample_" should use flatcase',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('0testexample', 'flatcase', assertionProperties)).toEqual([
+          {
+            message: '"0testexample" should use flatcase',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('testExample', 'flatcase', assertionProperties)).toEqual([
+          {
+            message: '"testExample" should use flatcase',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('TestExample', 'flatcase', assertionProperties)).toEqual([
+          {
+            message: '"TestExample" should use flatcase',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.casing('test-example', 'flatcase', assertionProperties)).toEqual([
+          {
+            message: '"test-example" should use flatcase',
+            location: baseLocation,
+          },
+        ]);
+      });
+    });
+
+    describe('sortOrder', () => {
+      it('value should be ordered in ASC direction', () => {
+        expect(asserts.sortOrder(['example', 'foo', 'test'], 'asc', assertionProperties)).toEqual(
+          []
+        );
+        expect(
+          asserts.sortOrder(['example', 'foo', 'test'], { direction: 'asc' }, assertionProperties)
+        ).toEqual([]);
+        expect(asserts.sortOrder(['example'], 'asc', assertionProperties)).toEqual([]);
+        expect(asserts.sortOrder(['example', 'test', 'foo'], 'asc', assertionProperties)).toEqual([
+          {
+            message: 'Should be sorted in an ascending order',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.sortOrder(['example', 'foo', 'test'], 'desc', assertionProperties)).toEqual([
+          {
+            message: 'Should be sorted in a descending order',
+            location: baseLocation,
+          },
+        ]);
+        expect(
+          asserts.sortOrder(
+            [{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }],
+            { direction: 'asc', property: 'name' },
+            assertionProperties
+          )
+        ).toEqual([]);
+        expect(
+          asserts.sortOrder(
+            [{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }],
+            { direction: 'desc', property: 'name' },
+            assertionProperties
+          )
+        ).toEqual([
+          {
+            message: 'Should be sorted in a descending order by property name',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('value should be ordered in DESC direction', () => {
+        expect(asserts.sortOrder(['test', 'foo', 'example'], 'desc', assertionProperties)).toEqual(
+          []
+        );
+        expect(
+          asserts.sortOrder(['test', 'foo', 'example'], { direction: 'desc' }, assertionProperties)
+        ).toEqual([]);
+        expect(asserts.sortOrder(['example'], 'desc', assertionProperties)).toEqual([]);
+        expect(asserts.sortOrder(['example', 'test', 'foo'], 'desc', assertionProperties)).toEqual([
+          {
+            message: 'Should be sorted in a descending order',
+            location: baseLocation,
+          },
+        ]);
+        expect(asserts.sortOrder(['test', 'foo', 'example'], 'asc', assertionProperties)).toEqual([
+          {
+            message: 'Should be sorted in an ascending order',
+            location: baseLocation,
+          },
+        ]);
+        expect(
+          asserts.sortOrder(
+            [{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }],
+            { direction: 'desc', property: 'name' },
+            assertionProperties
+          )
+        ).toEqual([]);
+        expect(
+          asserts.sortOrder(
+            [{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }],
+            { direction: 'asc', property: 'name' },
+            assertionProperties
+          )
+        ).toEqual([
+          {
+            message: 'Should be sorted in an ascending order by property name',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('should not order objects without property defined', () => {
+        expect(
+          asserts.sortOrder(
+            [
+              { name: 'bar', id: 1 },
+              { name: 'baz', id: 2 },
+              { name: 'foo', id: 3 },
+            ],
+            { direction: 'desc' },
+            assertionProperties
+          )
+        ).toEqual([
+          {
+            message: 'Please define a property to sort objects by',
+            location: baseLocation,
+          },
+        ]);
+        expect(
+          asserts.sortOrder(
+            [
+              { name: 'bar', id: 1 },
+              { name: 'baz', id: 2 },
+              { name: 'foo', id: 3 },
+            ],
+            { direction: 'asc' },
+            assertionProperties
+          )
+        ).toEqual([
+          {
+            message: 'Please define a property to sort objects by',
+            location: baseLocation,
+          },
+        ]);
+      });
+      it('should ignore string value casing while ordering', () => {
+        expect(asserts.sortOrder(['Example', 'foo', 'Test'], 'asc', assertionProperties)).toEqual(
+          []
+        );
+        expect(asserts.sortOrder(['Test', 'foo', 'Example'], 'desc', assertionProperties)).toEqual(
+          []
+        );
+        expect(
+          asserts.sortOrder(
+            [{ name: 'bar' }, { name: 'Baz' }, { name: 'Foo' }],
+            { direction: 'asc', property: 'name' },
+            assertionProperties
+          )
+        ).toEqual([]);
+        expect(
+          asserts.sortOrder(
+            [{ name: 'Foo' }, { name: 'baz' }, { name: 'Bar' }],
+            { direction: 'desc', property: 'name' },
+            assertionProperties
+          )
+        ).toEqual([]);
+      });
+    });
+
+    describe('mutuallyExclusive', () => {
+      it('node should not have more than one property from predefined list', () => {
+        expect(
+          asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'test'], assertionProperties)
+        ).toEqual([]);
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), [], assertionProperties)).toEqual(
+          []
+        );
+        expect(
+          asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'bar'], assertionProperties)
+        ).toEqual([
+          { message: 'foo, bar keys should be mutually exclusive', location: baseLocation.key() },
+        ]);
+        expect(
+          asserts.mutuallyExclusive(
+            Object.keys(fakeNode),
+            ['foo', 'bar', 'test'],
+            assertionProperties
+          )
+        ).toEqual([
+          {
+            message: 'foo, bar, test keys should be mutually exclusive',
+            location: baseLocation.key(),
+          },
+        ]);
+      });
+    });
+
+    describe('mutuallyRequired', () => {
+      it('node should have all the properties from predefined list', () => {
+        expect(
+          asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar'], assertionProperties)
+        ).toEqual([]);
+        expect(
+          asserts.mutuallyRequired(
+            Object.keys(fakeNode),
+            ['foo', 'bar', 'baz'],
+            assertionProperties
+          )
+        ).toEqual([]);
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), [], assertionProperties)).toEqual(
+          []
+        );
+        expect(
+          asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'test'], assertionProperties)
+        ).toEqual([
+          { message: 'Properties foo, test are mutually required', location: baseLocation.key() },
+        ]);
+        expect(
+          asserts.mutuallyRequired(
+            Object.keys(fakeNode),
+            ['foo', 'bar', 'test'],
+            assertionProperties
+          )
+        ).toEqual([
+          {
+            message: 'Properties foo, bar, test are mutually required',
+            location: baseLocation.key(),
+          },
+        ]);
+      });
+    });
+
+    describe('requireAny', () => {
+      it('node must have at least one property from predefined list', () => {
+        expect(
+          asserts.requireAny(Object.keys(fakeNode), ['foo', 'test'], assertionProperties)
+        ).toEqual([]);
+        expect(
+          asserts.requireAny(Object.keys(fakeNode), ['test', 'bar'], assertionProperties)
+        ).toEqual([]);
+        expect(asserts.requireAny(Object.keys(fakeNode), [], assertionProperties)).toEqual([
+          {
+            message: 'Should have any of ',
+            location: baseLocation.key(),
+          },
+        ]);
+        expect(
+          asserts.requireAny(Object.keys(fakeNode), ['test', 'test1'], assertionProperties)
+        ).toEqual([
+          {
+            message: 'Should have any of test, test1',
+            location: baseLocation.key(),
+          },
+        ]);
+        expect(
+          asserts.requireAny(Object.keys(fakeNode), ['foo', 'bar'], assertionProperties)
+        ).toEqual([]);
+        expect(
+          asserts.requireAny(Object.keys(fakeNode), ['foo', 'bar', 'test'], assertionProperties)
+        ).toEqual([]);
+      });
+    });
+
+    describe('function', () => {
+      it('node must have at least one property from predefined list', () => {
+        const customFn = jest.fn((value: string[], options: any) => {
+          if (value[0] === options.word) {
+            return [
+              { message: `First value should be ${options.word}`, location: baseLocation.key() },
+            ];
+          }
+          return [];
+        });
+        asserts['local/customFn' as keyof Asserts] = buildAssertCustomFunction(customFn);
+        expect(
+          asserts['local/customFn' as keyof Asserts](
+            Object.keys(fakeNode),
+            { word: 'foo' },
+            assertionProperties
+          )
+        ).toEqual([
+          {
+            message: 'First value should be foo',
+            location: baseLocation.key(),
+          },
+        ]);
+        expect(customFn.mock.calls.length).toBe(1);
+        expect(customFn.mock.calls[0][0]).toEqual(Object.keys(fakeNode));
+      });
+    });
+  });
+});