@sun-asterisk/sungen 1.0.14 → 1.0.16

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

@@ -23,7 +23,8 @@ export const assertionPatterns: StepPattern[] = [
           const resolved = context.selectorResolver.resolveSelector(
             step.selectorRef,
             context.featureName,
-            step.elementType
+            step.elementType,
+            step.nth
           );
           // Use selector's value as the path for URL assertion
           path = resolved.value || path;
@@ -42,6 +43,134 @@ export const assertionPatterns: StepPattern[] = [
       };
     },
     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 || 0,
+        });
+        return { code, comment: `Assert ${step.selectorRef} hidden with ${step.dataRef}` };
+      }
+
+      if (resolved.strategy === 'role' && resolved.role) {
+        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 || 0,
+        });
+        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 || 0,
+        });
+        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 || 0,
+      });
+      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 || 0,
+        });
+        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 || 0,
+        });
+        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 || 0,
+        });
+        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 || 0,
+      });
+      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}}
@@ -61,8 +190,9 @@ export const assertionPatterns: StepPattern[] = [
       try {
         resolved = context.selectorResolver.resolveSelector(
           step.selectorRef!,
-          context.featureName,  // Pass feature context from step context
-          step.elementType
+          context.featureName,
+          step.elementType,
+          step.nth
         );
       } catch (error) {
         // Selector not in YAML or context issue - will use variable-only
@@ -124,7 +254,10 @@ export const assertionPatterns: StepPattern[] = [
       } else {
         // Empty selector - use variable only
         const code = context.templateEngine.renderStep('visible-with-variable-assertion', {
-          variable: escapedVariable
+          selectorRef: step.selectorRef,
+          selectorValue: resolved.value || '',
+          dataValue,
+          nth: resolved.nth || 0,
         });
         return {
           code,
@@ -132,46 +265,7 @@ export const assertionPatterns: StepPattern[] = [
         };
       }
     },
-    priority: 13,  // HIGHEST priority - match before should-be-visible-with-value
-  },
-  {
-    name: 'should-be-visible-with-value',
-    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) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
-
-      // Resolve the data value
-      let dataValue: string;
-      try {
-        dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
-      } catch (error) {
-        dataValue = `\${${step.dataRef}}`;
-      }
-
-      // Container types (row, list-item/listitem) use .filter({ hasText }) instead of regex
-      const filterTypes = ['row', 'listitem', 'list-item'];
-      const normalizedType = step.elementType || '';
-      const useFilter = filterTypes.includes(normalizedType) || filterTypes.includes(resolved.role || '');
-
-      // When using .filter({ hasText }), name is redundant — data value identifies the element
-      const templateData = useFilter
-        ? { ...(() => { const { name: _n, ...rest } = resolved; return rest; })(), dataValue, dataRef: step.dataRef }
-        : { ...resolved, dataValue, dataRef: step.dataRef };
-
-      const templateName = useFilter ? 'visible-with-filter-assertion' : 'visible-with-value-assertion';
-      const code = context.templateEngine.renderStep(templateName, templateData);
-
-      return {
-        code,
-        comment: `Assert ${step.selectorRef} with value ${step.dataRef}`,
-      };
-    },
-    priority: 11, // Lower than see-with-variable (13) so variable-only pattern matches first
+    priority: 13,
   },
   {
     name: 'should-be-visible',
@@ -182,7 +276,7 @@ export const assertionPatterns: StepPattern[] = [
        step.text.match(/\b(see|sees)\s+\[/)) &&
       !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const code = context.templateEngine.renderStep('visible-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
         code,
@@ -192,15 +286,14 @@ export const assertionPatterns: StepPattern[] = [
     priority: 10,
   },
   {
-    name: 'should-not-be-visible',
+    name: 'is-hidden',
+    // "see [target] is hidden" — no variable version; with-variable handled by see-with-variable-hidden
     matcher: (step: ParsedStep) =>
-      (step.text.includes('should not be visible') || 
-       step.text.includes('should be hidden') ||
-       step.text.includes('should not see')) && 
-      !!step.selectorRef,
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis hidden\b/.test(step.text) &&
+      !step.dataRef && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
-      const code = context.templateEngine.renderStep('not-visible-assertion', { ...resolved, selectorRef: step.selectorRef });
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      const code = context.templateEngine.renderStep('is-hidden-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
         code,
         comment: `Assert ${step.selectorRef} is not visible`,
@@ -211,37 +304,37 @@ export const assertionPatterns: StepPattern[] = [
   {
     name: 'should-be-enabled',
     matcher: (step: ParsedStep) =>
-      step.text.includes('should be enabled') && !!step.selectorRef,
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis enabled\b/.test(step.text) && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const code = context.templateEngine.renderStep('enabled-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
         code,
         comment: `Assert ${step.selectorRef} is enabled`,
       };
     },
-    priority: 9,
+    priority: 11,
   },
   {
     name: 'should-be-disabled',
     matcher: (step: ParsedStep) =>
-      step.text.includes('should be disabled') && !!step.selectorRef,
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis disabled\b/.test(step.text) && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const code = context.templateEngine.renderStep('disabled-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
         code,
         comment: `Assert ${step.selectorRef} is disabled`,
       };
     },
-    priority: 9,
+    priority: 11,
   },
   {
     name: 'should-contain-text',
     matcher: (step: ParsedStep) =>
       step.text.includes('should contain') && !!step.selectorRef && !!(step.value || step.dataRef),
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const expectedText = step.value || `\${${step.dataRef}}`;
       const code = context.templateEngine.renderStep('contain-text-assertion', {
         ...resolved,
@@ -259,7 +352,7 @@ export const assertionPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       step.text.includes('should have text') && !!step.selectorRef && !!(step.value || step.dataRef),
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const expectedText = step.value || `\${${step.dataRef}}`;
       const code = context.templateEngine.renderStep('have-text-assertion', {
         ...resolved,
@@ -273,60 +366,60 @@ export const assertionPatterns: StepPattern[] = [
     priority: 10,
   },
   {
-    name: 'should-be-empty',
+    name: 'is-empty',
     matcher: (step: ParsedStep) =>
-      step.text.includes('should be empty') && !!step.selectorRef,
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis empty\b/.test(step.text) && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const code = context.templateEngine.renderStep('empty-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
         code,
         comment: `Assert ${step.selectorRef} is empty`,
       };
     },
-    priority: 8,
+    priority: 11,
   },
   {
-    name: 'should-be-checked',
+    name: 'is-checked',
     matcher: (step: ParsedStep) =>
-      step.text.includes('should be checked') && !!step.selectorRef,
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis checked\b/.test(step.text) && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const code = context.templateEngine.renderStep('checked-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
         code,
         comment: `Assert ${step.selectorRef} is checked`,
       };
     },
-    priority: 8,
+    priority: 11,
   },
   {
-    name: 'should-be-unchecked',
+    name: 'is-unchecked',
     matcher: (step: ParsedStep) =>
-      step.text.includes('should be unchecked') && !!step.selectorRef,
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis unchecked\b/.test(step.text) && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const code = context.templateEngine.renderStep('not-checked-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
         code,
         comment: `Assert ${step.selectorRef} is unchecked`,
       };
     },
-    priority: 8,
+    priority: 11,
   },
   {
-    name: 'should-be-focused',
+    name: 'is-focused',
     matcher: (step: ParsedStep) =>
-      step.text.includes('should be focused') && !!step.selectorRef,
+      /\b(see|sees)\s+\[/.test(step.text) && /\bis focused\b/.test(step.text) && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const code = context.templateEngine.renderStep('focused-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
         code,
         comment: `Assert ${step.selectorRef} is focused`,
       };
     },
-    priority: 7,
+    priority: 11,
   },
   {
     name: 'see-data-text',
@@ -379,7 +472,7 @@ export const assertionPatterns: StepPattern[] = [
         }
       }
 
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const code = context.templateEngine.renderStep('list-item-count-assertion', {
         ...resolved,
         expectedCount,
@@ -413,7 +506,7 @@ export const assertionPatterns: StepPattern[] = [
         }
       }
 
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const code = context.templateEngine.renderStep('count-assertion', {
         ...resolved,
         expectedCount,

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

@@ -7,12 +7,46 @@ import { StepPattern } from './types';
  * Resolvers return metadata, templates handle framework syntax
  */
 export const formPatterns: StepPattern[] = [
+  {
+    name: 'upload-file',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('fill') || step.text.includes('fills')) &&
+      step.elementType === 'uploader' &&
+      !!step.selectorRef &&
+      !!(step.dataRef || step.value),
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+
+      let fileName: string;
+      if (step.dataRef) {
+        try {
+          fileName = context.dataResolver.resolveData(step.dataRef, context.featureName);
+        } catch (error) {
+          fileName = `\${${step.dataRef}}`;
+        }
+      } else {
+        fileName = step.value!;
+      }
+
+      const code = context.templateEngine.renderStep('upload-action', {
+        ...resolved,
+        selectorRef: step.selectorRef,
+        fileName,
+      });
+
+      return {
+        code,
+        comment: `Upload file ${fileName} via ${step.selectorRef}`,
+      };
+    },
+    priority: 12,
+  },
   {
     name: 'fill-input',
     matcher: (step: ParsedStep) =>
       (step.text.includes('fills') || step.text.includes('fill') || step.text.includes('inputs') || step.text.includes('input')) && !!step.selectorRef && !!(step.dataRef || step.value),
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       
       // Resolve data reference to actual value
       let value: string;
@@ -46,7 +80,7 @@ export const formPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       step.text.includes('checks') && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       
       const code = context.templateEngine.renderStep('check-action', { ...resolved, selectorRef: step.selectorRef });
       
@@ -62,7 +96,7 @@ export const formPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       step.text.includes('unchecks') && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       
       const code = context.templateEngine.renderStep('uncheck-action', { ...resolved, selectorRef: step.selectorRef });
       
@@ -80,7 +114,7 @@ export const formPatterns: StepPattern[] = [
       !!step.selectorRef &&
       !!(step.dataRef || step.value),
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
 
       // Resolve data reference to actual value
       let value: string;
@@ -130,7 +164,7 @@ export const formPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       step.text.includes('clears') && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       
       const code = context.templateEngine.renderStep('clear-action', { ...resolved, selectorRef: step.selectorRef });