@mablhq/mabl-cli 2.72.4 → 2.72.12

package/mablscript/steps/AssertStep.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssertStep = exports.assertStepYamlMablscriptNames = exports.MAX_AI_ASSERTIONS_PER_CLOUD_RUN = exports.OnFailure = void 0;
+exports.buildAssertStepDescriptor = buildAssertStepDescriptor;
 const ConditionAction_1 = require("../actions/ConditionAction");
 const FindAction_1 = require("../actions/FindAction");
-const MablStep_1 = require("../MablStep");
 const MablAction_1 = require("../MablAction");
 const ExtractAction_1 = require("../actions/ExtractAction");
 const domUtil_1 = require("../../domUtil");
@@ -16,6 +16,9 @@ const CountAction_1 = require("../actions/CountAction");
 const MobileFindAction_1 = require("../mobile/steps/actions/MobileFindAction");
 const GetViewportDescriptor_1 = require("../types/GetViewportDescriptor");
 const GetViewportAction_1 = require("../actions/GetViewportAction");
+const MablStepV2_1 = require("../MablStepV2");
+const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
+const AssertStepOld_1 = require("./AssertStepOld");
 var OnFailure;
 (function (OnFailure) {
     OnFailure["ContinueWithWarning"] = "continue";
@@ -29,9 +32,11 @@ const assertStepYamlMablscriptNames = () => {
     return assertionNames;
 };
 exports.assertStepYamlMablscriptNames = assertStepYamlMablscriptNames;
-class AssertStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'assert');
+class AssertStep extends MablStepV2_1.MablStepV2 {
+    constructor(name, args, actions, descriptor) {
+        const stepDescriptor = descriptor ?? buildAssertStepDescriptor(name, args, actions);
+        super(name, stepDescriptor, AssertStep.actionCode);
+        this.actions = actions;
         const firstAction = actions[0];
         if (firstAction instanceof FindAction_1.FindAction ||
             firstAction instanceof MobileFindAction_1.MobileFindAction ||
@@ -72,14 +77,13 @@ class AssertStep extends MablStep_1.MablStep {
         this.assertionType = (0, ConditionDescriptor_1.getAssertionConditionFieldFromDescriptor)(this.conditionAction.conditionDescriptor);
         this.assertionValue = (0, ConditionDescriptor_1.getOptionalComparatorValue)(this.conditionAction.conditionDescriptor);
         this.isWaitUntilStep = this.determineIfWaitUntilStep();
-        this.assertArguments =
-            args[0] && typeof args[0] === 'object'
-                ? args[0]
-                : undefined;
         this.onFailure =
-            this.assertArguments?.onFailure ||
-                OnFailure.FailImmediately;
-        this.observationScope = this.assertArguments?.observationScope;
+            'onFailure' in stepDescriptor && stepDescriptor.onFailure
+                ? stepDescriptor.onFailure
+                : OnFailure.FailImmediately;
+        if ('observationScope' in stepDescriptor) {
+            this.observationScope = stepDescriptor.observationScope;
+        }
     }
     canContinueOnFailure() {
         return this.onFailure !== OnFailure.FailImmediately;
@@ -112,77 +116,47 @@ class AssertStep extends MablStep_1.MablStep {
         return ConditionDescriptor_1.AssertionConditionFieldToStepName[this.assertionType];
     }
     toStepDescriptor() {
-        const find = this.primaryAction.toDescriptor();
+        const target = this.primaryAction.toDescriptor();
         const descriptorToActionMap = new Map()
-            .set(find, this.primaryAction)
+            .set(target, this.primaryAction)
             .set(this.conditionAction.conditionDescriptor, this.conditionAction);
-        if (this.extractAction) {
-            descriptorToActionMap.set(this.extractAction.extractDescriptor, this.extractAction);
+        const extractDescriptor = this.extractAction?.toDescriptor();
+        if (this.extractAction && extractDescriptor) {
+            descriptorToActionMap.set(extractDescriptor, this.extractAction);
         }
         if (this.countAction) {
             descriptorToActionMap.set(this.countAction.countDescriptor, this.countAction);
         }
         return {
-            find,
-            extractDescriptor: this.extractAction?.extractDescriptor,
-            conditionDescriptor: this.conditionAction.conditionDescriptor,
-            countDescriptor: this.countAction?.countDescriptor,
+            target,
+            extract: extractDescriptor,
+            condition: this.conditionAction.conditionDescriptor,
+            count: this.countAction?.countDescriptor,
             onFailure: this.onFailure,
             observationScope: this.observationScope,
             descriptorToActionMap,
             actionCode: this.actionCode,
         };
     }
-    getFormattedStep(_fullLocatorsOn) {
-        const result = {};
-        result[this.getStepName()] = { ...this.annotationsAsYml() };
-        const formatted = result[this.getStepName()];
-        if (this.extractAction) {
-            formatted.attribute = this.extractAction.extractionAttribute;
-            formatted.extractType =
-                ExtractAction_1.ExtractAction.mablscriptToYamlType[this.extractAction.extractionType];
-        }
-        if (this.countAction) {
-            formatted.attribute = 'count';
-        }
-        if (this.assertionValue !== undefined) {
-            formatted.assertionValue = this.assertionValue;
-        }
-        if (this.aiPrompt !== undefined) {
-            formatted.aiPrompt = this.aiPrompt;
-        }
-        const targetDescriptor = this.primaryAction.toDescriptor();
-        if ((0, GetVariableDescriptor_1.isGetVariableDescriptor)(targetDescriptor)) {
-            formatted.target = (0, GetVariableDescriptor_1.convertGetVariableDescriptorToYaml)(targetDescriptor);
-        }
-        else {
-            formatted.target = targetDescriptor;
-        }
-        if (this.conditionAction.hasOptionsAtInstantiation) {
-            formatted.conditionOptions = (0, ConditionDescriptor_1.getOptionalConditionOptions)(this.conditionAction.conditionDescriptor);
-        }
-        if (!!this.assertArguments?.observationScope ||
-            !!this.assertArguments?.onFailure) {
-            formatted.assertArguments = this.assertArguments;
-        }
-        result[this.getStepName()] =
-            MablStep_1.MablStep.cloneAndRemoveUndefinedEntriesFromObject(formatted);
-        if (this.stepId()) {
-            result[this.getStepName()].id = this.stepId();
-        }
-        return result;
-    }
     static fromYaml(stepName, stepArgs) {
         const actions = [];
         const assertionType = ConditionDescriptor_1.AssertionStepNameToField[stepName];
-        const assertionValue = stepArgs.assertionValue;
-        const conditionOptions = stepArgs.conditionOptions;
+        const assertionValue = stepArgs.assertionValue ??
+            stepArgs.conditionDescriptor?.comparatorValue ??
+            stepArgs.condition?.comparatorValue;
+        const conditionOptions = stepArgs.conditionOptions
+            ?.caseInsensitive
+            ? { caseInsensitive: stepArgs.conditionOptions.caseInsensitive }
+            : {
+                caseInsensitive: stepArgs.conditionDescriptor?.caseInsensitive ??
+                    stepArgs.condition?.caseInsensitive,
+            };
         let primaryAction;
         if (stepArgs.target?.kind === GetCurrentLocationDescriptor_1.GET_CURRENT_LOCATION_KIND) {
             primaryAction = new GetUrlAction_1.GetUrlAction(GetUrlAction_1.GetUrlAction.mablScriptStepNames[0], []);
         }
-        else if (stepArgs.target?.kind === GetVariableDescriptor_1.GET_VARIABLE_VALUE) {
-            primaryAction = new GetVariableValue_1.GetVariableValue(GetVariableValue_1.GetVariableValue.mablScriptStepNames[0], [stepArgs.target?.variable]);
+        else if ((0, GetVariableDescriptor_1.isGetVariableDescriptor)(stepArgs.target)) {
+            primaryAction = GetVariableValue_1.GetVariableValue.buildAction(stepArgs.target.variable);
         }
         else if ((0, GetViewportDescriptor_1.isGetViewportDescriptor)(stepArgs.target)) {
             primaryAction = new GetViewportAction_1.GetViewportAction();
@@ -199,7 +173,10 @@ class AssertStep extends MablStep_1.MablStep {
         else if ((0, domUtil_1.isFindElementDescriptor)(stepArgs.target)) {
             const { findOptions, findTarget, findType } = stepArgs.target;
             if (findType === domUtil_1.FindType.FIND_ONE) {
-                primaryAction = new FindAction_1.FindAction(findType, [findTarget, findOptions]);
+                const findArgument = findTarget.shadowParents
+                    ? findTarget
+                    : findTarget.selector;
+                primaryAction = new FindAction_1.FindAction(findType, [findArgument, findOptions]);
             }
             else {
                 primaryAction = new FindAction_1.FindAction(findType, [findTarget, findOptions]);
@@ -209,41 +186,107 @@ class AssertStep extends MablStep_1.MablStep {
             throw new Error(`Error parsing [${stepName}] with incompatible step arguments`);
         }
         actions.push(primaryAction);
+        let extractAction;
+        let countAction;
+        let conditionAction;
         if (assertionType === 'ai_prompt') {
-            actions.push(new ConditionAction_1.ConditionAction('evaluate_ai_prompt', [
-                stepArgs.aiPrompt?.userPrompt ?? stepArgs.userPrompt,
-                {
-                    metaPrompt: stepArgs.aiPrompt?.metaPrompt ?? stepArgs.metaPrompt,
-                    criteria: stepArgs.aiPrompt?.criteria,
-                },
-            ]));
+            const userPrompt = stepArgs.aiPrompt?.userPrompt ??
+                stepArgs.userPrompt ??
+                stepArgs.conditionDescriptor?.userPrompt ??
+                stepArgs.condition?.userPrompt;
+            const conditionArgs = [userPrompt];
+            const metaPrompt = stepArgs.aiPrompt?.metaPrompt ??
+                stepArgs.metaPrompt ??
+                stepArgs.conditionDescriptor?.metaPrompt ??
+                stepArgs.condition?.metaPrompt;
+            const criteria = stepArgs.aiPrompt?.criteria ??
+                stepArgs.conditionDescriptor?.criteria ??
+                stepArgs.condition?.criteria;
+            if (metaPrompt || criteria) {
+                conditionArgs.push({
+                    metaPrompt,
+                    criteria,
+                });
+            }
+            conditionAction = new ConditionAction_1.ConditionAction('evaluate_ai_prompt', conditionArgs);
+            actions.push(conditionAction);
         }
         else if (assertionType === 'present' || assertionType === 'not_present') {
-            actions.push(new ConditionAction_1.ConditionAction('evaluate_presence', [assertionType]));
+            conditionAction = new ConditionAction_1.ConditionAction('evaluate_presence', [
+                assertionType,
+            ]);
+            actions.push(conditionAction);
         }
         else if (stepName === 'WaitUntil') {
-            actions.push(new ConditionAction_1.ConditionAction('evaluate_presence', ['present']));
+            conditionAction = new ConditionAction_1.ConditionAction('evaluate_presence', ['present']);
+            actions.push(conditionAction);
         }
         else {
-            if (stepArgs.attribute === 'count') {
-                actions.push(new CountAction_1.CountAction('count', [stepArgs.attribute]));
+            const isCountAssertion = stepArgs.attribute === 'count' ||
+                stepArgs.countDescriptor?.count ||
+                stepArgs.count?.count;
+            const attributeName = stepArgs.attribute ??
+                stepArgs.extractDescriptor?.attributeName ??
+                stepArgs.extract?.attributeName;
+            if (isCountAssertion) {
+                countAction = new CountAction_1.CountAction('count', ['count']);
+                actions.push(countAction);
             }
-            else if (stepArgs.target?.kind !== GetVariableDescriptor_1.GET_VARIABLE_VALUE) {
-                actions.push(new ExtractAction_1.ExtractAction(ExtractAction_1.ExtractAction.mablScriptTypeFromYamlType(stepArgs.extractType), [stepArgs.attribute]));
+            else if (stepArgs.target?.kind !== GetVariableDescriptor_1.GET_VARIABLE_VALUE &&
+                attributeName) {
+                const extractType = stepArgs.extractType ??
+                    stepArgs.extractDescriptor?.extractType ??
+                    stepArgs.extract?.extractType;
+                const extractArgs = [attributeName];
+                if (extractType === 'extract_css_properties') {
+                    extractArgs.push({ extraction_type: 'css' });
+                }
+                extractAction = new ExtractAction_1.ExtractAction(ExtractAction_1.ExtractAction.mablScriptTypeFromYamlType(extractType), extractArgs);
+                actions.push(extractAction);
             }
-            actions.push(new ConditionAction_1.ConditionAction('evaluate_condition', [
+            conditionAction = new ConditionAction_1.ConditionAction('evaluate_condition', [
                 assertionType,
                 assertionValue,
                 conditionOptions,
-            ]));
+            ]);
+            actions.push(conditionAction);
         }
-        const assertStep = new AssertStep('assert', [stepArgs.assertArguments], actions);
+        const target = primaryAction.toDescriptor();
+        const onFailure = stepArgs.onFailure ?? stepArgs.assertArguments?.onFailure;
+        const observationScope = stepArgs.observationScope ?? stepArgs.assertArguments?.observationScope;
+        const descriptorToActionMap = new Map()
+            .set(target, primaryAction)
+            .set(conditionAction.conditionDescriptor, conditionAction);
+        if (extractAction) {
+            descriptorToActionMap.set(extractAction.toDescriptor(), extractAction);
+        }
+        if (countAction) {
+            descriptorToActionMap.set(countAction.countDescriptor, countAction);
+        }
+        const stepDescriptor = {
+            target,
+            extract: extractAction?.toDescriptor(),
+            condition: conditionAction.conditionDescriptor,
+            count: countAction?.countDescriptor,
+            onFailure,
+            observationScope,
+            descriptorToActionMap,
+            actionCode: AssertStep.actionCode,
+            description: stepArgs.description,
+            disabled: stepArgs.disabled,
+        };
+        const assertStep = new AssertStep('assert', [], actions, stepDescriptor);
         if (stepArgs.annotation) {
             assertStep.setAnnotation(stepArgs.annotation);
         }
         assertStep.setStepId(stepArgs.id);
         return assertStep;
     }
+    static fromLegacyMablscript(args, actions) {
+        const stepDescriptor = buildAssertStepDescriptor('assert', args, actions);
+        const step = new AssertStep('assert', [], actions, stepDescriptor);
+        return step;
+    }
     toMablscript() {
         if (this.primaryAction instanceof MobileFindAction_1.MobileFindAction) {
             throw new Error('Mobile steps do not generate mablscript');
@@ -256,13 +299,11 @@ class AssertStep extends MablStep_1.MablStep {
         if (primaryActionFindMablscriptPrefix.length > 0) {
             primaryActionFindMablscriptPrefix += '.';
         }
-        const assertAction = `.assert(${!!(this.assertArguments?.onFailure ||
-            this.assertArguments?.observationScope)
+        const assertAction = `.assert(${!!(this.observationScope ||
+            (this.onFailure && this.onFailure !== OnFailure.FailImmediately))
             ? (0, MablAction_1.convertObjectToMablscriptArgs)({
-                ...this.assertArguments,
-                onFailure: this.assertArguments?.onFailure === OnFailure.FailImmediately
-                    ? undefined
-                    : this.assertArguments?.onFailure,
+                observationScope: this.observationScope,
+                onFailure: this.onFailure,
             })
             : ''})`;
         if (this.countAction) {
@@ -306,7 +347,147 @@ class AssertStep extends MablStep_1.MablStep {
             ...(this.extractAction?.getInputVariables() ?? []),
         ]);
     }
+    stepDescription() {
+        if (this.assertionType === 'ai_prompt') {
+            return `Assert AI prompt: "${this.aiPrompt?.userPrompt}"`;
+        }
+        if (this.isWaitUntilStep) {
+            const elementDescription = this.humanizeFind();
+            return `Wait until ${elementDescription} is present`;
+        }
+        const elementDescription = this.humanizeFind();
+        if (this.assertionType === 'present') {
+            return `Assert that ${elementDescription} is present`;
+        }
+        if (this.assertionType === 'not_present') {
+            return `Assert that ${elementDescription} is not present`;
+        }
+        if (this.countAction) {
+            const comparator = this.getComparatorText();
+            return `Assert that count of ${elementDescription} ${comparator} ${this.assertionValue}`;
+        }
+        if (this.extractAction) {
+            const attribute = this.extractAction.extractionAttribute;
+            const comparator = this.getComparatorText();
+            return `Assert that ${attribute} of ${elementDescription} ${comparator} ${this.assertionValue}`;
+        }
+        const comparator = this.getComparatorText();
+        return `Assert that ${elementDescription} ${comparator} ${this.assertionValue}`;
+    }
+    humanizeFind() {
+        if (this.primaryAction instanceof GetUrlAction_1.GetUrlAction) {
+            return 'current URL';
+        }
+        if (this.primaryAction instanceof GetVariableValue_1.GetVariableValue) {
+            return `variable {{${this.primaryAction.variableName}}}`;
+        }
+        if (this.primaryAction instanceof GetViewportAction_1.GetViewportAction) {
+            return 'viewport';
+        }
+        if (this.primaryAction instanceof FindAction_1.FindAction) {
+            const findDescriptor = this.primaryAction.toDescriptor();
+            return (0, MablStepWithFindAction_1.humanizeFindDescriptor)(findDescriptor);
+        }
+        return 'element';
+    }
+    getComparatorText() {
+        switch (this.assertionType) {
+            case 'equals':
+                return 'equals';
+            case 'does_not_equal':
+                return 'does not equal';
+            case 'contains':
+                return 'contains';
+            case 'does_not_contain':
+                return 'does not contain';
+            case 'matches_regex':
+                return 'matches';
+            case 'greater_than':
+                return 'is greater than';
+            case 'less_than':
+                return 'is less than';
+            case 'greater_than_or_equals':
+                return 'is greater than or equal to';
+            case 'less_than_or_equals':
+                return 'is less than or equal to';
+            case 'starts_with':
+                return 'starts with';
+            case 'starts_without':
+                return 'starts without';
+            case 'ends_with':
+                return 'ends with';
+            case 'ends_without':
+                return 'ends without';
+            default:
+                return 'is';
+        }
+    }
 }
 exports.AssertStep = AssertStep;
-AssertStep.mablScriptStepNames = ['assert'];
+AssertStep.actionCode = 'assert';
+AssertStep.mablScriptStepNames = [
+    AssertStep.actionCode,
+    ...Object.keys(AssertStepOld_1.oldToV2StepNameMap),
+];
 AssertStep.yamlMablScriptNames = (0, exports.assertStepYamlMablscriptNames)();
+function buildAssertStepDescriptor(_name, args, actions) {
+    const firstAction = actions[0];
+    let primaryAction;
+    if (firstAction instanceof FindAction_1.FindAction ||
+        firstAction instanceof MobileFindAction_1.MobileFindAction ||
+        firstAction instanceof GetUrlAction_1.GetUrlAction ||
+        firstAction instanceof GetVariableValue_1.GetVariableValue ||
+        firstAction instanceof GetViewportAction_1.GetViewportAction) {
+        primaryAction = firstAction;
+    }
+    else if (firstAction instanceof ConditionAction_1.ConditionAction &&
+        (0, ConditionDescriptor_1.isAIPromptCondition)(firstAction.conditionDescriptor)) {
+        primaryAction = new GetViewportAction_1.GetViewportAction();
+    }
+    else {
+        throw new Error(`Unexpected action type. Expected FindAction|MobileFindAction|GetUrlAction|GetVariableValue but got: ${firstAction.constructor.name}`);
+    }
+    let extractAction;
+    let countAction;
+    let conditionAction;
+    if (actions.length === 3) {
+        if (actions[1] instanceof CountAction_1.CountAction) {
+            countAction = actions[1];
+        }
+        else {
+            extractAction = actions[1];
+        }
+        conditionAction = actions[2];
+    }
+    else if (firstAction instanceof ConditionAction_1.ConditionAction) {
+        conditionAction = firstAction;
+    }
+    else {
+        conditionAction = actions[1];
+    }
+    const find = primaryAction.toDescriptor();
+    const assertArguments = args[0] && typeof args[0] === 'object'
+        ? args[0]
+        : undefined;
+    const onFailure = assertArguments?.onFailure || OnFailure.FailImmediately;
+    const observationScope = assertArguments?.observationScope;
+    const descriptorToActionMap = new Map()
+        .set(find, primaryAction)
+        .set(conditionAction.conditionDescriptor, conditionAction);
+    if (extractAction) {
+        descriptorToActionMap.set(extractAction.toDescriptor(), extractAction);
+    }
+    if (countAction) {
+        descriptorToActionMap.set(countAction.countDescriptor, countAction);
+    }
+    return {
+        target: find,
+        extract: extractAction?.toDescriptor(),
+        condition: conditionAction.conditionDescriptor,
+        count: countAction?.countDescriptor,
+        onFailure,
+        observationScope,
+        descriptorToActionMap,
+        actionCode: AssertStep.actionCode,
+    };
+}