@redocly/openapi-core 1.0.0-beta.91 → 1.0.0-beta.94

package/src/config/__tests__/config.test.ts

@@ -0,0 +1,256 @@
+import { Config, getMergedConfig } from '../config';
+
+const testConfig: Config = {
+  rawConfig: {
+    apis: {
+      'test@v1': {
+        root: 'resources/pets.yaml',
+        lint: { extends: [], rules: { 'operation-summary': 'warn' } },
+      },
+    },
+    organization: 'redocly-test',
+    lint: {
+      extends: [],
+      rules: { 'operation-summary': 'error', 'no-empty-servers': 'error' },
+      plugins: [],
+    },
+  },
+  configFile: 'redocly.yaml',
+  apis: {
+    'test@v1': {
+      root: 'resources/pets.yaml',
+      lint: { extends: [], rules: { 'operation-summary': 'warn' } },
+    },
+  },
+  // @ts-ignore
+  lint: {
+    rawConfig: {
+      extends: [],
+      rules: { 'operation-summary': 'error', 'no-empty-servers': 'error' },
+      plugins: [],
+    },
+    configFile: 'redocly.yaml',
+    ignore: {},
+    _usedRules: new Set(),
+    _usedVersions: new Set(),
+    recommendedFallback: false,
+    plugins: [],
+    doNotResolveExamples: false,
+    rules: {
+      oas2: { 'operation-summary': 'error', 'no-empty-servers': 'error' },
+      oas3_0: { 'operation-summary': 'error', 'no-empty-servers': 'error' },
+      oas3_1: { 'operation-summary': 'error', 'no-empty-servers': 'error' },
+    },
+    preprocessors: { oas2: {}, oas3_0: {}, oas3_1: {} },
+    decorators: { oas2: {}, oas3_0: {}, oas3_1: {} },
+  },
+  'features.openapi': {},
+  'features.mockServer': {},
+  resolve: { http: { headers: [] } },
+  organization: 'redocly-test',
+};
+
+describe('getMergedConfig', () => {
+  it('should merge lint defined in "apis" section the root one', () => {
+    expect(getMergedConfig(testConfig, 'test@v1')).toMatchInlineSnapshot(`
+      Config {
+        "apis": Object {
+          "test@v1": Object {
+            "lint": Object {
+              "extends": Array [],
+              "rules": Object {
+                "operation-summary": "warn",
+              },
+            },
+            "root": "resources/pets.yaml",
+          },
+        },
+        "configFile": "redocly.yaml",
+        "features.mockServer": Object {},
+        "features.openapi": Object {},
+        "lint": LintConfig {
+          "_usedRules": Set {},
+          "_usedVersions": Set {},
+          "configFile": "redocly.yaml",
+          "decorators": Object {
+            "oas2": Object {},
+            "oas3_0": Object {},
+            "oas3_1": Object {},
+          },
+          "doNotResolveExamples": false,
+          "ignore": Object {},
+          "plugins": Array [],
+          "preprocessors": Object {
+            "oas2": Object {},
+            "oas3_0": Object {},
+            "oas3_1": Object {},
+          },
+          "rawConfig": Object {
+            "decorators": Object {},
+            "extends": Array [],
+            "plugins": Array [],
+            "preprocessors": Object {},
+            "rules": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "warn",
+            },
+          },
+          "recommendedFallback": false,
+          "rules": Object {
+            "oas2": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "warn",
+            },
+            "oas3_0": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "warn",
+            },
+            "oas3_1": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "warn",
+            },
+          },
+        },
+        "organization": "redocly-test",
+        "rawConfig": Object {
+          "apis": Object {
+            "test@v1": Object {
+              "lint": Object {
+                "extends": Array [],
+                "rules": Object {
+                  "operation-summary": "warn",
+                },
+              },
+              "root": "resources/pets.yaml",
+            },
+          },
+          "features.mockServer": Object {},
+          "features.openapi": Object {},
+          "lint": Object {
+            "decorators": Object {},
+            "extends": Array [],
+            "plugins": Array [],
+            "preprocessors": Object {},
+            "rules": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "warn",
+            },
+          },
+          "organization": "redocly-test",
+        },
+        "region": undefined,
+        "resolve": Object {
+          "http": Object {
+            "customFetch": undefined,
+            "headers": Array [],
+          },
+        },
+      }
+    `);
+  });
+  it('should take into account a config file', () => {
+    const result = getMergedConfig(testConfig, 'test@v1');
+    expect(result.configFile).toEqual('redocly.yaml');
+    expect(result.lint.configFile).toEqual('redocly.yaml');
+  });
+  it('should return the same config when there is no alias provided', () => {
+    expect(getMergedConfig(testConfig)).toEqual(testConfig);
+  });
+  it('should handle wrong alias - return the same lint, empty features', () => {
+    expect(getMergedConfig(testConfig, 'wrong-alias')).toMatchInlineSnapshot(`
+      Config {
+        "apis": Object {
+          "test@v1": Object {
+            "lint": Object {
+              "extends": Array [],
+              "rules": Object {
+                "operation-summary": "warn",
+              },
+            },
+            "root": "resources/pets.yaml",
+          },
+        },
+        "configFile": "redocly.yaml",
+        "features.mockServer": Object {},
+        "features.openapi": Object {},
+        "lint": LintConfig {
+          "_usedRules": Set {},
+          "_usedVersions": Set {},
+          "configFile": "redocly.yaml",
+          "decorators": Object {
+            "oas2": Object {},
+            "oas3_0": Object {},
+            "oas3_1": Object {},
+          },
+          "doNotResolveExamples": false,
+          "ignore": Object {},
+          "plugins": Array [],
+          "preprocessors": Object {
+            "oas2": Object {},
+            "oas3_0": Object {},
+            "oas3_1": Object {},
+          },
+          "rawConfig": Object {
+            "decorators": Object {},
+            "extends": Array [],
+            "plugins": Array [],
+            "preprocessors": Object {},
+            "rules": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "error",
+            },
+          },
+          "recommendedFallback": false,
+          "rules": Object {
+            "oas2": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "error",
+            },
+            "oas3_0": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "error",
+            },
+            "oas3_1": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "error",
+            },
+          },
+        },
+        "organization": "redocly-test",
+        "rawConfig": Object {
+          "apis": Object {
+            "test@v1": Object {
+              "lint": Object {
+                "extends": Array [],
+                "rules": Object {
+                  "operation-summary": "warn",
+                },
+              },
+              "root": "resources/pets.yaml",
+            },
+          },
+          "features.mockServer": Object {},
+          "features.openapi": Object {},
+          "lint": Object {
+            "decorators": Object {},
+            "extends": Array [],
+            "plugins": Array [],
+            "preprocessors": Object {},
+            "rules": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "error",
+            },
+          },
+          "organization": "redocly-test",
+        },
+        "region": undefined,
+        "resolve": Object {
+          "http": Object {
+            "customFetch": undefined,
+            "headers": Array [],
+          },
+        },
+      }
+    `);
+  });
+});

package/src/config/all.ts

@@ -19,6 +19,7 @@ export default {
     'operation-description': 'error',
     'operation-2xx-response': 'error',
     'operation-4xx-response': 'error',
+    'assertions': 'error',
     'operation-operationId': 'error',
     'operation-summary': 'error',
     'operation-operationId-unique': 'error',

package/src/config/config.ts

@@ -646,19 +646,22 @@ function assignExisting<T>(target: Record<string, T>, obj: Record<string, T>) {
 
 export function getMergedConfig(config: Config, entrypointAlias?: string): Config {
   return entrypointAlias
-    ? new Config({
-        ...config.rawConfig,
-        lint: getMergedLintConfig(config, entrypointAlias),
-        'features.openapi': {
-          ...config['features.openapi'],
-          ...config.apis[entrypointAlias]?.['features.openapi'],
+    ? new Config(
+        {
+          ...config.rawConfig,
+          lint: getMergedLintConfig(config, entrypointAlias),
+          'features.openapi': {
+            ...config['features.openapi'],
+            ...config.apis[entrypointAlias]?.['features.openapi'],
+          },
+          'features.mockServer': {
+            ...config['features.mockServer'],
+            ...config.apis[entrypointAlias]?.['features.mockServer'],
+          },
+          // TODO: merge everything else here
         },
-        'features.mockServer': {
-          ...config['features.mockServer'],
-          ...config.apis[entrypointAlias]?.['features.mockServer'],
-        },
-        // TODO: merge everything else here
-      })
+        config.configFile,
+      )
     : config;
 }
 

package/src/config/minimal.ts

@@ -18,6 +18,7 @@ export default {
     'operation-description': 'off',
     'operation-2xx-response': 'warn',
     'operation-4xx-response': 'off',
+    'assertions': 'warn',
     'operation-operationId': 'warn',
     'operation-summary': 'warn',
     'operation-operationId-unique': 'warn',

package/src/config/recommended.ts

@@ -17,6 +17,7 @@ export default {
     'path-parameters-defined': 'error',
     'operation-description': 'off',
     'operation-2xx-response': 'warn',
+    'assertions': 'warn',
     'operation-4xx-response': 'warn',
     'operation-operationId': 'warn',
     'operation-summary': 'error',

package/src/config/rules.ts

@@ -24,14 +24,23 @@ export function initRules<T extends Function, P extends RuleSet<T>>(
           return undefined;
         }
 
-        const visitor = rule(ruleSettings);
+        const visitors = rule(ruleSettings);
+
+        if (Array.isArray(visitors)) {
+          return visitors.map((visitor: any) => ({
+            severity: ruleSettings.severity,
+            ruleId,
+            visitor: visitor,
+          }))
+        }
 
         return {
           severity: ruleSettings.severity,
           ruleId,
-          visitor,
+          visitor: visitors, // note: actually it is only one visitor object
         };
       }),
     )
+    .flatMap(visitor => visitor)
     .filter(notUndefined);
 }

package/src/lint.ts

@@ -11,7 +11,7 @@ import { LintConfig, Config } from './config/config';
 import { normalizeTypes } from './types';
 import { initRules } from './config/rules';
 import { releaseAjvInstance } from './rules/ajv';
-import { detectOpenAPI, OasMajorVersion, OasVersion, openAPIMajor } from './oas-types';
+import { detectOpenAPI, Oas3RuleSet, OasMajorVersion, OasVersion, openAPIMajor } from './oas-types';
 import { ConfigTypes } from './types/redocly-yaml';
 import { OasSpec } from './rules/common/spec';
 import { defaultPlugin } from './config/builtIn';
@@ -76,8 +76,8 @@ export async function lintDocument(opts: {
   };
 
   const preprocessors = initRules(rules as any, config, 'preprocessors', oasVersion);
-  const regularRules = initRules(rules as any, config, 'rules', oasVersion);
-  const normalizedVisitors = normalizeVisitors([...preprocessors, ...regularRules], types);
+  const regularRules = initRules(rules as Oas3RuleSet[], config, 'rules', oasVersion);
+  const normalizedVisitors = normalizeVisitors([...preprocessors, ...regularRules] as any, types);
   const resolvedRefMap = await resolveDocument({
     rootDocument: document,
     rootType: types.DefinitionRoot,

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

@@ -0,0 +1,231 @@
+import { asserts } from '../asserts';
+
+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/')).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();
+      });
+    });
+
+    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();
+      });
+    });
+
+    describe('defined', () => {
+      it('value should be defined', () => {
+        expect(asserts.defined('test', true)).toBeTruthy();
+        expect(asserts.defined(undefined, true)).toBeFalsy();
+      });
+      it('value should be undefined', () => {
+        expect(asserts.defined(undefined, false)).toBeTruthy();
+        expect(asserts.defined('test', false)).toBeFalsy();
+      });
+    });
+
+    describe('undefined', () => {
+      it('value should be undefined', () => {
+        expect(asserts.undefined(undefined, true)).toBeTruthy();
+        expect(asserts.undefined('test', true)).toBeFalsy();
+      });
+      it('value should be defined', () => {
+        expect(asserts.undefined('test', false)).toBeTruthy();
+        expect(asserts.undefined(undefined, false)).toBeFalsy();
+      });
+    });
+
+    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();
+      });
+    });
+
+    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();
+      });
+      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();
+      });
+    });
+
+    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();
+      });
+    });
+
+    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();
+      });
+    });
+
+    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();
+      });
+      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();
+      });
+      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();
+      });
+      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();
+      });
+      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();
+      });
+      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();
+      });
+      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();
+      });
+    });
+
+    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();
+      });
+      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();
+      });
+    });
+
+    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();
+      });
+    });
+
+    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();
+      });
+    });
+  });
+});

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

@@ -0,0 +1,65 @@
+import { Assertions } from '../.';
+
+const opts = {
+  '0': {
+    subject: 'Operation',
+    property: 'summary',
+    description: 'example warn text',
+    severity: 'warn',
+    pattern: '/example/',
+  },
+  '1': {
+    subject: 'PathItem',
+    context: [{ type: 'Operation', matchParentKeys: ['post'] }],
+    description: 'example warn text',
+    severity: 'warn',
+    mutuallyExclusive: ['summary', 'security'],
+  },
+  '2': {
+    subject: ['PathItem'],
+    context: [{ type: 'Operation' }],
+    property: 'tags',
+    description: 'example warn text',
+    severity: 'warn',
+    sortOrder: 'desc',
+  },
+  '3': {
+    subject: ['Foo'],
+    context: [{ type: 'Bar' }, { type: 'Baz' }],
+    property: 'test',
+    description: 'example warn text',
+    severity: 'warn',
+    sortOrder: 'desc',
+  },
+};
+
+describe('Oas3 assertions', () => {
+  it('should return the right visitor structure', () => {
+    const visitors = Assertions(opts) as any;
+    expect(visitors).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "Operation": [Function],
+        },
+        Object {
+          "Operation": Object {
+            "PathItem": [Function],
+            "skip": [Function],
+          },
+        },
+        Object {
+          "Operation": Object {
+            "PathItem": [Function],
+          },
+        },
+        Object {
+          "Bar": Object {
+            "Baz": Object {
+              "Foo": [Function],
+            },
+          },
+        },
+      ]
+    `);
+  });
+});