@redocly/openapi-core 1.23.0 → 1.24.0

package/src/rules/arazzo/__tests__/no-criteria-xpath.test.ts

@@ -0,0 +1,127 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('Arazzo no-criteria-xpath', () => {
+  const document = parseYamlToDocument(
+    outdent`
+      arazzo: '1.0.0'
+      info:
+        title: Cool API
+        version: 1.0.0
+        description: A cool API
+      sourceDescriptions:
+        - name: museum-api
+          type: openapi
+          url: openapi.yaml
+      workflows:
+        - workflowId: get-museum-hours
+          description: This workflow demonstrates how to get the museum opening hours and buy tickets.
+          parameters:
+            - in: header
+              name: Authorization
+              value: Basic Og==
+          steps:
+            - stepId: create-event
+              description: >-
+                Create a new special event.
+              operationPath: $sourceDescriptions.museum-api#/paths/~1special-events/post
+              requestBody:
+                payload:
+                  name: 'Mermaid Treasure Identification and Analysis'
+                  location: 'Under the seaaa 🦀 🎶 🌊.'
+                  eventDescription: 'Join us as we review and classify a rare collection of 20 thingamabobs, gadgets, gizmos, whoosits, and whatsits, kindly donated by Ariel.'
+                  dates:
+                    - '2023-09-05'
+                    - '2023-09-08'
+                  price: 0
+              successCriteria:
+                - condition: $statusCode == 201
+                - context: $response.body
+                  condition: $.name == 'Mermaid Treasure Identification and Analysis'
+                  type:
+                    type: jsonpath
+                    version: draft-goessner-dispatch-jsonpath-00
+                - context: $response.body
+                  condition: $.name == 'Orca Identification and Analysis'
+                  type: xpath
+                - context: $response.body
+                  condition: $.name == 'Mermaid Treasure Identification and Analysis'
+                  type:
+                    type: xpath
+                    version: xpath-30
+              outputs:
+                createdEventId: $response.body.eventId
+                name: $response.body.name
+        - workflowId: get-museum-hours-2
+          description: This workflow demonstrates how to get the museum opening hours and buy tickets.
+          parameters:
+            - in: header
+              name: Authorization
+              value: Basic Og==
+          steps:
+            - stepId: get-museum-hours
+              description: >-
+                Get museum hours by resolving request details with getMuseumHours operationId from openapi.yaml description.
+              operationId: museum-api.getMuseumHours
+              successCriteria:
+                - condition: $statusCode == 200
+    `,
+    'arazzo.yaml'
+  );
+
+  it('should report when the `xpath` criteria exists', async () => {
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        rules: {},
+        arazzoRules: { 'no-criteria-xpath': 'error' },
+      }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "location": [
+            {
+              "pointer": "#/workflows/0/steps/0/successCriteria/2/type",
+              "reportOnKey": false,
+              "source": "arazzo.yaml",
+            },
+          ],
+          "message": "The \`xpath\` type criteria is not supported by Spot.",
+          "ruleId": "no-criteria-xpath",
+          "severity": "error",
+          "suggest": [],
+        },
+        {
+          "location": [
+            {
+              "pointer": "#/workflows/0/steps/0/successCriteria/3/type",
+              "reportOnKey": false,
+              "source": "arazzo.yaml",
+            },
+          ],
+          "message": "The \`xpath\` type criteria is not supported by Spot.",
+          "ruleId": "no-criteria-xpath",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report when the `xpath` criteria exists', async () => {
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        rules: {},
+      }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+});

package/src/rules/arazzo/criteria-unique.ts

@@ -0,0 +1,63 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const CriteriaUnique: ArazzoRule = () => {
+  return {
+    FailureActionObject: {
+      enter(action, { report, location }: UserContext) {
+        const criterias = action.criteria;
+        const seen = new Set<string>();
+        for (const criteria of criterias) {
+          const key = JSON.stringify(criteria);
+          if (seen.has(key)) {
+            report({
+              message: 'The FailureAction criteria items must be unique.',
+              location: location.child(['criteria', criterias.indexOf(criteria)]),
+            });
+          } else {
+            seen.add(key);
+          }
+        }
+      },
+    },
+    SuccessActionObject: {
+      enter(action, { report, location }: UserContext) {
+        const criterias = action.criteria;
+        const seen = new Set<string>();
+        for (const criteria of criterias) {
+          const key = JSON.stringify(criteria);
+          if (seen.has(key)) {
+            report({
+              message: 'The SuccessAction criteria items must be unique.',
+              location: location.child(['criteria', criterias.indexOf(criteria)]),
+            });
+          } else {
+            seen.add(key);
+          }
+        }
+      },
+    },
+    Step: {
+      enter(step, { report, location }: UserContext) {
+        if (!step.successCriteria) {
+          return;
+        }
+
+        const successCriterias = step.successCriteria;
+        const seen = new Set<string>();
+
+        for (const criteria of successCriterias) {
+          const key = JSON.stringify(criteria);
+          if (seen.has(key)) {
+            report({
+              message: 'The Step SuccessCriteria items must be unique.',
+              location: location.child(['successCriteria', successCriterias.indexOf(criteria)]),
+            });
+          } else {
+            seen.add(key);
+          }
+        }
+      },
+    },
+  };
+};

package/src/rules/arazzo/index.ts

@@ -11,6 +11,9 @@ import { ParametersUnique } from './parameters-unique';
 import { StepOnSuccessUnique } from './step-onSuccess-unique';
 import { StepOnFailureUnique } from './step-onFailure-unique';
 import { RequestBodyReplacementsUnique } from './requestBody-replacements-unique';
+import { NoCriteriaXpath } from '../spot/no-criteria-xpath';
+import { NoActionsTypeEnd } from '../spot/no-actions-type-end';
+import { CriteriaUnique } from './criteria-unique';
 
 import type { ArazzoRule } from '../../visitors';
 import type { ArazzoRuleSet } from '../../oas-types';
@@ -29,6 +32,9 @@ export const rules: ArazzoRuleSet<'built-in'> = {
   'step-onSuccess-unique': StepOnSuccessUnique as ArazzoRule,
   'step-onFailure-unique': StepOnFailureUnique as ArazzoRule,
   'requestBody-replacements-unique': RequestBodyReplacementsUnique as ArazzoRule,
+  'no-criteria-xpath': NoCriteriaXpath as ArazzoRule,
+  'no-actions-type-end': NoActionsTypeEnd as ArazzoRule,
+  'criteria-unique': CriteriaUnique as ArazzoRule,
 };
 
 export const preprocessors = {};

package/src/rules/spot/no-actions-type-end.ts

@@ -0,0 +1,27 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const NoActionsTypeEnd: ArazzoRule = () => {
+  return {
+    FailureActionObject: {
+      enter(action, { report, location }: UserContext) {
+        if (action.type === 'end') {
+          report({
+            message: 'The `end` type action is not supported by Spot.',
+            location: location.child(['type']),
+          });
+        }
+      },
+    },
+    SuccessActionObject: {
+      enter(action, { report, location }: UserContext) {
+        if (action.type === 'end') {
+          report({
+            message: 'The `end` type action is not supported by Spot.',
+            location: location.child(['type']),
+          });
+        }
+      },
+    },
+  };
+};

package/src/rules/spot/no-criteria-xpath.ts

@@ -0,0 +1,20 @@
+import type { ArazzoRule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const NoCriteriaXpath: ArazzoRule = () => {
+  return {
+    CriterionObject: {
+      enter(criteria, { report, location }: UserContext) {
+        if (!criteria.type) {
+          return;
+        }
+        if (criteria?.type?.type === 'xpath' || criteria?.type === 'xpath') {
+          report({
+            message: 'The `xpath` type criteria is not supported by Spot.',
+            location: location.child(['type']),
+          });
+        }
+      },
+    },
+  };
+};

package/src/types/arazzo.ts

@@ -205,7 +205,7 @@ const CriterionObject: NodeType = {
         return undefined;
       } else if (typeof value === 'string') {
         return { enum: ['regex', 'jsonpath', 'simple', 'xpath'] };
-      } else if (value.type === 'jsonpath') {
+      } else if (value?.type === 'jsonpath') {
         return 'JSONPathCriterion';
       } else {
         return 'XPathCriterion';

package/src/types/redocly-yaml.ts

@@ -122,6 +122,9 @@ const builtInArazzoRules = [
   'step-onSuccess-unique',
   'step-onFailure-unique',
   'requestBody-replacements-unique',
+  'no-criteria-xpath',
+  'no-actions-type-end',
+  'criteria-unique',
 ] as const;
 
 export type BuiltInArazzoRuleId = typeof builtInArazzoRules[number];