@sungen/driver-ui 3.1.2-beta.100

package/src/patterns/assertion-patterns.ts

@@ -0,0 +1,691 @@
+import { ParsedStep } from '@sun-asterisk/sungen';
+import { StepPattern, StepTemplateData } from '@sun-asterisk/sungen';
+
+/**
+ * Assertion patterns: visibility, text content, state, attributes
+ * Uses template engine for framework-agnostic code generation
+ */
+export const assertionPatterns: StepPattern[] = [
+  // Browser alert text assertion: "see [Are you sure?] alert"
+  {
+    name: 'alert-text-assertion',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('see') || step.text.includes('sees')) &&
+      step.elementType === 'alert' &&
+      !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      let dataValue = step.selectorRef || '';
+      if (step.dataRef) {
+        try {
+          dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
+        } catch {
+          dataValue = `\${${step.dataRef}}`;
+        }
+      }
+      return {
+        templateName: 'alert-text-assertion',
+        data: { dataValue, stepCounter: context.stepCounter },
+        comment: `Assert browser alert contains "${step.selectorRef}"`,
+      };
+    },
+    priority: 21,
+  },
+  // Column cell assertion: "see [Department] column 1 with {{value}}" -> check table cell text
+  {
+    name: 'column-cell-assertion',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should see') || step.text.match(/\b(see|sees)\s+\[/)) &&
+      !!step.selectorRef &&
+      !!step.dataRef &&
+      (step.elementType === 'column' || step.elementType === 'columnheader'),
+    resolver: (step, context): StepTemplateData => {
+      let dataValue: string;
+      try {
+        dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      } catch (error) {
+        dataValue = `\${${step.dataRef}}`;
+      }
+
+      // getByRole('row') includes header row as nth(0), so Gherkin nth=1 maps to locator nth(1)
+      const rowNth = step.nth || 1;
+      // Create a safe variable name from column name
+      const columnIndexVar = `colIndex${step.selectorRef!.replace(/[^a-zA-Z0-9]/g, '')}`;
+
+      return {
+        templateName: 'column-cell-assertion',
+        data: {
+          columnName: step.selectorRef,
+          rowNth,
+          columnIndexVar,
+          dataValue,
+        },
+        comment: `Assert ${step.selectorRef} column row ${step.nth || 1} has text ${step.dataRef}`,
+      };
+    },
+    priority: 15,  // Higher than all other assertion patterns
+  },
+  // Page assertion pattern: "see [home] page" -> check URL matches selector value
+  {
+    name: 'page-assertion',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should see') ||
+       step.text.includes('see') ||
+       step.text.includes('sees')) &&
+      step.elementType === 'page',
+    resolver: (step, context): StepTemplateData => {
+      let path = step.featurePath || '/';
+
+      // If selector is present, extract path from selector's value attribute
+      if (step.selectorRef) {
+        try {
+          const resolved = context.selectorResolver.resolveSelector(
+            step.selectorRef,
+            context.featureName,
+            step.elementType,
+            step.nth
+          );
+          // Use selector's value as the path for URL assertion
+          path = resolved.value || path;
+        } catch (error) {
+          // Fallback to feature path if selector not found
+          path = step.featurePath || '/';
+        }
+      }
+
+      // Convert path to regex-safe string
+      const pathRegex = path.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+      return {
+        templateName: 'page-assertion',
+        data: { pathRegex },
+        comment: step.selectorRef ? `Assert on ${step.selectorRef} page` : `Assert on page`,
+      };
+    },
+    priority: 13,  // Higher priority than general visibility
+  },
+  // Pattern: Then User see [panel] dialog with {{kudo.title}} hidden -> toBeHidden()
+  {
+    name: 'see-with-variable-hidden',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should see') || step.text.match(/\b(see|sees)\s+\[/)) &&
+      !!step.selectorRef &&
+      !!step.dataRef &&
+      step.text.includes('with') &&
+      /\bis hidden\b/.test(step.text),
+    generator: (step, context) => {
+      let resolved: any = {};
+      try {
+        resolved = context.selectorResolver.resolveSelector(
+          step.selectorRef!,
+          context.featureName,
+          step.elementType,
+          step.nth
+        );
+      } catch (error) {}
+
+      let dataValue: string;
+      try {
+        dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      } catch (error) {
+        dataValue = `\${${step.dataRef}}`;
+      }
+
+      const escapedVariable = dataValue.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+
+      if (resolved.strategy === 'locator') {
+        const code = context.templateEngine.renderStep('hidden-with-filter-assertion', {
+          ...resolved, dataValue, nth: resolved.nth,
+        });
+        return { code, comment: `Assert ${step.selectorRef} hidden with ${step.dataRef}` };
+      }
+
+      if (resolved.strategy === 'role' && resolved.role) {
+        // Dialog role: check heading inside dialog instead of filter on full text content
+        if (resolved.role === 'dialog') {
+          const code = context.templateEngine.renderStep('hidden-dialog-heading-assertion', {
+            dataValue,
+          });
+          return { code, comment: `Assert ${step.selectorRef} dialog hidden with heading ${step.dataRef}` };
+        }
+
+        const code = context.templateEngine.renderStep('hidden-with-role-variable-assertion', {
+          role: resolved.role,
+          name: resolved.name && resolved.name.trim() ? resolved.name : undefined,
+          dataValue,
+          nth: resolved.nth,
+        });
+        return { code, comment: `Assert ${step.selectorRef} hidden with ${step.dataRef}` };
+      }
+
+      const selectorValue = resolved.value || '';
+      if (selectorValue && selectorValue.trim()) {
+        const code = context.templateEngine.renderStep('hidden-with-filter-assertion', {
+          ...resolved, dataValue, nth: resolved.nth,
+        });
+        return { code, comment: `Assert ${step.selectorRef} hidden with ${step.dataRef}` };
+      }
+
+      const code = context.templateEngine.renderStep('hidden-with-variable-assertion', {
+        selectorRef: step.selectorRef,
+        selectorValue: resolved.value || '',
+        dataValue,
+        nth: resolved.nth,
+      });
+      return { code, comment: `Assert ${step.selectorRef} hidden with ${step.dataRef}` };
+    },
+    priority: 14,
+  },
+  // Pattern: Then User see [submit] button with {{label}} disabled -> toBeDisabled()
+  {
+    name: 'see-with-variable-disabled',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should see') || step.text.match(/\b(see|sees)\s+\[/)) &&
+      !!step.selectorRef &&
+      !!step.dataRef &&
+      step.text.includes('with') &&
+      /\bis disabled\b/.test(step.text),
+    generator: (step, context) => {
+      let resolved: any = {};
+      try {
+        resolved = context.selectorResolver.resolveSelector(
+          step.selectorRef!,
+          context.featureName,
+          step.elementType,
+          step.nth
+        );
+      } catch (error) {}
+
+      let dataValue: string;
+      try {
+        dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      } catch (error) {
+        dataValue = `\${${step.dataRef}}`;
+      }
+
+      const escapedVariable = dataValue.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+
+      if (resolved.strategy === 'locator') {
+        const code = context.templateEngine.renderStep('disabled-with-filter-assertion', {
+          ...resolved, dataValue, nth: resolved.nth,
+        });
+        return { code, comment: `Assert ${step.selectorRef} disabled with ${step.dataRef}` };
+      }
+
+      if (resolved.strategy === 'role' && resolved.role) {
+        const code = context.templateEngine.renderStep('disabled-with-role-variable-assertion', {
+          role: resolved.role,
+          name: resolved.name && resolved.name.trim() ? resolved.name : undefined,
+          dataValue,
+          nth: resolved.nth,
+        });
+        return { code, comment: `Assert ${step.selectorRef} disabled with ${step.dataRef}` };
+      }
+
+      const selectorValue = resolved.value || '';
+      if (selectorValue && selectorValue.trim()) {
+        const code = context.templateEngine.renderStep('disabled-with-filter-assertion', {
+          ...resolved, dataValue, nth: resolved.nth,
+        });
+        return { code, comment: `Assert ${step.selectorRef} disabled with ${step.dataRef}` };
+      }
+
+      const code = context.templateEngine.renderStep('disabled-with-variable-assertion', {
+        selectorRef: step.selectorRef,
+        selectorValue: resolved.value || '',
+        dataValue,
+        nth: resolved.nth,
+      });
+      return { code, comment: `Assert ${step.selectorRef} disabled with ${step.dataRef}` };
+    },
+    priority: 14,
+  },
+    // NEW: Assertion with variable (handles both empty selector and static + variable)
+  // Pattern: Then User see [error] message with {{fail_message}}
+  // If selector YAML has empty value, uses variable-only matching
+  // If selector has value, combines both (static text + variable)
+  // Input types → toHaveValue, everything else → toHaveText
+  {
+    name: 'see-with-variable',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should see') ||
+       step.text.match(/\b(see|sees)\s+\[/)) &&
+      !!step.selectorRef &&
+      !!step.dataRef &&
+      step.text.includes('with'),
+    generator: (step, context) => {
+      // Input element types use toHaveValue instead of toHaveText
+      const INPUT_TYPES = new Set([
+        'field', 'textarea', 'search', 'dropdown', 'slider', 'date-picker',
+        'input', 'textbox', 'editor', 'select', 'combobox',
+      ]);
+
+      // Resolve data variable value
+      let dataValue: string;
+      try {
+        dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      } catch (error) {
+        dataValue = `\${${step.dataRef}}`;
+      }
+
+      // Resolve selector from YAML with feature context
+      let resolved: any = {};
+      try {
+        resolved = context.selectorResolver.resolveSelector(
+          step.selectorRef!,
+          context.featureName,
+          step.elementType,
+          step.nth
+        );
+      } catch (error) {
+        // Selector not in YAML or context issue - will use variable-only
+      }
+
+      // --- Attribute assertion: toHaveAttribute ---
+      // When selector YAML has `attribute` field (e.g., attribute: 'src', 'href')
+      if (resolved.attribute) {
+        const code = context.templateEngine.renderStep('attribute-assertion', {
+          ...resolved,
+          dataValue,
+        });
+        return {
+          code,
+          comment: `Assert ${step.selectorRef} ${resolved.attribute} matches ${step.dataRef}`,
+        };
+      }
+
+      // --- Input types: toHaveValue ---
+      if (step.elementType && INPUT_TYPES.has(step.elementType)) {
+        const code = context.templateEngine.renderStep('have-value-assertion', {
+          ...resolved,
+          dataValue,
+        });
+        return {
+          code,
+          comment: `Assert ${step.selectorRef} has value ${step.dataRef}`,
+        };
+      }
+
+      // --- Label-value pattern: "User see [X] label with {{Y}}" ---
+      if (step.elementType === 'label' && step.dataRef) {
+        let label: string | undefined = step.selectorRef;
+        try {
+          const labelResolved = context.selectorResolver.resolveSelector(
+            step.selectorRef!,
+            context.featureName,
+            step.elementType,
+            step.nth
+          );
+          if (labelResolved.value !== undefined && labelResolved.value.trim() === '') {
+            label = undefined;
+          }
+        } catch {
+          // No selector entry — use label from selectorRef
+        }
+
+        const code = context.templateEngine.renderStep('label-value-assertion', {
+          label,
+          dataValue,
+        });
+        return {
+          code,
+          comment: `Assert ${step.selectorRef} label with value ${step.dataRef}`,
+        };
+      }
+
+      // --- Dialog role: check heading inside dialog ---
+      if (resolved.strategy === 'role' && resolved.role === 'dialog') {
+        const code = context.templateEngine.renderStep('visible-dialog-heading-assertion', {
+          dataValue,
+        });
+        return {
+          code,
+          comment: `Assert ${step.selectorRef} dialog with heading ${step.dataRef}`,
+        };
+      }
+
+      // --- Image role: images have no text, use name ---
+      if (resolved.strategy === 'role' && resolved.role === 'img') {
+        const hasName = resolved.name && resolved.name.trim();
+        const code = context.templateEngine.renderStep('visible-with-role-variable-assertion', {
+          role: resolved.role,
+          name: hasName ? resolved.name : dataValue,
+          exact: resolved.exact || false,
+          nth: resolved.nth,
+        });
+        return {
+          code,
+          comment: `Assert ${step.selectorRef} image with name ${step.dataRef}`,
+        };
+      }
+
+      // --- Everything else: toHaveText (exact full match) ---
+      // Locator strategy
+      if (resolved.strategy === 'locator') {
+        const code = context.templateEngine.renderStep('have-text-assertion', {
+          ...resolved,
+          expectedText: dataValue,
+        });
+        return {
+          code,
+          comment: `Assert ${step.selectorRef} has text ${step.dataRef}`,
+        };
+      }
+
+      // Role-based selector
+      if (resolved.strategy === 'role' && resolved.role) {
+        const hasName = resolved.name && resolved.name.trim();
+        const code = context.templateEngine.renderStep('have-text-assertion', {
+          ...resolved,
+          expectedText: dataValue,
+        });
+        return {
+          code,
+          comment: `Assert ${step.selectorRef} has text ${step.dataRef}`,
+        };
+      }
+
+      // Text/placeholder/testid/other strategies
+      const code = context.templateEngine.renderStep('have-text-assertion', {
+        ...resolved,
+        expectedText: dataValue,
+      });
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} has text ${step.dataRef}`,
+      };
+    },
+    priority: 13,
+  },
+  {
+    name: 'should-be-visible',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should be visible') ||
+       step.text.includes('should be displayed') ||
+       step.text.includes('should see') ||
+       step.text.match(/\b(see|sees)\s+\[/)) &&
+      !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'visible-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
+        comment: `Assert ${step.selectorRef} is visible`,
+      };
+    },
+    priority: 10,
+  },
+  {
+    name: 'is-hidden',
+    // "see [target] is hidden" — no variable version; with-variable handled by see-with-variable-hidden
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis hidden\b/.test(step.text) &&
+      !step.dataRef && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'is-hidden-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
+        comment: `Assert ${step.selectorRef} is not visible`,
+      };
+    },
+    priority: 11,
+  },
+  {
+    name: 'should-be-enabled',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis enabled\b/.test(step.text) && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'enabled-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
+        comment: `Assert ${step.selectorRef} is enabled`,
+      };
+    },
+    priority: 11,
+  },
+  {
+    name: 'should-be-disabled',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis disabled\b/.test(step.text) && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'disabled-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
+        comment: `Assert ${step.selectorRef} is disabled`,
+      };
+    },
+    priority: 11,
+  },
+  {
+    name: 'should-contain-text',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should contain') || step.text.includes('contains')) && !!step.selectorRef && !!(step.value || step.dataRef),
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      const expectedText = step.value || context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      return {
+        templateName: 'contain-text-assertion',
+        data: { ...resolved, expectedText },
+        comment: `Assert ${step.selectorRef} contains "${step.value || step.dataRef}"`,
+      };
+    },
+    priority: 12,
+  },
+  {
+    name: 'should-have-text',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should have text') || step.text.includes('has text')) && !!step.selectorRef && !!(step.value || step.dataRef),
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      const expectedText = step.value || context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      return {
+        templateName: 'have-text-assertion',
+        data: { ...resolved, expectedText },
+        comment: `Assert ${step.selectorRef} has text "${step.value || step.dataRef}"`,
+      };
+    },
+    priority: 12,
+  },
+  {
+    name: 'is-empty',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis empty\b/.test(step.text) && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'empty-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
+        comment: `Assert ${step.selectorRef} is empty`,
+      };
+    },
+    priority: 11,
+  },
+  {
+    name: 'is-checked',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis checked\b/.test(step.text) && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'checked-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
+        comment: `Assert ${step.selectorRef} is checked`,
+      };
+    },
+    priority: 11,
+  },
+  {
+    name: 'is-unchecked',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis unchecked\b/.test(step.text) && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'not-checked-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
+        comment: `Assert ${step.selectorRef} is unchecked`,
+      };
+    },
+    priority: 11,
+  },
+  {
+    name: 'is-focused',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis focused\b/.test(step.text) && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'focused-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
+        comment: `Assert ${step.selectorRef} is focused`,
+      };
+    },
+    priority: 11,
+  },
+  {
+    name: 'see-data-text',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should see') ||
+       step.text.match(/\b(see|sees)\b/)) &&
+      !step.selectorRef &&
+      !!step.dataRef,
+    resolver: (step, context): StepTemplateData => {
+      // Resolve data reference to actual value
+      let dataValue: string;
+      try {
+        dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      } catch (error) {
+        dataValue = `\${${step.dataRef}}`;
+      }
+
+      return {
+        templateName: 'visible-assertion',
+        data: {
+          strategy: 'text',
+          value: dataValue,
+        },
+        comment: `Assert ${step.dataRef} is visible`,
+      };
+    },
+    priority: 5, // Lower than selector-based assertions
+  },
+  {
+    name: 'list-item-count',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should have') && step.text.includes('count') &&
+      !!step.selectorRef && step.text.includes('items') &&
+      (step.elementType === 'list' || step.elementType === 'list-item' || step.elementType === 'listitem'),
+    resolver: (step, context): StepTemplateData => {
+      let expectedCount: number | string = 1;
+
+      const match = step.text.match(/count\s+(\d+)/);
+      if (match) {
+        expectedCount = parseInt(match[1]);
+      } else if (step.dataRef) {
+        try {
+          const resolvedData = context.dataResolver.resolveData(step.dataRef, context.featureName);
+          const parsed = parseInt(resolvedData);
+          expectedCount = isNaN(parsed) ? 1 : parsed;
+        } catch {
+          expectedCount = `\${${step.dataRef}}`;
+        }
+      }
+
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'list-item-count-assertion',
+        data: { ...resolved, expectedCount },
+        comment: `Assert ${step.selectorRef} list has ${expectedCount} items`,
+      };
+    },
+    priority: 9, // Higher than should-have-count (8)
+  },
+  {
+    name: 'should-have-count',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should have') && step.text.includes('count') && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      let expectedCount: number | string = 1;
+
+      // Try literal digit first: "count 10"
+      const match = step.text.match(/count\s+(\d+)/);
+      if (match) {
+        expectedCount = parseInt(match[1]);
+      } else if (step.dataRef) {
+        // Resolve data reference: "count {{number_items}}"
+        try {
+          const resolvedData = context.dataResolver.resolveData(step.dataRef, context.featureName);
+          const parsed = parseInt(resolvedData);
+          expectedCount = isNaN(parsed) ? 1 : parsed;
+        } catch {
+          expectedCount = `\${${step.dataRef}}`;
+        }
+      }
+
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'count-assertion',
+        data: { ...resolved, expectedCount },
+        comment: `Assert ${step.selectorRef} has count ${expectedCount}`,
+      };
+    },
+    priority: 8,
+  },
+  {
+    name: 'is-loading',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis loading\b/.test(step.text) && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'loading-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
+        comment: `Assert ${step.selectorRef} is loading`,
+      };
+    },
+    priority: 11,
+  },
+  {
+    name: 'is-selected',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis selected\b/.test(step.text) && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'selected-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
+        comment: `Assert ${step.selectorRef} is selected`,
+      };
+    },
+    priority: 11,
+  },
+  {
+    name: 'is-sorted-ascending',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\s+\[/.test(step.text) && /\bsorted ascending\b/.test(step.text) && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'sorted-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef, sortDirection: 'ascending' },
+        comment: `Assert ${step.selectorRef} is sorted ascending`,
+      };
+    },
+    priority: 12,
+  },
+  {
+    name: 'is-sorted-descending',
+    matcher: (step: ParsedStep) =>
+      /\b(see|sees)\s+\[/.test(step.text) && /\bsorted descending\b/.test(step.text) && !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      return {
+        templateName: 'sorted-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef, sortDirection: 'descending' },
+        comment: `Assert ${step.selectorRef} is sorted descending`,
+      };
+    },
+    priority: 12,
+  },
+];