@sun-asterisk/sungen 3.1.2 → 3.2.0-beta.142

package/src/generators/test-generator/patterns/assertion-patterns.ts

@@ -1,691 +0,0 @@
-import { ParsedStep } from '../../gherkin-parser';
-import { StepPattern, StepTemplateData } from './types';
-
-/**
- * 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,
-  },
-];