@redocly/openapi-core 1.0.0-beta.100

package/src/rules/common/no-http-verbs-in-paths.ts

@@ -0,0 +1,36 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { Oas2PathItem } from '../../typings/swagger';
+import { Oas3PathItem } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+import { isPathParameter, splitCamelCaseIntoWords } from '../../utils';
+
+const httpMethods = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
+
+export const NoHttpVerbsInPaths: Oas3Rule | Oas2Rule = ({ splitIntoWords }) => {
+  return {
+    PathItem(_path: Oas2PathItem | Oas3PathItem, { key, report, location }: UserContext) {
+      const pathKey = key.toString();
+      if (!pathKey.startsWith('/')) return;
+      const pathSegments = pathKey.split('/');
+
+      for (const pathSegment of pathSegments) {
+        if (!pathSegment || isPathParameter(pathSegment)) continue;
+
+        const isHttpMethodIncluded = (method: string) => {
+          return splitIntoWords
+            ? splitCamelCaseIntoWords(pathSegment).has(method)
+            : pathSegment.toLocaleLowerCase().includes(method);
+        };
+
+        for (const method of httpMethods) {
+          if (isHttpMethodIncluded(method)) {
+            report({
+              message: `path \`${pathKey}\` should not contain http verb ${method}`,
+              location: location.key(),
+            });
+          }
+        }
+      }
+    },
+  };
+};

package/src/rules/common/no-identical-paths.ts

@@ -0,0 +1,24 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+import { Oas3Paths } from '../../typings/openapi';
+import { Oas2Paths } from '../../typings/swagger';
+
+export const NoIdenticalPaths: Oas3Rule | Oas2Rule = () => {
+  return {
+    PathMap(pathMap: Oas3Paths | Oas2Paths, { report, location }: UserContext) {
+      const pathsMap = new Map<string, string>();
+      for (const pathName of Object.keys(pathMap)) {
+        const id = pathName.replace(/{.+?}/g, '{VARIABLE}');
+        const existingSamePath = pathsMap.get(id);
+        if (existingSamePath) {
+          report({
+            message: `The path already exists which differs only by path parameter name(s): \`${existingSamePath}\` and \`${pathName}\`.`,
+            location: location.child([pathName]).key(),
+          });
+        } else {
+          pathsMap.set(id, pathName);
+        }
+      }
+    },
+  };
+};

package/src/rules/common/no-invalid-parameter-examples.ts

@@ -0,0 +1,36 @@
+import { UserContext } from '../../walk';
+import { Oas3Parameter } from '../../typings/openapi';
+import { validateExample } from '../utils';
+
+export const NoInvalidParameterExamples: any = (opts: any) => {
+  const disallowAdditionalProperties = opts.disallowAdditionalProperties ?? true;
+  return {
+    Parameter: {
+      leave(parameter: Oas3Parameter, ctx: UserContext) {
+        if (parameter.example) {
+          validateExample(
+            parameter.example,
+            parameter.schema!,
+            ctx.location.child('example'),
+            ctx,
+            disallowAdditionalProperties,
+          );
+        }
+
+        if (parameter.examples) {
+          for (const [key, example] of Object.entries(parameter.examples)) {
+            if ('value' in example) {
+              validateExample(
+                example.value,
+                parameter.schema!,
+                ctx.location.child(['examples', key]),
+                ctx,
+                false,
+              );
+            }
+          }
+        }
+      },
+    },
+  };
+};

package/src/rules/common/no-invalid-schema-examples.ts

@@ -0,0 +1,27 @@
+import { UserContext } from '../../walk';
+import { Oas3_1Schema } from '../../typings/openapi';
+import { validateExample } from '../utils';
+
+export const NoInvalidSchemaExamples: any = (opts: any) => {
+  const disallowAdditionalProperties = opts.disallowAdditionalProperties ?? true;
+  return {
+    Schema: {
+      leave(schema: Oas3_1Schema, ctx: UserContext) {
+        if (schema.examples) {
+          for (const example of schema.examples) {
+            validateExample(
+              example,
+              schema,
+              ctx.location.child(['examples', schema.examples.indexOf(example)]),
+              ctx,
+              disallowAdditionalProperties,
+            );
+          }
+        }
+        if (schema.example) {
+          validateExample(schema.example, schema, ctx.location.child('example'), ctx, false);
+        }
+      },
+    },
+  };
+};

package/src/rules/common/no-path-trailing-slash.ts

@@ -0,0 +1,15 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+
+export const NoPathTrailingSlash: Oas3Rule | Oas2Rule = () => {
+  return {
+    PathItem(_path: any, { report, key, location }: UserContext) {
+      if ((key as string).endsWith('/') && key !== '/') {
+        report({
+          message: `\`${key}\` should not have a trailing slash.`,
+          location: location.key(),
+        });
+      }
+    },
+  };
+};

package/src/rules/common/operation-2xx-response.ts

@@ -0,0 +1,16 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+
+export const Operation2xxResponse: Oas3Rule | Oas2Rule = () => {
+  return {
+    ResponsesMap(responses: Record<string, object>, { report }: UserContext) {
+      const codes = Object.keys(responses);
+      if (!codes.some((code) => code === 'default' || /2[Xx0-9]{2}/.test(code))) {
+        report({
+          message: 'Operation must have at least one `2xx` response.',
+          location: { reportOnKey: true },
+        });
+      }
+    },
+  };
+};

package/src/rules/common/operation-4xx-response.ts

@@ -0,0 +1,17 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+
+export const Operation4xxResponse: Oas3Rule | Oas2Rule = () => {
+  return {
+    ResponsesMap(responses: Record<string, object>, { report }: UserContext) {
+      const codes = Object.keys(responses);
+
+      if (!codes.some((code) => /4[Xx0-9]{2}/.test(code))) {
+        report({
+          message: 'Operation must have at least one `4xx` response.',
+          location: { reportOnKey: true },
+        });
+      }
+    },
+  };
+};

package/src/rules/common/operation-description.ts

@@ -0,0 +1,13 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { validateDefinedAndNonEmpty } from '../utils';
+import { UserContext } from '../../walk';
+import { Oas2Operation } from '../../typings/swagger';
+import { Oas3Operation } from '../../typings/openapi';
+
+export const OperationDescription: Oas3Rule | Oas2Rule = () => {
+  return {
+    Operation(operation: Oas2Operation | Oas3Operation, ctx: UserContext) {
+      validateDefinedAndNonEmpty('description', operation, ctx);
+    },
+  };
+};

package/src/rules/common/operation-operationId-unique.ts

@@ -0,0 +1,21 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { Oas2Operation } from '../../typings/swagger';
+import { Oas3Operation } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+
+export const OperationIdUnique: Oas3Rule | Oas2Rule = () => {
+  const seenOperations = new Set();
+
+  return {
+    Operation(operation: Oas2Operation | Oas3Operation, { report, location }: UserContext) {
+      if (!operation.operationId) return;
+      if (seenOperations.has(operation.operationId)) {
+        report({
+          message: 'Every operation must have a unique `operationId`.',
+          location: location.child([operation.operationId]),
+        });
+      }
+      seenOperations.add(operation.operationId);
+    },
+  };
+};

package/src/rules/common/operation-operationId-url-safe.ts

@@ -0,0 +1,19 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { Oas2Operation } from '../../typings/swagger';
+import { Oas3Operation } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+
+const validUrlSymbols = /^[A-Za-z0-9-._~:/?#\[\]@!\$&'()*+,;=]*$/;
+
+export const OperationIdUrlSafe: Oas3Rule | Oas2Rule = () => {
+  return {
+    Operation(operation: Oas2Operation | Oas3Operation, { report, location }: UserContext) {
+      if (operation.operationId && !validUrlSymbols.test(operation.operationId)) {
+        report({
+          message: 'Operation `operationId` should not have URL invalid characters.',
+          location: location.child(['operationId']),
+        });
+      }
+    },
+  };
+};

package/src/rules/common/operation-operationId.ts

@@ -0,0 +1,17 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { validateDefinedAndNonEmpty } from '../utils';
+import { UserContext } from '../../walk';
+import { Oas2Operation } from '../../typings/swagger';
+import { Oas3Operation } from '../../typings/openapi';
+
+export const OperationOperationId: Oas3Rule | Oas2Rule = () => {
+  return {
+    DefinitionRoot: {
+      PathItem: {
+        Operation(operation: Oas2Operation | Oas3Operation, ctx: UserContext) {
+          validateDefinedAndNonEmpty('operationId', operation, ctx);
+        },
+      },
+    }
+  };
+};

package/src/rules/common/operation-parameters-unique.ts

@@ -0,0 +1,48 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { Oas2Parameter } from '../../typings/swagger';
+import { Oas3Parameter } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+
+export const OperationParametersUnique: Oas3Rule | Oas2Rule = () => {
+  let seenPathParams: Set<string>;
+  let seenOperationParams: Set<string>;
+
+  return {
+    PathItem: {
+      enter() {
+        seenPathParams = new Set();
+      },
+      Parameter(
+        parameter: Oas2Parameter | Oas3Parameter,
+        { report, key, parentLocations }: UserContext,
+      ) {
+        const paramId = `${parameter.in}___${parameter.name}`;
+        if (seenPathParams.has(paramId)) {
+          report({
+            message: `Paths must have unique \`name\` + \`in\` parameters.\nRepeats of \`in:${parameter.in}\` + \`name:${parameter.name}\`.`,
+            location: parentLocations.PathItem.child(['parameters', key]),
+          });
+        }
+        seenPathParams.add(`${parameter.in}___${parameter.name}`);
+      },
+      Operation: {
+        enter() {
+          seenOperationParams = new Set();
+        },
+        Parameter(
+          parameter: Oas2Parameter | Oas3Parameter,
+          { report, key, parentLocations }: UserContext,
+        ) {
+          const paramId = `${parameter.in}___${parameter.name}`;
+          if (seenOperationParams.has(paramId)) {
+            report({
+              message: `Operations must have unique \`name\` + \`in\` parameters. Repeats of \`in:${parameter.in}\` + \`name:${parameter.name}\`.`,
+              location: parentLocations.Operation.child(['parameters', key]),
+            });
+          }
+          seenOperationParams.add(paramId);
+        },
+      },
+    },
+  };
+};

package/src/rules/common/operation-security-defined.ts

@@ -0,0 +1,45 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { Location } from '../../ref-utils';
+import { UserContext } from '../../walk';
+import { Oas2SecurityScheme } from '../../typings/swagger';
+import { Oas3SecurityScheme } from '../../typings/openapi';
+
+export const OperationSecurityDefined: Oas3Rule | Oas2Rule = () => {
+  let referencedSchemes = new Map<
+    string,
+    {
+      defined?: boolean;
+      from: Location[];
+    }
+  >();
+
+  return {
+    DefinitionRoot: {
+      leave(_: object, { report }: UserContext) {
+        for (const [name, scheme] of referencedSchemes.entries()) {
+          if (scheme.defined) continue;
+          for (const reportedFromLocation of scheme.from) {
+            report({
+              message: `There is no \`${name}\` security scheme defined.`,
+              location: reportedFromLocation.key(),
+            });
+          }
+        }
+      },
+    },
+    SecurityScheme(_securityScheme: Oas2SecurityScheme | Oas3SecurityScheme, { key }: UserContext) {
+      referencedSchemes.set(key.toString(), { defined: true, from: [] });
+    },
+    SecurityRequirement(requirements, { location }) {
+      for (const requirement of Object.keys(requirements)) {
+        const authScheme = referencedSchemes.get(requirement);
+        const requirementLocation = location.child([requirement]);
+        if (!authScheme) {
+          referencedSchemes.set(requirement, { from: [requirementLocation] });
+        } else {
+          authScheme.from.push(requirementLocation);
+        }
+      }
+    },
+  };
+};

package/src/rules/common/operation-singular-tag.ts

@@ -0,0 +1,17 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { Oas2Operation } from '../../typings/swagger';
+import { Oas3Operation } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+
+export const OperationSingularTag: Oas3Rule | Oas2Rule = () => {
+  return {
+    Operation(operation: Oas2Operation | Oas3Operation, { report, location }: UserContext) {
+      if (operation.tags && operation.tags.length > 1) {
+        report({
+          message: 'Operation `tags` object should have only one tag.',
+          location: location.child(['tags']).key(),
+        });
+      }
+    },
+  };
+};

package/src/rules/common/operation-summary.ts

@@ -0,0 +1,13 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { validateDefinedAndNonEmpty } from '../utils';
+import { UserContext } from '../../walk';
+import { Oas2Operation } from '../../typings/swagger';
+import { Oas3Operation } from '../../typings/openapi';
+
+export const OperationSummary: Oas3Rule | Oas2Rule = () => {
+  return {
+    Operation(operation: Oas2Operation | Oas3Operation, ctx: UserContext) {
+      validateDefinedAndNonEmpty('summary', operation, ctx);
+    },
+  };
+};

package/src/rules/common/operation-tag-defined.ts

@@ -0,0 +1,26 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { Oas2Definition, Oas2Operation } from '../../typings/swagger';
+import { Oas3Definition, Oas3Operation } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+
+export const OperationTagDefined: Oas3Rule | Oas2Rule = () => {
+  let definedTags: Set<string>;
+
+  return {
+    DefinitionRoot(root: Oas2Definition | Oas3Definition) {
+      definedTags = new Set((root.tags ?? []).map((t) => t.name));
+    },
+    Operation(operation: Oas2Operation | Oas3Operation, { report, location }: UserContext) {
+      if (operation.tags) {
+        for (let i = 0; i < operation.tags.length; i++) {
+          if (!definedTags.has(operation.tags[i])) {
+            report({
+              message: `Operation tags should be defined in global tags.`,
+              location: location.child(['tags', i]),
+            });
+          }
+        }
+      }
+    },
+  };
+};

package/src/rules/common/parameter-description.ts

@@ -0,0 +1,22 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { Oas2Parameter } from '../../typings/swagger';
+import { Oas3Parameter } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+
+export const ParameterDescription: Oas3Rule | Oas2Rule = () => {
+  return {
+    Parameter(parameter: Oas2Parameter | Oas3Parameter, { report, location }: UserContext) {
+      if (parameter.description === undefined) {
+        report({
+          message: 'Parameter object description must be present.',
+          location: { reportOnKey: true },
+        });
+      } else if (!parameter.description) {
+        report({
+          message: 'Parameter object description must be non-empty string.',
+          location: location.child(['description']),
+        });
+      }
+    },
+  };
+};

package/src/rules/common/path-declaration-must-exist.ts

@@ -0,0 +1,15 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+
+export const PathDeclarationMustExist: Oas3Rule | Oas2Rule = () => {
+  return {
+    PathItem(_path: object, { report, key }: UserContext) {
+      if ((key as string).indexOf('{}') !== -1) {
+        report({
+          message: 'Path parameter declarations must be non-empty. `{}` is invalid.',
+          location: { reportOnKey: true },
+        });
+      }
+    },
+  };
+};

package/src/rules/common/path-excludes-patterns.ts

@@ -0,0 +1,23 @@
+import { Oas2Rule, Oas3Rule } from '../../visitors';
+import { Oas2PathItem } from '../../typings/swagger';
+import { Oas3PathItem } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+
+export const PathExcludesPatterns: Oas3Rule | Oas2Rule = ({ patterns }) => {
+  return {
+    PathItem(_path: Oas2PathItem | Oas3PathItem, { report, key, location }: UserContext) {
+      if (!patterns)
+        throw new Error(`Parameter "patterns" is not provided for "path-excludes-patterns" rule`);
+      const pathKey = key.toString();
+      if (pathKey.startsWith('/')) {
+        const matches = patterns.filter((pattern: string) => pathKey.match(pattern));
+        for (const match of matches) {
+          report({
+            message: `path \`${pathKey}\` should not match regex pattern: \`${match}\``,
+            location: location.key(),
+          });
+        }
+      }
+    },
+  };
+};

package/src/rules/common/path-http-verbs-order.ts

@@ -0,0 +1,30 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { Oas2PathItem } from '../../typings/swagger';
+import { Oas3PathItem } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+
+const defaultOrder = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
+
+export const PathHttpVerbsOrder: Oas3Rule | Oas2Rule = (opts: any) => {
+  const order: string[] = (opts && opts.order) || defaultOrder;
+  if (!Array.isArray(order)) {
+    throw new Error('path-http-verbs-order `order` option must be an array');
+  }
+
+  return {
+    PathItem(path: Oas2PathItem | Oas3PathItem, { report, location }: UserContext) {
+      const httpVerbs = Object.keys(path).filter((k) => order.includes(k));
+
+      for (let i = 0; i < httpVerbs.length - 1; i++) {
+        const aIdx = order.indexOf(httpVerbs[i]);
+        const bIdx = order.indexOf(httpVerbs[i + 1]);
+        if (bIdx < aIdx) {
+          report({
+            message: 'Operation http verbs must be ordered.',
+            location: { reportOnKey: true, ...location.child(httpVerbs[i + 1]) },
+          });
+        }
+      }
+    },
+  };
+};

package/src/rules/common/path-not-include-query.ts

@@ -0,0 +1,17 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+
+export const PathNotIncludeQuery: Oas3Rule | Oas2Rule = () => {
+  return {
+    PathMap: {
+      PathItem(_operation: object, { report, key }: UserContext) {
+        if (key.toString().includes('?')) {
+          report({
+            message: `Don't put query string items in the path, they belong in parameters with \`in: query\`.`,
+            location: { reportOnKey: true },
+          });
+        }
+      },
+    }
+  };
+};

package/src/rules/common/path-params-defined.ts

@@ -0,0 +1,58 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { Oas2Parameter } from '../../typings/swagger';
+import { Oas3Parameter } from '../../typings/openapi';
+import { UserContext } from '../../walk';
+
+const pathRegex = /\{([a-zA-Z0-9_.-]+)\}+/g;
+
+export const PathParamsDefined: Oas3Rule | Oas2Rule = () => {
+  let pathTemplateParams: Set<string>;
+  let definedPathParams: Set<string>;
+  let currentPath: string;
+
+  return {
+    PathItem: {
+      enter(_: object, { key }: UserContext) {
+        definedPathParams = new Set();
+        currentPath = key as string;
+        pathTemplateParams = new Set(
+          Array.from(key!.toString().matchAll(pathRegex)).map((m) => m[1]),
+        );
+      },
+      Parameter(parameter: Oas2Parameter | Oas3Parameter, { report, location }: UserContext) {
+        if (parameter.in === 'path' && parameter.name) {
+          definedPathParams.add(parameter.name);
+          if (!pathTemplateParams.has(parameter.name)) {
+            report({
+              message: `Path parameter \`${parameter.name}\` is not used in the path \`${currentPath}\`.`,
+              location: location.child(['name']),
+            });
+          }
+        }
+      },
+      Operation: {
+        leave(_op: object, { report, location }: UserContext) {
+          for (const templateParam of Array.from(pathTemplateParams.keys())) {
+            if (!definedPathParams.has(templateParam)) {
+              report({
+                message: `The operation does not define the path parameter \`{${templateParam}}\` expected by path \`${currentPath}\`.`,
+                location: location.child(['parameters']).key(), // report on operation
+              });
+            }
+          }
+        },
+        Parameter(parameter: Oas2Parameter | Oas3Parameter, { report, location }: UserContext) {
+          if (parameter.in === 'path' && parameter.name) {
+            definedPathParams.add(parameter.name);
+            if (!pathTemplateParams.has(parameter.name)) {
+              report({
+                message: `Path parameter \`${parameter.name}\` is not used in the path \`${currentPath}\`.`,
+                location: location.child(['name']),
+              });
+            }
+          }
+        },
+      },
+    },
+  };
+};

package/src/rules/common/path-segment-plural.ts

@@ -0,0 +1,31 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+import { isPathParameter, isSingular } from '../../utils';
+
+export const PathSegmentPlural: Oas3Rule | Oas2Rule = (opts) => {
+  const { ignoreLastPathSegment, exceptions } = opts;
+  return {
+    PathItem: {
+      leave(_path: any, { report, key, location }: UserContext) {
+        const pathKey = key.toString();
+        if (pathKey.startsWith('/')) {
+          const pathSegments = pathKey.split('/');
+          pathSegments.shift();
+          if (ignoreLastPathSegment && pathSegments.length > 1) {
+            pathSegments.pop();
+          }
+
+          for (const pathSegment of pathSegments) {
+            if (exceptions && exceptions.includes(pathSegment)) continue;
+            if (!isPathParameter(pathSegment) && isSingular(pathSegment)) {
+              report({
+                message: `path segment \`${pathSegment}\` should be plural.`,
+                location: location.key(),
+              });
+            }
+          }
+        }
+      },
+    },
+  };
+};

package/src/rules/common/paths-kebab-case.ts

@@ -0,0 +1,16 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+
+export const PathsKebabCase: Oas3Rule | Oas2Rule = () => {
+  return {
+    PathItem(_path: object, { report, key }: UserContext) {
+      const segments = (key as string).substr(1).split('/').filter(s => s !== ''); // filter out empty segments
+      if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
+        report({
+          message: `\`${key}\` does not use kebab-case.`,
+          location: { reportOnKey: true },
+        });
+      }
+    },
+  };
+};

package/src/rules/common/response-contains-header.ts

@@ -0,0 +1,30 @@
+import { Oas2Rule, Oas3Rule } from '../../visitors';
+import { UserContext } from '../../walk';
+import { Oas3Response } from '../../typings/openapi';
+import { Oas2Response } from '../../typings/swagger';
+import { getMatchingStatusCodeRange } from '../../utils';
+
+export const ResponseContainsHeader: Oas3Rule | Oas2Rule = (options) => {
+  const names: Record<string, string[]> = options.names || {};
+  return {
+    Operation: {
+      Response: {
+        enter: (response: Oas2Response | Oas3Response, { report, location, key }: UserContext) => {
+          const expectedHeaders =
+            names[key] ||
+            names[getMatchingStatusCodeRange(key)] ||
+            names[getMatchingStatusCodeRange(key).toLowerCase()] ||
+            [];
+          for (const expectedHeader of expectedHeaders) {
+            if (!response.headers?.[expectedHeader]) {
+              report({
+                message: `Response object must contain a "${expectedHeader}" header.`,
+                location: location.child('headers').key(),
+              });
+            }
+          }
+        },
+      },
+    },
+  };
+};