@mablhq/playwright-tools 2.49.1

package/mablscript/mobile/tests/steps/ScrollStep.mobiletest.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ScrollStep_1 = require("../../steps/ScrollStep");
+const ScrollStepDescriptor_1 = require("../../../types/mobile/ScrollStepDescriptor");
+const StepTestsUtil_1 = require("../StepTestsUtil");
+const domUtil_1 = require("../../../../domUtil");
+describe('Scroll steps parse correctly', () => {
+    describe('ScrollType.ScrollDeviceScreen', () => {
+        it('Parses a ScrollDeviceScreen step', () => {
+            const windowSize = { width: 1440, height: 2392 };
+            const scrollStepDescriptor = {
+                description: 'Scroll down 94.06% of the screen',
+                id: 'scrolliePolieOlie',
+                coordinates: {
+                    from: {
+                        xPercent: 1074 / windowSize.width,
+                        yPercent: 2350 / windowSize.height,
+                    },
+                    to: {
+                        xPercent: 1074 / windowSize.width,
+                        yPercent: 100 / windowSize.height,
+                    },
+                },
+                actionCode: 'scroll',
+                scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Down,
+                scrollType: ScrollStepDescriptor_1.ScrollType.ScrollDeviceScreen,
+            };
+            const steps = [
+                {
+                    Scroll: scrollStepDescriptor,
+                },
+            ];
+            (0, StepTestsUtil_1.parseAndValidateYamlConversion)(steps, ScrollStep_1.ScrollStep.stepName, scrollStepDescriptor);
+            const scrollStep = new ScrollStep_1.ScrollStep(scrollStepDescriptor);
+            expect(scrollStep.stepId()).toEqual(scrollStepDescriptor.id);
+        });
+        it('Humanizes a ScrollDeviceScreen step', () => {
+            const windowSize = { width: 1440, height: 2392 };
+            const stepYaml = {
+                Scroll: {
+                    coordinates: {
+                        from: {
+                            xPercent: 1074 / windowSize.width,
+                            yPercent: 2350 / windowSize.height,
+                        },
+                        to: {
+                            xPercent: 1074 / windowSize.width,
+                            yPercent: 100 / windowSize.height,
+                        },
+                    },
+                    actionCode: 'scroll',
+                    scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Down,
+                    scrollType: ScrollStepDescriptor_1.ScrollType.ScrollDeviceScreen,
+                },
+            };
+            const step = (0, StepTestsUtil_1.loadRawStepIntoMablStep)(stepYaml);
+            expect(step.stepDescription()).toEqual(`Scroll down 94.06% of the screen`);
+        });
+        it('Humanizes scroll directions as expected', () => {
+            const scrollUpStepYaml = {
+                Scroll: {
+                    coordinates: {
+                        from: {
+                            xPercent: 0.109212,
+                            yPercent: 0.241223,
+                        },
+                        to: {
+                            xPercent: 0.145543,
+                            yPercent: 0.865454,
+                        },
+                    },
+                    actionCode: 'scroll',
+                    scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Up,
+                    scrollType: ScrollStepDescriptor_1.ScrollType.ScrollDeviceScreen,
+                },
+            };
+            const scrollUpStep = (0, StepTestsUtil_1.loadRawStepIntoMablStep)(scrollUpStepYaml);
+            expect(scrollUpStep.stepDescription()).toEqual(`Scroll up 62.42% of the screen`);
+            const scrollDownStepYaml = {
+                Scroll: {
+                    coordinates: {
+                        from: {
+                            xPercent: 0.48351,
+                            yPercent: 0.89123,
+                        },
+                        to: {
+                            xPercent: 0.4515,
+                            yPercent: 0.0874,
+                        },
+                    },
+                    actionCode: 'scroll',
+                    scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Down,
+                    scrollType: ScrollStepDescriptor_1.ScrollType.ScrollDeviceScreen,
+                },
+            };
+            const scrollDownStep = (0, StepTestsUtil_1.loadRawStepIntoMablStep)(scrollDownStepYaml);
+            expect(scrollDownStep.stepDescription()).toEqual(`Scroll down 80.38% of the screen`);
+            const scrollLeftStepYaml = {
+                Scroll: {
+                    coordinates: {
+                        from: {
+                            xPercent: 0.08111,
+                            yPercent: 0.46123,
+                        },
+                        to: {
+                            xPercent: 0.90295,
+                            yPercent: 0.4574,
+                        },
+                    },
+                    actionCode: 'scroll',
+                    scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Right,
+                    scrollType: ScrollStepDescriptor_1.ScrollType.ScrollDeviceScreen,
+                },
+            };
+            const scrollLeftStep = (0, StepTestsUtil_1.loadRawStepIntoMablStep)(scrollLeftStepYaml);
+            expect(scrollLeftStep.stepDescription()).toEqual(`Scroll left 82.18% of the screen`);
+            const scrollRightStepYaml = {
+                Scroll: {
+                    coordinates: {
+                        from: {
+                            xPercent: 0.88111,
+                            yPercent: 0.46123,
+                        },
+                        to: {
+                            xPercent: 0.09295,
+                            yPercent: 0.4574,
+                        },
+                    },
+                    actionCode: 'scroll',
+                    scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Left,
+                    scrollType: ScrollStepDescriptor_1.ScrollType.ScrollDeviceScreen,
+                },
+            };
+            const scrollRightStep = (0, StepTestsUtil_1.loadRawStepIntoMablStep)(scrollRightStepYaml);
+            expect(scrollRightStep.stepDescription()).toEqual(`Scroll right 78.82% of the screen`);
+        });
+    });
+    describe('ScrollType.ScrollToElement', () => {
+        const find = {
+            findType: domUtil_1.FindType.FIND_ONE,
+            findTarget: {
+                selector: {
+                    iOS: {
+                        name: 'Name field',
+                    },
+                    uuid: '',
+                },
+            },
+        };
+        const innerFindTarget = {
+            findType: domUtil_1.FindType.FIND_ONE,
+            findTarget: {
+                selector: {
+                    iOS: {
+                        name: 'Email field',
+                    },
+                    uuid: '',
+                },
+            },
+        };
+        it('Parses a ScrollToElement step', () => {
+            const scrollStepDescriptor = {
+                description: 'Scroll right a maximum of 6 times within the "Name field" element until the "Email field" element is visible',
+                id: 'scrollMe',
+                actionCode: 'scroll',
+                find,
+                maxScrollAttempts: 6,
+                scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Right,
+                scrollType: ScrollStepDescriptor_1.ScrollType.ScrollToElement,
+                targetElementDescriptor: innerFindTarget,
+            };
+            const steps = [
+                {
+                    Scroll: scrollStepDescriptor,
+                },
+            ];
+            (0, StepTestsUtil_1.parseAndValidateYamlConversion)(steps, ScrollStep_1.ScrollStep.stepName, scrollStepDescriptor);
+            const scrollStep = new ScrollStep_1.ScrollStep(scrollStepDescriptor);
+            expect(scrollStep.stepId()).toEqual(scrollStepDescriptor.id);
+        });
+        it('Humanizes ScrollToElement step with container element', () => {
+            const scrollStepDescriptor = {
+                id: 'scrollMe',
+                actionCode: 'scroll',
+                coordinates: {
+                    from: {
+                        xPercent: 0.109212,
+                        yPercent: 0.241223,
+                    },
+                    to: {
+                        xPercent: 0.145543,
+                        yPercent: 0.865454,
+                    },
+                },
+                find,
+                maxScrollAttempts: 6,
+                scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Up,
+                scrollType: ScrollStepDescriptor_1.ScrollType.ScrollToElement,
+                targetElementDescriptor: innerFindTarget,
+            };
+            const stepYaml = {
+                Scroll: scrollStepDescriptor,
+            };
+            const step = (0, StepTestsUtil_1.loadRawStepIntoMablStep)(stepYaml);
+            expect(step.stepDescription()).toEqual(`Scroll up 62.42% a maximum of 6 times within the "Name field" element until the "Email field" element is visible`);
+        });
+        it('Humanizes ScrollToElement step without container element', () => {
+            const scrollStepDescriptor = {
+                id: 'scrollMe',
+                actionCode: 'scroll',
+                coordinates: {
+                    from: {
+                        xPercent: 0.109212,
+                        yPercent: 0.241223,
+                    },
+                    to: {
+                        xPercent: 0.145543,
+                        yPercent: 0.865454,
+                    },
+                },
+                maxScrollAttempts: 6,
+                scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Up,
+                scrollType: ScrollStepDescriptor_1.ScrollType.ScrollToElement,
+                targetElementDescriptor: innerFindTarget,
+            };
+            const stepYaml = {
+                Scroll: scrollStepDescriptor,
+            };
+            const step = (0, StepTestsUtil_1.loadRawStepIntoMablStep)(stepYaml);
+            expect(step.stepDescription()).toEqual(`Scroll up 62.42% a maximum of 6 times within the screen until the "Email field" element is visible`);
+        });
+        it('Humanizes a legacy ScrollToElement step', () => {
+            const scrollStepDescriptor = {
+                id: 'scrollMe',
+                actionCode: 'scroll',
+                find,
+                maxScrollAttempts: 6,
+                scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Right,
+                scrollType: ScrollStepDescriptor_1.ScrollType.ScrollToElement,
+                targetElementDescriptor: innerFindTarget,
+            };
+            const stepYaml = {
+                Scroll: scrollStepDescriptor,
+            };
+            const step = (0, StepTestsUtil_1.loadRawStepIntoMablStep)(stepYaml);
+            expect(step.stepDescription()).toEqual(`Scroll right a maximum of 6 times within the "Name field" element until the "Email field" element is visible`);
+        });
+    });
+    describe('ScrollType.ScrollWithinElement', () => {
+        const find = {
+            findType: domUtil_1.FindType.FIND_ONE,
+            findTarget: {
+                selector: {
+                    iOS: {
+                        name: 'Name field',
+                    },
+                    uuid: '',
+                },
+            },
+        };
+        it('Parses a ScrollWithinElement step', () => {
+            const scrollStepDescriptor = {
+                description: 'Scroll right 80% within the "Name field" element',
+                id: 'scrollMe',
+                actionCode: 'scroll',
+                coordinates: {
+                    from: {
+                        xPercent: 0.9,
+                        yPercent: 0.6,
+                    },
+                    to: {
+                        xPercent: 0.1,
+                        yPercent: 0.5,
+                    },
+                },
+                find,
+                scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Left,
+                scrollType: ScrollStepDescriptor_1.ScrollType.ScrollWithinElement,
+            };
+            const steps = [
+                {
+                    Scroll: scrollStepDescriptor,
+                },
+            ];
+            (0, StepTestsUtil_1.parseAndValidateYamlConversion)(steps, ScrollStep_1.ScrollStep.stepName, scrollStepDescriptor);
+            const scrollStep = new ScrollStep_1.ScrollStep(scrollStepDescriptor);
+            expect(scrollStep.stepId()).toEqual(scrollStepDescriptor.id);
+        });
+        it('Humanizes a ScrollWithinElement step', () => {
+            const scrollStepDescriptor = {
+                id: 'scrollMe',
+                actionCode: 'scroll',
+                coordinates: {
+                    from: {
+                        xPercent: 0.9,
+                        yPercent: 0.6,
+                    },
+                    to: {
+                        xPercent: 0.1,
+                        yPercent: 0.5,
+                    },
+                },
+                find,
+                scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Left,
+                scrollType: ScrollStepDescriptor_1.ScrollType.ScrollWithinElement,
+            };
+            const stepYaml = {
+                Scroll: scrollStepDescriptor,
+            };
+            const step = (0, StepTestsUtil_1.loadRawStepIntoMablStep)(stepYaml);
+            expect(step.stepDescription()).toEqual(`Scroll right 80% within the "Name field" element`);
+        });
+    });
+});
+describe('getScrollDirectionAndPercentageFromCoordinates', () => {
+    it('returned default down 80% if no coordinates supplied', () => {
+        expect((0, ScrollStep_1.getScrollDirectionAndPercentageFromCoordinates)(undefined)).toEqual({
+            scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Down,
+            scrollPercent: '80%',
+        });
+    });
+    it('determines correct down direction and percentage', () => {
+        const scrollCoordinates = {
+            from: {
+                xPercent: 0.3,
+                yPercent: 0.75,
+            },
+            to: {
+                xPercent: 0.5,
+                yPercent: 0.25,
+            },
+        };
+        expect((0, ScrollStep_1.getScrollDirectionAndPercentageFromCoordinates)(scrollCoordinates)).toEqual({
+            scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Down,
+            scrollPercent: '50%',
+        });
+    });
+    it('determines correct up direction and percentage', () => {
+        const scrollCoordinates = {
+            from: {
+                xPercent: 0.7,
+                yPercent: 0,
+            },
+            to: {
+                xPercent: 0.4,
+                yPercent: 1,
+            },
+        };
+        expect((0, ScrollStep_1.getScrollDirectionAndPercentageFromCoordinates)(scrollCoordinates)).toEqual({
+            scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Up,
+            scrollPercent: '100%',
+        });
+    });
+    it('determines correct right direction and percentage', () => {
+        const scrollCoordinates = {
+            from: {
+                xPercent: 0.95,
+                yPercent: 0.4,
+            },
+            to: {
+                xPercent: 0.12,
+                yPercent: 0.5,
+            },
+        };
+        expect((0, ScrollStep_1.getScrollDirectionAndPercentageFromCoordinates)(scrollCoordinates)).toEqual({
+            scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Right,
+            scrollPercent: '83%',
+        });
+    });
+    it('determines correct left direction and percentage', () => {
+        const scrollCoordinates = {
+            from: {
+                xPercent: 0.04,
+                yPercent: 0.7,
+            },
+            to: {
+                xPercent: 0.82,
+                yPercent: 0.4,
+            },
+        };
+        expect((0, ScrollStep_1.getScrollDirectionAndPercentageFromCoordinates)(scrollCoordinates)).toEqual({
+            scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Left,
+            scrollPercent: '78%',
+        });
+    });
+});

package/mablscript/mobile/tests/steps/SetOrientationStep.mobiletest.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SetOrientationStep_1 = require("../../steps/SetOrientationStep");
+const SetOrientationStepDescriptor_1 = require("../../../types/mobile/SetOrientationStepDescriptor");
+const StepTestsUtil_1 = require("../StepTestsUtil");
+describe('SetOrientation steps parse correctly', () => {
+    it('Parses a SetOrientation step', () => {
+        const setOrientationStepDescriptor = {
+            id: 'theOrientalExpress',
+            orientation: SetOrientationStepDescriptor_1.Orientation.Landscape,
+            actionCode: 'set_orientation',
+        };
+        const steps = [
+            {
+                SetOrientation: setOrientationStepDescriptor,
+            },
+        ];
+        (0, StepTestsUtil_1.parseAndValidateYamlConversion)(steps, SetOrientationStep_1.SetOrientationStep.stepName, setOrientationStepDescriptor);
+        const orientationStep = new SetOrientationStep_1.SetOrientationStep(setOrientationStepDescriptor);
+        expect(orientationStep.stepId()).toEqual(setOrientationStepDescriptor.id);
+    });
+    it('Humanizes a SetOrientation step', () => {
+        const stepYaml = {
+            SetOrientation: {
+                orientation: SetOrientationStepDescriptor_1.Orientation.Landscape,
+                actionCode: 'set_orientation',
+            },
+        };
+        const step = (0, StepTestsUtil_1.loadRawStepIntoMablStep)(stepYaml);
+        expect(step.stepDescription()).toEqual(`Set orientation of device to landscape`);
+    });
+});

package/mablscript/mobile/tests/steps/TapStep.mobiletest.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TapStep_1 = require("../../steps/TapStep");
+const domUtil_1 = require("../../../../domUtil");
+const StepTestsUtil_1 = require("../StepTestsUtil");
+const TapStepDescriptor_1 = require("../../../types/mobile/TapStepDescriptor");
+const TestMobileFindDescriptors_1 = require("../TestMobileFindDescriptors");
+describe('Tap steps parse correctly', () => {
+    it('Parses a Tap step with a Find One selector', () => {
+        const find = {
+            findType: domUtil_1.FindType.FIND_ONE,
+            findTarget: {
+                selector: {
+                    iOS: {
+                        name: '{{@varInFind}}',
+                    },
+                    uuid: '',
+                },
+            },
+        };
+        const stepDescriptor = {
+            id: 'TappyMcTapperson',
+            find,
+            type: TapStepDescriptor_1.TapType.tap,
+            actionCode: 'tap',
+        };
+        const steps = [
+            {
+                Tap: stepDescriptor,
+            },
+        ];
+        (0, StepTestsUtil_1.parseAndValidateYamlConversion)(steps, TapStep_1.TapStep.stepName, stepDescriptor);
+        const tapStep = new TapStep_1.TapStep(stepDescriptor);
+        expect(tapStep.stepId()).toEqual(stepDescriptor.id);
+        expect(tapStep.getInputVariables()).toStrictEqual(['varInFind']);
+    });
+    it('Parses a WebView Tap step', () => {
+        const stepDescriptor = {
+            find: TestMobileFindDescriptors_1.iOSWebViewTextFieldMobileFindDescriptor,
+            type: TapStepDescriptor_1.TapType.tap,
+            actionCode: 'tap',
+        };
+        const steps = [
+            {
+                Tap: stepDescriptor,
+            },
+        ];
+        (0, StepTestsUtil_1.parseAndValidateYamlConversion)(steps, TapStep_1.TapStep.stepName, stepDescriptor);
+    });
+    it('Renders description for step without find', () => {
+        const stepDescriptor = {
+            type: TapStepDescriptor_1.TapType.tap,
+        };
+        const tapStep = new TapStep_1.TapStep(stepDescriptor);
+        expect(tapStep.stepDescription()).toEqual('Tap on unknown element');
+    });
+});

package/mablscript/mobile/tests/steps/UninstallAppStep.mobiletest.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const UninstallAppStep_1 = require("../../steps/UninstallAppStep");
+const StepTestsUtil_1 = require("../StepTestsUtil");
+describe('Uninstall App steps parse correctly', () => {
+    it('Parses an UninstallApp step', () => {
+        const stepDescriptor = {
+            id: 'noAppForYou',
+            actionCode: 'uninstallApp',
+        };
+        const steps = [
+            {
+                UninstallApp: stepDescriptor,
+            },
+        ];
+        (0, StepTestsUtil_1.parseAndValidateYamlConversion)(steps, UninstallAppStep_1.UninstallAppStep.stepName, stepDescriptor);
+        const tapStep = new UninstallAppStep_1.UninstallAppStep(stepDescriptor);
+        expect(tapStep.stepId()).toEqual(stepDescriptor.id);
+    });
+});

package/mablscript/steps/AbstractAssertionsAndVariablesStep.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractAssertionsAndVariablesStep = void 0;
+const domUtil_1 = require("../../domUtil");
+const MablAction_1 = require("../MablAction");
+const MablStep_1 = require("../MablStep");
+const ConditionDescriptor_1 = require("../types/ConditionDescriptor");
+const AssertStep_1 = require("./AssertStep");
+class AbstractAssertionsAndVariablesStep extends MablStep_1.MablStep {
+    constructor(name, args, actions, mablScriptName, stepName, descriptor) {
+        super(name, args, actions, mablScriptName);
+        this.stepName = stepName;
+        this.descriptor = descriptor;
+    }
+    getStepName() {
+        return this.stepName;
+    }
+    toStepDescriptor() {
+        var _a;
+        const formatted = JSON.parse(JSON.stringify(this.descriptor));
+        formatted.actionCode = this.actionCode;
+        (_a = formatted.assertions) === null || _a === void 0 ? void 0 : _a.forEach((assertion) => {
+            if (!(0, ConditionDescriptor_1.isComparisonType)(assertion.assertion)) {
+                throw new Error(`Invalid comparison type: ${assertion.assertion}`);
+            }
+        });
+        return formatted;
+    }
+    toMablscript() {
+        return `${this.getActionCode()}(${(0, domUtil_1.buildStepArgumentString)({
+            params: { ...this.descriptor },
+            legacy: true,
+        })})`;
+    }
+    getInputVariables() {
+        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.descriptor);
+    }
+    getOutputVariables() {
+        var _a, _b;
+        return (_b = (_a = this.descriptor.variables) === null || _a === void 0 ? void 0 : _a.map((variable) => variable.name)) !== null && _b !== void 0 ? _b : [];
+    }
+    canContinueOnFailure() {
+        var _a, _b;
+        return (((_b = (_a = this.descriptor.options) === null || _a === void 0 ? void 0 : _a.onFailure) !== null && _b !== void 0 ? _b : AssertStep_1.OnFailure.FailImmediately) !==
+            AssertStep_1.OnFailure.FailImmediately);
+    }
+    canFailAtEnd() {
+        var _a;
+        return ((_a = this.descriptor.options) === null || _a === void 0 ? void 0 : _a.onFailure) === AssertStep_1.OnFailure.FailTestAtEnd;
+    }
+}
+exports.AbstractAssertionsAndVariablesStep = AbstractAssertionsAndVariablesStep;

package/mablscript/steps/AccessibilityCheck.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessibilityCheckStep = exports.AccessibilityCheckSeverity = void 0;
+const MablStep_1 = require("../MablStep");
+const FindAction_1 = require("../actions/FindAction");
+const ActionsUtils_1 = require("./ActionsUtils");
+const domUtil_1 = require("../../domUtil");
+var AccessibilityCheckSeverity;
+(function (AccessibilityCheckSeverity) {
+    AccessibilityCheckSeverity["Critical"] = "critical";
+    AccessibilityCheckSeverity["Minor"] = "minor";
+    AccessibilityCheckSeverity["Moderate"] = "moderate";
+    AccessibilityCheckSeverity["Serious"] = "serious";
+})(AccessibilityCheckSeverity || (exports.AccessibilityCheckSeverity = AccessibilityCheckSeverity = {}));
+class AccessibilityCheckStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'accessibility_check');
+        if (this.actions.length) {
+            this.findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(this.actions);
+        }
+        this.checkConfig = this.getActionArgs()[0];
+    }
+    canContinueOnFailure() {
+        return true;
+    }
+    getStepName() {
+        return AccessibilityCheckStep.yamlMablScriptNames[0];
+    }
+    toStepDescriptor() {
+        if (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_ONE:
+                    return {
+                        ...this.checkConfig,
+                        find,
+                        descriptorToActionMap: new Map().set(find, this),
+                        actionCode: this.actionCode,
+                    };
+                default:
+                    throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
+            }
+        }
+        return {
+            actionCode: this.actionCode,
+            ...this.checkConfig,
+        };
+    }
+    getFormattedStep(_fullLocatorsOn) {
+        let finalStep;
+        if (this.findAction) {
+            finalStep = {
+                AccessibilityCheck: {
+                    ...super.annotationsAsYml(),
+                    ...this.findAction.toYaml(),
+                    ...this.checkConfig,
+                },
+            };
+        }
+        else {
+            finalStep = {
+                AccessibilityCheck: {
+                    ...super.annotationsAsYml(),
+                    ...this.checkConfig,
+                },
+            };
+        }
+        if (this.stepId()) {
+            finalStep.AccessibilityCheck.id = this.stepId();
+        }
+        return finalStep;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const actions = [];
+        if (stepArgs.selector) {
+            actions.push(FindAction_1.FindAction.findActionFromStepArgs(stepArgs));
+        }
+        const checkConfig = {
+            tags: stepArgs.tags,
+            rules: stepArgs.rules,
+            disabledRules: stepArgs.disabledRules,
+            failOn: stepArgs.failOn,
+        };
+        const step = new AccessibilityCheckStep(AccessibilityCheckStep.mablScriptStepNames[0], [checkConfig], actions);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        var _a, _b, _c;
+        let argString = '';
+        if (((_a = this.checkConfig) === null || _a === void 0 ? void 0 : _a.tags) ||
+            ((_b = this.checkConfig) === null || _b === void 0 ? void 0 : _b.disabledRules) ||
+            ((_c = this.checkConfig) === null || _c === void 0 ? void 0 : _c.rules)) {
+            argString = `{${(0, MablStep_1.buildObjectString)(this.checkConfig)}}`;
+        }
+        let findAction = '';
+        if (this.findAction) {
+            findAction = `${this.findAction.toMablscript()}.`;
+        }
+        return `${findAction}${AccessibilityCheckStep.mablScriptStepNames[0]}(${argString})`;
+    }
+}
+exports.AccessibilityCheckStep = AccessibilityCheckStep;
+AccessibilityCheckStep.mablScriptStepNames = ['accessibility_check'];
+AccessibilityCheckStep.yamlMablScriptNames = ['AccessibilityCheck'];

package/mablscript/steps/ActionsUtils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionsUtils = void 0;
+const FindAction_1 = require("../actions/FindAction");
+var ActionsUtils;
+(function (ActionsUtils) {
+    function validateSingleFindAction(actions) {
+        if (actions.length !== 1) {
+            throw new Error('Expected only one action argument.');
+        }
+        const action = actions[0];
+        if (action instanceof FindAction_1.FindAction) {
+            return action;
+        }
+        throw new Error('The action must be a FindAction.');
+    }
+    ActionsUtils.validateSingleFindAction = validateSingleFindAction;
+})(ActionsUtils || (exports.ActionsUtils = ActionsUtils = {}));