@mablhq/mabl-cli 2.72.0 → 2.72.3

package/mablscript/steps/CreateVariableStep.js

@@ -9,161 +9,188 @@ const FindAction_1 = require("../actions/FindAction");
 const GenerateEmailAddressAction_1 = require("../actions/GenerateEmailAddressAction");
 const GenerateRandomStringAction_1 = require("../actions/GenerateRandomStringAction");
 const JavaScriptAction_1 = require("../actions/JavaScriptAction");
-const MablStepV2_1 = require("../MablStepV2");
+const MablStep_1 = require("../MablStep");
 const CreateVariableStepDescriptor_1 = require("../types/CreateVariableStepDescriptor");
-class CreateVariableStep extends MablStepV2_1.MablStepV2 {
-    constructor(descriptor) {
-        super(CreateVariableStep.stepName, descriptor, CreateVariableStep.actionCode);
-        this.variableName = descriptor.name;
-        this.generationType = descriptor.generator.type;
-        this.actions = this.buildActions(descriptor);
+class CreateVariableStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'as');
+        this.variableName = this.getActionArgs()[0];
+        this.generationType = this.calculateGenerationType();
     }
     getStepName() {
         return CreateVariableStep.stepName;
     }
-    toStepDescriptor() {
-        return CreateVariableStep.buildStepDescriptor(this.variableName, this.generationType, this.actions);
+    calculateGenerationType() {
+        if (this.actions.length === 2 && this.actions[0] instanceof FindAction_1.FindAction) {
+            if (this.actions[0].findDescriptor.findType === domUtil_1.FindType.FIND_COOKIE) {
+                return CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE;
+            }
+            if (this.actions[1] instanceof ExtractAction_1.ExtractAction) {
+                return CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE;
+            }
+            else if (this.actions[1] instanceof CountAction_1.CountAction) {
+                return CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT;
+            }
+        }
+        else if (this.actions.length === 1 &&
+            this.actions[0] instanceof GenerateEmailAddressAction_1.GenerateEmailAddressAction) {
+            return CreateVariableStepDescriptor_1.VariableGenerator.EMAIL;
+        }
+        else if (this.actions.length === 1 &&
+            this.actions[0] instanceof JavaScriptAction_1.JavaScriptAction) {
+            return CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT;
+        }
+        else if (this.actions.length === 1 &&
+            this.actions[0] instanceof GenerateRandomStringAction_1.GenerateRandomStringAction) {
+            return CreateVariableStepDescriptor_1.VariableGenerator.PATTERN;
+        }
+        throw new Error('Unsupported variable generation type');
     }
-    static buildStepDescriptor(variableName, generationType, actions) {
-        switch (generationType) {
+    toStepDescriptor() {
+        let step;
+        switch (this.generationType) {
+            case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
+                const cookieFindAction = this.actions[0];
+                const cookieFind = cookieFindAction.toDescriptor();
+                step = {
+                    name: this.variableName,
+                    generator: {
+                        type: CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE,
+                        cookieSelector: cookieFind.findTarget,
+                        attribute: this.actions[1].extractionAttribute,
+                    },
+                    find: cookieFind,
+                    descriptorToActionMap: new Map().set(cookieFind, cookieFindAction),
+                    actionCode: this.actionCode,
+                };
+                break;
             case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
-                const findAction = actions[0];
-                const extractAction = actions[1];
+                const findAction = this.actions[0];
                 const find = findAction.toDescriptor();
-                return {
-                    name: variableName,
+                step = {
+                    name: this.variableName,
                     generator: {
                         type: CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE,
-                        attribute: extractAction.extractionAttribute,
+                        attribute: this.actions[1].extractionAttribute,
                         find,
                     },
                     find,
-                    descriptorToActionMap: new Map([[find, findAction]]),
-                    actionCode: CreateVariableStep.actionCode,
-                };
-            case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
-                const countFindAction = actions[0];
-                const countFind = countFindAction.toDescriptor();
-                return {
-                    find: countFind,
-                    name: variableName,
-                    generator: {
-                        type: CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT,
-                        find: countFind,
-                    },
-                    descriptorToActionMap: new Map([[countFind, countFindAction]]),
-                    actionCode: CreateVariableStep.actionCode,
+                    descriptorToActionMap: new Map().set(find, findAction),
+                    actionCode: this.actionCode,
                 };
+                break;
             case CreateVariableStepDescriptor_1.VariableGenerator.EMAIL:
-                return {
-                    name: variableName,
+                step = {
+                    name: this.variableName,
                     generator: { type: CreateVariableStepDescriptor_1.VariableGenerator.EMAIL },
-                    actionCode: CreateVariableStep.actionCode,
+                    actionCode: this.actionCode,
                 };
+                break;
             case CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT:
-                const jsAction = actions[0];
-                return {
-                    name: variableName,
+                step = {
+                    name: this.variableName,
                     generator: {
                         type: CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT,
-                        javaScript: jsAction.toDescriptor().javaScript,
+                        javaScript: this.actions[0].javaScript,
                     },
-                    actionCode: CreateVariableStep.actionCode,
+                    actionCode: this.actionCode,
                 };
+                break;
             case CreateVariableStepDescriptor_1.VariableGenerator.PATTERN:
-                const patternAction = actions[0];
-                return {
-                    name: variableName,
+                step = {
+                    name: this.variableName,
                     generator: {
                         type: CreateVariableStepDescriptor_1.VariableGenerator.PATTERN,
-                        pattern: patternAction.generateString,
+                        pattern: this.actions[0]
+                            .generateString,
                     },
-                    actionCode: CreateVariableStep.actionCode,
+                    actionCode: this.actionCode,
                 };
-            case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
-                const cookieFindAction = actions[0];
-                const cookieExtractAction = actions[1];
-                const cookieFind = cookieFindAction.toDescriptor();
-                return {
-                    name: variableName,
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
+                const countFindAction = this.actions[0];
+                const countFind = countFindAction.toDescriptor();
+                step = {
+                    find: countFind,
+                    name: this.variableName,
                     generator: {
-                        type: CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE,
-                        cookieSelector: cookieFind.findTarget,
-                        attribute: cookieExtractAction.extractionAttribute,
+                        type: CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT,
+                        find: countFind,
                     },
-                    find: cookieFind,
-                    descriptorToActionMap: new Map([[cookieFind, cookieFindAction]]),
-                    actionCode: CreateVariableStep.actionCode,
+                    descriptorToActionMap: new Map().set(countFind, countFindAction),
+                    actionCode: this.actionCode,
                 };
-            default:
-                throw new Error(`Unsupported variable generation type: ${generationType}`);
+                break;
         }
+        return step;
     }
-    buildActions(descriptor) {
-        const actions = [];
-        switch (descriptor.generator.type) {
-            case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
-                if ('find' in descriptor) {
-                    const attrGenerator = descriptor.generator;
-                    actions.push(FindAction_1.FindAction.findActionFromStepArgs(descriptor));
-                    actions.push(new ExtractAction_1.ExtractAction('extract_attribute', [attrGenerator.attribute]));
-                }
-                break;
+    getFormattedStep() {
+        const step = this.toStepDescriptor();
+        const stepName = this.getStepName();
+        const formatted = {
+            [stepName]: {},
+        };
+        if (this.annotationsOnStep()) {
+            formatted[stepName].annotation = this.annotation;
+        }
+        if (this.description) {
+            formatted[stepName].description = this.description;
+        }
+        switch (step.generator.type) {
             case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
-                if ('find' in descriptor) {
-                    const findDescriptor = descriptor.find;
-                    actions.push(new FindAction_1.FindAction('find_all', [
-                        findDescriptor.findTarget,
-                        findDescriptor.foundElementSelectors,
-                        findDescriptor.findOptions,
-                    ]));
-                    actions.push(new CountAction_1.CountAction('count', []));
-                }
+                formatted[stepName] = {
+                    ...formatted[stepName],
+                    generator: step.generator,
+                    name: this.variableName,
+                    selector: step.generator.find.findTarget,
+                };
                 break;
-            case CreateVariableStepDescriptor_1.VariableGenerator.EMAIL:
-                actions.push(new GenerateEmailAddressAction_1.GenerateEmailAddressAction('generate_email_address', []));
+            case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
+                formatted[stepName] = {
+                    ...formatted[stepName],
+                    generator: step.generator,
+                    name: this.variableName,
+                    selector: step.generator.find.findTarget.selector,
+                    selectorAncestors: (step.generator.find.findTarget.auxiliaryDescriptors ?? []).map((descriptor) => descriptor.selector),
+                };
                 break;
             case CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT:
-                const jsGenerator = descriptor.generator;
-                actions.push(JavaScriptAction_1.JavaScriptAction.fromDescriptor({
-                    javaScript: jsGenerator.javaScript,
-                }));
-                break;
-            case CreateVariableStepDescriptor_1.VariableGenerator.PATTERN:
-                const patternGenerator = descriptor.generator;
-                actions.push(new GenerateRandomStringAction_1.GenerateRandomStringAction('generate_random_string', [
-                    patternGenerator.pattern,
-                ]));
-                break;
-            case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
-                if ('find' in descriptor) {
-                    const cookieGenerator = descriptor.generator;
-                    actions.push(new FindAction_1.FindAction('find_cookie', [cookieGenerator.cookieSelector]));
-                    actions.push(new ExtractAction_1.ExtractAction('extract_attribute', [cookieGenerator.attribute]));
-                }
+                formatted[stepName] = {
+                    ...formatted[stepName],
+                    generator: {
+                        type: CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT,
+                        javaScript: this.actions[0].toYaml(),
+                    },
+                    name: this.variableName,
+                };
                 break;
             default:
-                throw new Error(`Unsupported variable generation type: ${descriptor.generator.type}`);
+                formatted[stepName] = {
+                    ...formatted[stepName],
+                    generator: step.generator,
+                    name: this.variableName,
+                };
+        }
+        if (this.stepId()) {
+            formatted[stepName].id = this.stepId();
         }
-        return actions;
+        return formatted;
     }
     static fromYaml(_stepName, stepArgs) {
         const variableName = stepArgs.name;
-        const generator = stepArgs.generator ?? {};
+        const generator = stepArgs.generator;
         const generationType = generator.type;
         const actions = [];
         switch (generationType) {
             case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
-                const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
-                actions.push(findAction);
+                actions.push(FindAction_1.FindAction.findActionFromStepArgs(stepArgs));
                 const extractArgs = generator.metadata
                     ? [generator.attribute, generator.metadata]
                     : [generator.attribute];
                 actions.push(new ExtractAction_1.ExtractAction('extract_attribute', extractArgs));
                 break;
             case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
-                const countFindAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs, domUtil_1.FindType.FIND_ALL);
-                actions.push(countFindAction);
+                actions.push(FindAction_1.FindAction.findActionFromStepArgs(stepArgs, domUtil_1.FindType.FIND_ALL));
                 actions.push(new CountAction_1.CountAction('count', []));
                 break;
             case CreateVariableStepDescriptor_1.VariableGenerator.EMAIL:
@@ -178,88 +205,29 @@ class CreateVariableStep extends MablStepV2_1.MablStepV2 {
                 ]));
                 break;
             case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
-                const cookieFindAction = new FindAction_1.FindAction('find_cookie', [
-                    generator.cookieSelector,
-                ]);
-                actions.push(cookieFindAction);
-                actions.push(new ExtractAction_1.ExtractAction('extract_attribute', [generator.attribute]));
+                actions.push(new FindAction_1.FindAction('find_cookie', [generator.cookieSelector]));
+                const extractCookieArgs = [generator.attribute];
+                actions.push(new ExtractAction_1.ExtractAction('extract_attribute', extractCookieArgs));
                 break;
-            default:
-                throw new Error(`Unsupported variable generation type: ${generationType}`);
         }
-        const stepDescriptor = CreateVariableStep.buildStepDescriptor(variableName, generationType, actions);
-        const step = new CreateVariableStep(stepDescriptor);
+        const step = new CreateVariableStep('as', [variableName], actions);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(args, actions) {
-        const variableName = args[0];
-        const generationType = CreateVariableStep.calculateGenerationType(actions);
-        const stepDescriptor = CreateVariableStep.buildStepDescriptor(variableName, generationType, actions);
-        const step = new CreateVariableStep(stepDescriptor);
-        return step;
-    }
-    static calculateGenerationType(actions) {
-        if (actions.length === 2 && actions[0] instanceof FindAction_1.FindAction) {
-            if (actions[0].findDescriptor.findType === domUtil_1.FindType.FIND_COOKIE) {
-                return CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE;
-            }
-            if (actions[1] instanceof ExtractAction_1.ExtractAction) {
-                return CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE;
-            }
-            else if (actions[1] instanceof CountAction_1.CountAction) {
-                return CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT;
-            }
-        }
-        else if (actions.length === 1 &&
-            actions[0] instanceof GenerateEmailAddressAction_1.GenerateEmailAddressAction) {
-            return CreateVariableStepDescriptor_1.VariableGenerator.EMAIL;
-        }
-        else if (actions.length === 1 && actions[0] instanceof JavaScriptAction_1.JavaScriptAction) {
-            return CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT;
-        }
-        else if (actions.length === 1 &&
-            actions[0] instanceof GenerateRandomStringAction_1.GenerateRandomStringAction) {
-            return CreateVariableStepDescriptor_1.VariableGenerator.PATTERN;
-        }
-        throw new Error('Unsupported variable generation type');
-    }
     toMablscript() {
         return `${this.actions.reduce((mablscript, action) => `${mablscript}${action.toMablscript()}.`, '')}as("${this.variableName}")`;
     }
     getInputVariables() {
-        return this.actions.length > 0 ? this.actions[0].getInputVariables() : [];
+        return this.actions[0].getInputVariables();
     }
     getOutputVariables() {
         return [this.variableName];
     }
-    stepDescription() {
-        switch (this.generationType) {
-            case CreateVariableStepDescriptor_1.VariableGenerator.EMAIL:
-                return `Generate email address for variable "${this.variableName}"`;
-            case CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT:
-                return `Execute JavaScript to create variable "${this.variableName}"`;
-            case CreateVariableStepDescriptor_1.VariableGenerator.PATTERN:
-                return `Generate random string for variable "${this.variableName}"`;
-            case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
-                return `Extract attribute value to variable "${this.variableName}"`;
-            case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
-                return `Extract cookie attribute to variable "${this.variableName}"`;
-            case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
-                return `Count elements and store in variable "${this.variableName}"`;
-            default:
-                return `Create variable "${this.variableName}"`;
-        }
-    }
 }
 exports.CreateVariableStep = CreateVariableStep;
 CreateVariableStep.stepName = 'CreateVariable';
-CreateVariableStep.actionCode = 'as';
-CreateVariableStep.mablScriptStepNames = [CreateVariableStep.actionCode];
-CreateVariableStep.yamlMablScriptNames = [
-    CreateVariableStep.stepName,
-    'GenerateEmailAddress',
-];
+CreateVariableStep.mablScriptStepNames = ['as'];
+CreateVariableStep.yamlMablScriptNames = ['CreateVariable', 'GenerateEmailAddress'];
 function isCreateVariableStep(value) {
     return (value?.getStepName &&
         value.getStepName() === CreateVariableStep.stepName &&

package/mablscript/steps/DatabaseQueryStep.js

@@ -4,29 +4,19 @@ exports.DatabaseQueryVariableSource = exports.DatabaseQueryStep = void 0;
 exports.isDatabaseQueryStep = isDatabaseQueryStep;
 const AbstractAssertionsAndVariablesStep_1 = require("./AbstractAssertionsAndVariablesStep");
 class DatabaseQueryStep extends AbstractAssertionsAndVariablesStep_1.AbstractAssertionsAndVariablesStep {
-    constructor(descriptor) {
-        super(DatabaseQueryStep.stepName, descriptor, DatabaseQueryStep.actionCode);
+    constructor(name, args, actions) {
+        super(name, args, actions, DatabaseQueryStep.mablScriptStepNames[0], DatabaseQueryStep.stepName, args[0]);
     }
     static fromYaml(_stepName, stepArgs) {
         const formatted = stepArgs;
-        const step = new DatabaseQueryStep(formatted);
+        const step = new DatabaseQueryStep(DatabaseQueryStep.stepName, [formatted], []);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(args, _actions) {
-        if (args.length !== 1) {
-            throw new Error(`DatabaseQueryStep fromLegacyMablscript expects 1 argument, got ${args.length}`);
-        }
-        return new DatabaseQueryStep(args[0]);
-    }
-    stepDescription() {
-        return `Database query execution`;
-    }
 }
 exports.DatabaseQueryStep = DatabaseQueryStep;
 DatabaseQueryStep.stepName = 'DatabaseQuery';
-DatabaseQueryStep.actionCode = 'database_query';
-DatabaseQueryStep.mablScriptStepNames = [DatabaseQueryStep.actionCode];
+DatabaseQueryStep.mablScriptStepNames = ['database_query'];
 DatabaseQueryStep.yamlMablScriptNames = [DatabaseQueryStep.stepName];
 var DatabaseQueryVariableSource;
 (function (DatabaseQueryVariableSource) {

package/mablscript/steps/DoubleClickStep.js

@@ -3,59 +3,62 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoubleClickStep = void 0;
 const FindAction_1 = require("../actions/FindAction");
 const domUtil_1 = require("../../domUtil");
-const ActionsUtils_1 = require("./ActionsUtils");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class DoubleClickStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(descriptor, findAction) {
-        super(DoubleClickStep.stepName, descriptor, DoubleClickStep.actionCode, findAction);
+    constructor(name, args, actions) {
+        super(name, args, actions, 'double_click');
+        this.validate();
+        this.findAction = this.actions[0];
+    }
+    validate() {
+        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
+            throw new Error('Double click steps should have exactly on sub action and it should be a find');
+        }
     }
     getStepName() {
-        return DoubleClickStep.stepName;
+        return 'DoubleClick';
     }
     toStepDescriptor() {
-        return buildStepDescriptor(this.findAction);
+        const find = this.findAction.toDescriptor();
+        switch (find.findType) {
+            case domUtil_1.FindType.FIND_FIRST:
+            case domUtil_1.FindType.FIND_LAST:
+            case domUtil_1.FindType.FIND_ANY:
+            case domUtil_1.FindType.FIND_ALL:
+            case domUtil_1.FindType.FIND_ONE:
+                return {
+                    find,
+                    descriptorToActionMap: new Map().set(find, this.findAction),
+                    actionCode: this.actionCode,
+                };
+            default:
+                throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
+        }
+    }
+    getFormattedStep(_fullLocatorsOn) {
+        const step = {
+            DoubleClick: {
+                ...super.annotationsAsYml(),
+                ...this.findAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step.DoubleClick.id = this.stepId();
+        }
+        return step;
     }
     static fromYaml(_stepName, stepArgs) {
-        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
-        const stepDescriptor = buildStepDescriptor(findAction);
-        const step = new DoubleClickStep(stepDescriptor, findAction);
+        const step = new DoubleClickStep('double_click', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(_args, actions) {
-        const findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(actions);
-        const stepDescriptor = buildStepDescriptor(findAction);
-        return new DoubleClickStep(stepDescriptor, findAction);
-    }
     toMablscript() {
         return `${this.findAction.toMablscript()}.double_click()`;
     }
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
-    stepDescription() {
-        const elementDescription = this.humanizeFind();
-        return `Double click on ${elementDescription}`;
-    }
 }
 exports.DoubleClickStep = DoubleClickStep;
-DoubleClickStep.stepName = 'DoubleClick';
-DoubleClickStep.actionCode = 'double_click';
-DoubleClickStep.mablScriptStepNames = [DoubleClickStep.actionCode];
-DoubleClickStep.yamlMablScriptNames = [DoubleClickStep.stepName];
-function buildStepDescriptor(findAction) {
-    const find = findAction.toDescriptor();
-    switch (find.findType) {
-        case domUtil_1.FindType.FIND_FIRST:
-        case domUtil_1.FindType.FIND_LAST:
-        case domUtil_1.FindType.FIND_ANY:
-        case domUtil_1.FindType.FIND_ONE:
-            return {
-                find,
-                descriptorToActionMap: new Map().set(find, findAction),
-                actionCode: DoubleClickStep.actionCode,
-            };
-        default:
-            throw new Error(`Error generating step descriptor for ${DoubleClickStep.stepName}: Unexpected find type ${find.findType}`);
-    }
-}
+DoubleClickStep.mablScriptStepNames = ['double_click'];
+DoubleClickStep.yamlMablScriptNames = ['DoubleClick'];