@redocly/openapi-core 1.0.0-beta.101 → 1.0.0-beta.104

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

@@ -1,5 +1,9 @@
+import { Location } from '../../../../ref-utils';
+import { Source } from '../../../../resolve';
 import { asserts } from '../asserts';
 
+let baseLocation = new Location(jest.fn() as any as Source, 'pointer');
+
 describe('oas3 assertions', () => {
   describe('generic rules', () => {
     const fakeNode = {
@@ -10,232 +14,231 @@ describe('oas3 assertions', () => {
 
     describe('pattern', () => {
       it('value should match regex pattern', () => {
-        expect(asserts.pattern('test string', '/test/')).toBeTruthy();
-        expect(asserts.pattern('test string', '/test me/')).toBeFalsy();
-        expect(asserts.pattern(['test string', 'test me'], '/test/')).toBeTruthy();
-        expect(asserts.pattern(['test string', 'test me'], '/test me/')).toBeFalsy();
+        expect(asserts.pattern('test string', '/test/', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.pattern('test string', '/test me/', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.pattern(['test string', 'test me'], '/test/', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.pattern(['test string', 'test me'], '/test me/', baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
+        expect(asserts.pattern('./components/smth/test.yaml', '/^(./)?components/.*.yaml$/', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.pattern('./other.yaml', '/^(./)?components/.*.yaml$/', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+      });
+    });
+
+    describe('ref', () => {
+      it('value should have ref', () => {
+        expect(asserts.ref({ $ref: 'text' }, true, baseLocation, { $ref: 'text' })).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.ref({}, true, baseLocation, {})).toEqual({ isValid: false, location: baseLocation.key() });
+      });
+
+      it('value should not have ref', () => {
+        expect(asserts.ref({ $ref: 'text' }, false, baseLocation, { $ref: 'text' })).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.ref({}, false, baseLocation, {})).toEqual({ isValid: true, location: baseLocation.key() });
+      });
+
+      it('value should match regex pattern', () => {
+        expect(asserts.ref({ $ref: 'test string' }, '/test/', baseLocation, { $ref: 'test string' })).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.ref({ $ref: 'test string' }, '/test me/', baseLocation, { $ref: 'test string' })).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.ref({ $ref: './components/smth/test.yaml' }, '/^(./)?components/.*.yaml$/', baseLocation, { $ref: './components/smth/test.yaml' })).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.ref({ $ref: './paths/smth/test.yaml' }, '/^(./)?components/.*.yaml$/', baseLocation, { $ref: './paths/smth/test.yaml' })).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     describe('enum', () => {
       it('value should be among predefined keys', () => {
-        expect(asserts.enum('test', ['test', 'example'])).toBeTruthy();
-        expect(asserts.enum(['test'], ['test', 'example'])).toBeTruthy();
-        expect(asserts.enum(['test', 'example'], ['test', 'example'])).toBeTruthy();
-        expect(asserts.enum(['test', 'example', 'foo'], ['test', 'example'])).toBeFalsy();
-        expect(asserts.enum('test', ['foo', 'example'])).toBeFalsy();
-        expect(asserts.enum(['test', 'foo'], ['test', 'example'])).toBeFalsy();
+        expect(asserts.enum('test', ['test', 'example'], baseLocation)).toEqual({ isValid: true });
+        expect(asserts.enum(['test'], ['test', 'example'], baseLocation)).toEqual({ isValid: true });
+        expect(asserts.enum(['test', 'example'], ['test', 'example'], baseLocation)).toEqual({ isValid: true });
+        expect(asserts.enum(['test', 'example', 'foo'], ['test', 'example'], baseLocation)).toEqual({ isValid: false, location: baseLocation.child('foo').key() });
+        expect(asserts.enum('test', ['foo', 'example'], baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.enum(['test', 'foo'], ['test', 'example'], baseLocation)).toEqual({ isValid: false, location: baseLocation.child('foo').key() });
       });
     });
 
     describe('defined', () => {
       it('value should be defined', () => {
-        expect(asserts.defined('test', true)).toBeTruthy();
-        expect(asserts.defined(undefined, true)).toBeFalsy();
+        expect(asserts.defined('test', true, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.defined(undefined, true, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be undefined', () => {
-        expect(asserts.defined(undefined, false)).toBeTruthy();
-        expect(asserts.defined('test', false)).toBeFalsy();
+        expect(asserts.defined(undefined, false, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.defined('test', false, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     describe('undefined', () => {
       it('value should be undefined', () => {
-        expect(asserts.undefined(undefined, true)).toBeTruthy();
-        expect(asserts.undefined('test', true)).toBeFalsy();
+        expect(asserts.undefined(undefined, true, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.undefined('test', true, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be defined', () => {
-        expect(asserts.undefined('test', false)).toBeTruthy();
-        expect(asserts.undefined(undefined, false)).toBeFalsy();
+        expect(asserts.undefined('test', false, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.undefined(undefined, false, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     describe('required', () => {
       it('values should be required', () => {
-        expect(asserts.required(['one', 'two', 'three'], ['one', 'two'])).toBeTruthy();
-        expect(asserts.required(['one', 'two'], ['one', 'two', 'three'])).toBeFalsy();
+        expect(asserts.required(['one', 'two', 'three'], ['one', 'two'], baseLocation)).toEqual({ isValid: true });
+        expect(asserts.required(['one', 'two'], ['one', 'two', 'three'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
       });
     });
 
     describe('nonEmpty', () => {
       it('value should not be empty', () => {
-        expect(asserts.nonEmpty('test', true)).toBeTruthy();
-        expect(asserts.nonEmpty('', true)).toBeFalsy();
-        expect(asserts.nonEmpty(null, true)).toBeFalsy();
-        expect(asserts.nonEmpty(undefined, true)).toBeFalsy();
+        expect(asserts.nonEmpty('test', true, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.nonEmpty('', true, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.nonEmpty(null, true, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.nonEmpty(undefined, true, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be empty', () => {
-        expect(asserts.nonEmpty('', false)).toBeTruthy();
-        expect(asserts.nonEmpty(null, false)).toBeTruthy();
-        expect(asserts.nonEmpty(undefined, false)).toBeTruthy();
-        expect(asserts.nonEmpty('test', false)).toBeFalsy();
+        expect(asserts.nonEmpty('', false, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.nonEmpty(null, false, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.nonEmpty(undefined, false, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.nonEmpty('test', false, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     describe('minLength', () => {
       it('value should have less or equal than 5 symbols length', () => {
-        expect(asserts.minLength('test', 5)).toBeFalsy();
-        expect(asserts.minLength([1, 2, 3, 4], 5)).toBeFalsy();
-        expect(asserts.minLength([1, 2, 3, 4, 5], 5)).toBeTruthy();
-        expect(asserts.minLength([1, 2, 3, 4, 5, 6], 5)).toBeTruthy();
-        expect(asserts.minLength('example', 5)).toBeTruthy();
-        expect(asserts.minLength([], 5)).toBeFalsy();
-        expect(asserts.minLength('', 5)).toBeFalsy();
+        expect(asserts.minLength('test', 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.minLength([1, 2, 3, 4], 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.minLength([1, 2, 3, 4, 5], 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.minLength([1, 2, 3, 4, 5, 6], 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.minLength('example', 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.minLength([], 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.minLength('', 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     describe('maxLength', () => {
       it('value should have more or equal than 5 symbols length', () => {
-        expect(asserts.maxLength('test', 5)).toBeTruthy();
-        expect(asserts.maxLength([1, 2, 3, 4], 5)).toBeTruthy();
-        expect(asserts.maxLength([1, 2, 3, 4, 5], 5)).toBeTruthy();
-        expect(asserts.maxLength([1, 2, 3, 4, 5, 6], 5)).toBeFalsy();
-        expect(asserts.maxLength('example', 5)).toBeFalsy();
-        expect(asserts.maxLength([], 5)).toBeTruthy();
-        expect(asserts.maxLength('', 5)).toBeTruthy();
+        expect(asserts.maxLength('test', 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.maxLength([1, 2, 3, 4], 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.maxLength([1, 2, 3, 4, 5], 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.maxLength([1, 2, 3, 4, 5, 6], 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.maxLength('example', 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.maxLength([], 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.maxLength('', 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
       });
     });
 
     describe('casing', () => {
       it('value should be camelCase', () => {
-        expect(asserts.casing(['testExample', 'fooBar'], 'camelCase')).toBeTruthy();
-        expect(asserts.casing(['testExample', 'FooBar'], 'camelCase')).toBeFalsy();
-        expect(asserts.casing('testExample', 'camelCase')).toBeTruthy();
-        expect(asserts.casing('TestExample', 'camelCase')).toBeFalsy();
-        expect(asserts.casing('test-example', 'camelCase')).toBeFalsy();
-        expect(asserts.casing('test_example', 'camelCase')).toBeFalsy();
+        expect(asserts.casing(['testExample', 'fooBar'], 'camelCase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['testExample', 'FooBar'], 'camelCase', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('FooBar').key() });
+        expect(asserts.casing('testExample', 'camelCase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing('TestExample', 'camelCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'camelCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test_example', 'camelCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be PascalCase', () => {
-        expect(asserts.casing('TestExample', 'PascalCase')).toBeTruthy();
-        expect(asserts.casing(['TestExample', 'FooBar'], 'PascalCase')).toBeTruthy();
-        expect(asserts.casing(['TestExample', 'fooBar'], 'PascalCase')).toBeFalsy();
-        expect(asserts.casing('testExample', 'PascalCase')).toBeFalsy();
-        expect(asserts.casing('test-example', 'PascalCase')).toBeFalsy();
-        expect(asserts.casing('test_example', 'PascalCase')).toBeFalsy();
+        expect(asserts.casing('TestExample', 'PascalCase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TestExample', 'FooBar'], 'PascalCase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TestExample', 'fooBar'], 'PascalCase', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('fooBar').key() });
+        expect(asserts.casing('testExample', 'PascalCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'PascalCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test_example', 'PascalCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be kebab-case', () => {
-        expect(asserts.casing('test-example', 'kebab-case')).toBeTruthy();
-        expect(asserts.casing(['test-example', 'foo-bar'], 'kebab-case')).toBeTruthy();
-        expect(asserts.casing(['test-example', 'foo_bar'], 'kebab-case')).toBeFalsy();
-        expect(asserts.casing('testExample', 'kebab-case')).toBeFalsy();
-        expect(asserts.casing('TestExample', 'kebab-case')).toBeFalsy();
-        expect(asserts.casing('test_example', 'kebab-case')).toBeFalsy();
+        expect(asserts.casing('test-example', 'kebab-case', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['test-example', 'foo-bar'], 'kebab-case', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['test-example', 'foo_bar'], 'kebab-case', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('foo_bar').key() });
+        expect(asserts.casing('testExample', 'kebab-case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TestExample', 'kebab-case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test_example', 'kebab-case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be snake_case', () => {
-        expect(asserts.casing('test_example', 'snake_case')).toBeTruthy();
-        expect(asserts.casing(['test_example', 'foo_bar'], 'snake_case')).toBeTruthy();
-        expect(asserts.casing(['test_example', 'foo-bar'], 'snake_case')).toBeFalsy();
-        expect(asserts.casing('testExample', 'snake_case')).toBeFalsy();
-        expect(asserts.casing('TestExample', 'snake_case')).toBeFalsy();
-        expect(asserts.casing('test-example', 'snake_case')).toBeFalsy();
+        expect(asserts.casing('test_example', 'snake_case', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['test_example', 'foo_bar'], 'snake_case', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['test_example', 'foo-bar'], 'snake_case', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('foo-bar').key() });
+        expect(asserts.casing('testExample', 'snake_case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TestExample', 'snake_case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'snake_case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be MACRO_CASE', () => {
-        expect(asserts.casing('TEST_EXAMPLE', 'MACRO_CASE')).toBeTruthy();
-        expect(asserts.casing(['TEST_EXAMPLE', 'FOO_BAR'], 'MACRO_CASE')).toBeTruthy();
-        expect(asserts.casing(['TEST_EXAMPLE', 'FOO-BAR'], 'MACRO_CASE')).toBeFalsy();
-        expect(asserts.casing('TEST_EXAMPLE_', 'MACRO_CASE')).toBeFalsy();
-        expect(asserts.casing('_TEST_EXAMPLE', 'MACRO_CASE')).toBeFalsy();
-        expect(asserts.casing('TEST__EXAMPLE', 'MACRO_CASE')).toBeFalsy();
-        expect(asserts.casing('TEST-EXAMPLE', 'MACRO_CASE')).toBeFalsy();
-        expect(asserts.casing('testExample', 'MACRO_CASE')).toBeFalsy();
-        expect(asserts.casing('TestExample', 'MACRO_CASE')).toBeFalsy();
-        expect(asserts.casing('test-example', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('TEST_EXAMPLE', 'MACRO_CASE', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TEST_EXAMPLE', 'FOO_BAR'], 'MACRO_CASE', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TEST_EXAMPLE', 'FOO-BAR'], 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('FOO-BAR').key() });
+        expect(asserts.casing('TEST_EXAMPLE_', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('_TEST_EXAMPLE', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TEST__EXAMPLE', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TEST-EXAMPLE', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('testExample', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TestExample', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be COBOL-CASE', () => {
-        expect(asserts.casing('TEST-EXAMPLE', 'COBOL-CASE')).toBeTruthy();
-        expect(asserts.casing(['TEST-EXAMPLE', 'FOO-BAR'], 'COBOL-CASE')).toBeTruthy();
-        expect(asserts.casing(['TEST-EXAMPLE', 'FOO_BAR'], 'COBOL-CASE')).toBeFalsy();
-        expect(asserts.casing('TEST-EXAMPLE-', 'COBOL-CASE')).toBeFalsy();
-        expect(asserts.casing('0TEST-EXAMPLE', 'COBOL-CASE')).toBeFalsy();
-        expect(asserts.casing('-TEST-EXAMPLE', 'COBOL-CASE')).toBeFalsy();
-        expect(asserts.casing('TEST--EXAMPLE', 'COBOL-CASE')).toBeFalsy();
-        expect(asserts.casing('TEST_EXAMPLE', 'COBOL-CASE')).toBeFalsy();
-        expect(asserts.casing('testExample', 'COBOL-CASE')).toBeFalsy();
-        expect(asserts.casing('TestExample', 'COBOL-CASE')).toBeFalsy();
-        expect(asserts.casing('test-example', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('TEST-EXAMPLE', 'COBOL-CASE', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TEST-EXAMPLE', 'FOO-BAR'], 'COBOL-CASE', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TEST-EXAMPLE', 'FOO_BAR'], 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('FOO_BAR').key() });
+        expect(asserts.casing('TEST-EXAMPLE-', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('0TEST-EXAMPLE', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('-TEST-EXAMPLE', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TEST--EXAMPLE', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TEST_EXAMPLE', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('testExample', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TestExample', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be flatcase', () => {
-        expect(asserts.casing('testexample', 'flatcase')).toBeTruthy();
-        expect(asserts.casing(['testexample', 'foobar'], 'flatcase')).toBeTruthy();
-        expect(asserts.casing(['testexample', 'foo_bar'], 'flatcase')).toBeFalsy();
-        expect(asserts.casing('testexample_', 'flatcase')).toBeFalsy();
-        expect(asserts.casing('0testexample', 'flatcase')).toBeFalsy();
-        expect(asserts.casing('testExample', 'flatcase')).toBeFalsy();
-        expect(asserts.casing('TestExample', 'flatcase')).toBeFalsy();
-        expect(asserts.casing('test-example', 'flatcase')).toBeFalsy();
+        expect(asserts.casing('testexample', 'flatcase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['testexample', 'foobar'], 'flatcase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['testexample', 'foo_bar'], 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('foo_bar').key() });
+        expect(asserts.casing('testexample_', 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('0testexample', 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('testExample', 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TestExample', 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     describe.skip('sortOrder', () => {
       it('value should be ordered in ASC direction', () => {
-        expect(asserts.sortOrder(['example', 'foo', 'test'], 'asc')).toBeTruthy();
-        expect(asserts.sortOrder(['example', 'foo', 'test'], { direction: 'asc' })).toBeTruthy();
-        expect(asserts.sortOrder(['example'], 'asc')).toBeTruthy();
-        expect(asserts.sortOrder(['example', 'test', 'foo'], 'asc')).toBeFalsy();
-        expect(asserts.sortOrder(['example', 'foo', 'test'], 'desc')).toBeFalsy();
-        expect(
-          asserts.sortOrder([{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }], {
-            direction: 'asc',
-            property: 'name',
-          }),
-        ).toBeTruthy();
-        expect(
-          asserts.sortOrder([{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }], {
-            direction: 'desc',
-            property: 'name',
-          }),
-        ).toBeFalsy();
+        expect(asserts.sortOrder(['example', 'foo', 'test'], 'asc', baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['example', 'foo', 'test'], { direction: 'asc' }, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['example'], 'asc', baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['example', 'test', 'foo'], 'asc', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.sortOrder(['example', 'foo', 'test'], 'desc', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.sortOrder([{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }], { direction: 'asc', property: 'name' }, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder([{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }], { direction: 'desc', property: 'name' }, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be ordered in DESC direction', () => {
-        expect(asserts.sortOrder(['test', 'foo', 'example'], 'desc')).toBeTruthy();
-        expect(asserts.sortOrder(['test', 'foo', 'example'], { direction: 'desc' })).toBeTruthy();
-        expect(asserts.sortOrder(['example'], 'desc')).toBeTruthy();
-        expect(asserts.sortOrder(['example', 'test', 'foo'], 'desc')).toBeFalsy();
-        expect(asserts.sortOrder(['test', 'foo', 'example'], 'asc')).toBeFalsy();
-        expect(
-          asserts.sortOrder([{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }], {
-            direction: 'desc',
-            property: 'name',
-          }),
-        ).toBeTruthy();
-        expect(
-          asserts.sortOrder([{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }], {
-            direction: 'asc',
-            property: 'name',
-          }),
-        ).toBeFalsy();
+        expect(asserts.sortOrder(['test', 'foo', 'example'], 'desc', baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['test', 'foo', 'example'], { direction: 'desc' }, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['example'], 'desc', baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['example', 'test', 'foo'], 'desc', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.sortOrder(['test', 'foo', 'example'], 'asc', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.sortOrder([{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }], { direction: 'desc', property: 'name' }, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder([{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }], { direction: 'asc', property: 'name' }, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     describe('mutuallyExclusive', () => {
       it('node should not have more than one property from predefined list', () => {
-        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'test'])).toBeTruthy();
-        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), [])).toBeTruthy();
-        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'bar'])).toBeFalsy();
-        expect(
-          asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'bar', 'test']),
-        ).toBeFalsy();
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'test'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), [], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'bar'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'bar', 'test'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
       });
     });
 
     describe('mutuallyRequired', () => {
       it('node should have all the properties from predefined list', () => {
-        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar'])).toBeTruthy();
-        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar', 'baz'])).toBeTruthy();
-        expect(asserts.mutuallyRequired(Object.keys(fakeNode), [])).toBeTruthy();
-        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'test'])).toBeFalsy();
-        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar', 'test'])).toBeFalsy();
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar', 'baz'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), [], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'test'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar', 'test'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
       });
     });
 
     describe('requireAny', () => {
       it('node must have at least one property from predefined list', () => {
-        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'test'])).toBeTruthy();
-        expect(asserts.requireAny(Object.keys(fakeNode), ['test', 'bar'])).toBeTruthy();
-        expect(asserts.requireAny(Object.keys(fakeNode), [])).toBeFalsy();
-        expect(asserts.requireAny(Object.keys(fakeNode), ['test', 'test1'])).toBeFalsy();
-        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'bar'])).toBeTruthy();
-        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'bar', 'test'])).toBeTruthy();
+        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'test'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.requireAny(Object.keys(fakeNode), ['test', 'bar'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.requireAny(Object.keys(fakeNode), [], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
+        expect(asserts.requireAny(Object.keys(fakeNode), ['test', 'test1'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
+        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'bar'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'bar', 'test'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
       });
     });
   });

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

@@ -1,6 +1,18 @@
-import { OrderOptions, OrderDirection, isOrdered, getIntersectionLength } from './utils';
+import { Location } from '../../../ref-utils';
+import { isString as runOnValue } from '../../../utils';
+import {
+  OrderOptions,
+  OrderDirection,
+  isOrdered,
+  getIntersectionLength,
+  regexFromString,
+} from './utils';
 
-type Asserts = Record<string, (value: any, condition: any) => boolean>;
+type AssertResult = { isValid: boolean; location?: Location };
+type Asserts = Record<
+  string,
+  (value: any, condition: any, baseLocation: Location, rawValue?: any) => AssertResult
+>;
 
 export const runOnKeysSet = new Set([
   'mutuallyExclusive',
@@ -13,6 +25,8 @@ export const runOnKeysSet = new Set([
   'sortOrder',
   'disallowed',
   'required',
+  'requireAny',
+  'ref',
 ]);
 export const runOnValuesSet = new Set([
   'pattern',
@@ -24,73 +38,82 @@ export const runOnValuesSet = new Set([
   'maxLength',
   'casing',
   'sortOrder',
+  'ref',
 ]);
 
 export const asserts: Asserts = {
-  pattern: (value: string | string[], condition: string): boolean => {
-    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
-    const values = typeof value === 'string' ? [value] : value;
-    const regexOptions = condition.match(/(\b\/\b)(.+)/g) || ['/'];
-    condition = condition.slice(1).replace(regexOptions[0], '');
-    const regx = new RegExp(condition, regexOptions[0].slice(1));
+  pattern: (value: string | string[], condition: string, baseLocation: Location) => {
+    if (typeof value === 'undefined') return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+    const values = runOnValue(value) ? [value] : value;
+    const regx = regexFromString(condition);
     for (let _val of values) {
-      if (!_val.match(regx)) {
-        return false;
+      if (!regx?.test(_val)) {
+        return { isValid: false, location: runOnValue(value) ? baseLocation : baseLocation.key() };
       }
     }
-    return true;
+    return { isValid: true };
   },
-  enum: (value: string | string[], condition: string[]): boolean => {
-    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
-    const values = typeof value === 'string' ? [value] : value;
+  enum: (value: string | string[], condition: string[], baseLocation: Location) => {
+    if (typeof value === 'undefined') return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+    const values = runOnValue(value) ? [value] : value;
     for (let _val of values) {
       if (!condition.includes(_val)) {
-        return false;
+        return {
+          isValid: false,
+          location: runOnValue(value) ? baseLocation : baseLocation.child(_val).key(),
+        };
       }
     }
-    return true;
+    return { isValid: true };
   },
-  defined: (value: string | undefined, condition: boolean = true): boolean => {
+  defined: (value: string | undefined, condition: boolean = true, baseLocation: Location) => {
     const isDefined = typeof value !== 'undefined';
-    return condition ? isDefined : !isDefined;
+    return { isValid: condition ? isDefined : !isDefined, location: baseLocation };
   },
-  required: (value: string[], keys: string[]): boolean => {
+  required: (value: string[], keys: string[], baseLocation: Location) => {
     for (const requiredKey of keys) {
       if (!value.includes(requiredKey)) {
-        return false;
+        return { isValid: false, location: baseLocation.key() };
       }
     }
-    return true;
+    return { isValid: true };
   },
-  disallowed: (value: string | string[], condition: string[]): boolean => {
-    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
-    const values = typeof value === 'string' ? [value] : value;
+  disallowed: (value: string | string[], condition: string[], baseLocation: Location) => {
+    if (typeof value === 'undefined') return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+    const values = runOnValue(value) ? [value] : value;
     for (let _val of values) {
       if (condition.includes(_val)) {
-        return false;
+        return {
+          isValid: false,
+          location: runOnValue(value) ? baseLocation : baseLocation.child(_val).key(),
+        };
       }
     }
-    return true;
+    return { isValid: true };
   },
-  undefined: (value: any, condition: boolean = true): boolean => {
+  undefined: (value: any, condition: boolean = true, baseLocation: Location) => {
     const isUndefined = typeof value === 'undefined';
-    return condition ? isUndefined : !isUndefined;
+    return { isValid: condition ? isUndefined : !isUndefined, location: baseLocation };
   },
-  nonEmpty: (value: string | undefined | null, condition: boolean = true): boolean => {
+  nonEmpty: (
+    value: string | undefined | null,
+    condition: boolean = true,
+    baseLocation: Location
+  ) => {
     const isEmpty = typeof value === 'undefined' || value === null || value === '';
-    return condition ? !isEmpty : isEmpty;
+    return { isValid: condition ? !isEmpty : isEmpty, location: baseLocation };
   },
-  minLength: (value: string | any[], condition: number): boolean => {
-    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
-    return value.length >= condition;
+  minLength: (value: string | any[], condition: number, baseLocation: Location) => {
+    if (typeof value === 'undefined') return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+    return { isValid: value.length >= condition, location: baseLocation };
   },
-  maxLength: (value: string | any[], condition: number): boolean => {
-    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
-    return value.length <= condition;
+  maxLength: (value: string | any[], condition: number, baseLocation: Location) => {
+    if (typeof value === 'undefined') return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+    return { isValid: value.length <= condition, location: baseLocation };
   },
-  casing: (value: string | string[], condition: string): boolean => {
-    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
-    const values = typeof value === 'string' ? [value] : value;
+  casing: (value: string | string[], condition: string, baseLocation: Location) => {
+    if (typeof value === 'undefined') return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+    const values: string[] = runOnValue(value) ? [value] : value;
     for (let _val of values) {
       let matchCase = false;
       switch (condition) {
@@ -117,24 +140,46 @@ export const asserts: Asserts = {
           break;
       }
       if (!matchCase) {
-        return false;
+        return {
+          isValid: false,
+          location: runOnValue(value) ? baseLocation : baseLocation.child(_val).key(),
+        };
       }
     }
-    return true;
+    return { isValid: true };
   },
-  sortOrder: (value: any[], condition: OrderOptions | OrderDirection): boolean => {
-    if (typeof value === 'undefined') return true;
-    return isOrdered(value, condition);
+  sortOrder: (value: any[], condition: OrderOptions | OrderDirection, baseLocation: Location) => {
+    if (typeof value === 'undefined') return { isValid: true };
+    return { isValid: isOrdered(value, condition), location: baseLocation };
   },
-  mutuallyExclusive: (value: string[], condition: string[]): boolean => {
-    return getIntersectionLength(value, condition) < 2;
+  mutuallyExclusive: (value: string[], condition: string[], baseLocation: Location) => {
+    return { isValid: getIntersectionLength(value, condition) < 2, location: baseLocation.key() };
   },
-  mutuallyRequired: (value: string[], condition: string[]): boolean => {
-    return getIntersectionLength(value, condition) > 0
-      ? getIntersectionLength(value, condition) === condition.length
-      : true;
+  mutuallyRequired: (value: string[], condition: string[], baseLocation: Location) => {
+    return {
+      isValid:
+        getIntersectionLength(value, condition) > 0
+          ? getIntersectionLength(value, condition) === condition.length
+          : true,
+      location: baseLocation.key(),
+    };
   },
-  requireAny: (value: string[], condition: string[]): boolean => {
-    return getIntersectionLength(value, condition) >= 1;
+  requireAny: (value: string[], condition: string[], baseLocation: Location) => {
+    return { isValid: getIntersectionLength(value, condition) >= 1, location: baseLocation.key() };
+  },
+  ref: (_value: any, condition: string | boolean, baseLocation, rawValue: any) => {
+    if (typeof rawValue === 'undefined') return { isValid: true }; // property doesn't exist, no need to lint it with this assert
+    const hasRef = rawValue.hasOwnProperty('$ref');
+    if (typeof condition === 'boolean') {
+      return {
+        isValid: condition ? hasRef : !hasRef,
+        location: hasRef ? baseLocation : baseLocation.key(),
+      };
+    }
+    const regex = regexFromString(condition);
+    return {
+      isValid: hasRef && regex?.test(rawValue['$ref']),
+      location: hasRef ? baseLocation : baseLocation.key(),
+    };
   },
 };