itemengine-cypress-automation 1.0.340 → 1.0.341

package/cypress/pages/components/fillInTheGapsTextCommonComponent.js

@@ -1715,72 +1715,6 @@ const tests = {
             fillInTheGapsTextCommonComponent.steps.verifyAnswerInputFieldPlaceholderTextPreviewTab(1, 'Global placeholder');
         });
     },
-
-     //TODO need to remove once Save as you go is available for all questions
-    /**
-     * @description Verifies the behavior of the 'Add alternative answer' button, warning popups, and validation error messages
-     * in the 'Specify correct answer' section for alternative answers in auto-scored questions.
-     * @param {string|null} questionType - The type of the question (e.g., 'list ordering'). Pass `null` if not applicable.
-     * @example - verifyAutoScoredAddAlternativeAnswerButtonAndValidation();
-     */
-    verifyAutoScoredAddAlternativeAnswerButtonAndValidation: (questionType = null) => {
-        it('\'+ Add alternative answer\' button should be present', () => {
-            utilities.verifyInnerText(autoScoredSpecifyCorrectAnswerSection.alternativeAnswerButton(), 'Add alternative answer');
-            utilities.verifyElementVisibilityState(autoScoredSpecifyCorrectAnswerSection.alternativeAnswerButton(), 'visible');
-            autoScoredSpecifyCorrectAnswerSection.alternativeAnswerButton()
-                .verifyPseudoClassBeforeProperty('content', '""');
-        });
-
-        it('CSS of \'Add Alternative answer\' button', { tags: 'css' }, () => {
-            utilities.verifyCSS(autoScoredSpecifyCorrectAnswerSection.alternativeAnswerButton().find('p'), {
-                'color': css.color.activeButtons,
-                'font-size': css.fontSize.default,
-                'font-weight': css.fontWeight.regular
-            });
-            autoScoredSpecifyCorrectAnswerSection.alternativeAnswerButton()
-                .verifyPseudoClassBeforeProperty('color', css.color.activeButtons);
-        });
-
-        it('If user has not selected correct answer in the correct accordion, then the Add alternative answer button should be in enabled state', () => {
-            utilities.verifyElementNotDisabled(autoScoredSpecifyCorrectAnswerSection.alternativeAnswerButton());
-            autoScoredSpecifyCorrectAnswerSection.steps.clickOnAddAlternativeAnswerButton();
-        });
-
-        it('CSS of warning popup', { tags: 'css' }, () => {
-            utilities.verifyCSS(dialogBoxBase.dialogBoxTitle(), {
-                'color': css.color.flyoutTitle,
-                'font-size': css.fontSize.heading,
-                'font-weight': css.fontWeight.semibold
-            });
-            utilities.verifyCSS(dialogBoxBase.dialogBoxContent(), {
-                'color': css.color.labels,
-                'font-size': css.fontSize.default,
-                'font-weight': css.fontWeight.regular
-            });
-            utilities.verifyCSS(dialogBoxBase.buttonClose().find('svg'), {
-                'fill': css.color.closeIcon
-            });
-        });
-
-        it('Accessibility of warning popup', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(dialogBoxBase.dialogBox());
-            dialogBoxBase.steps.closeWarningPopup();
-        });
-    },
-
-    //TODO need to remove once Save as you go is available for all questions
-    verifyWarningPopupAndAccordionNavigationWhenNoPointsAddedInAlternativeAccordion: () => {
-        it('When user tries to expand correct accordion when all the mandatory fields are not filled in the alternative accordion, then a warning popup should be displayed and on closing the popup, alternative 2 accordion should be in expanded state', () => {
-            autoScoredSpecifyCorrectAnswerSection.correctAnswerAccordion()
-                .click();
-            dialogBoxBase.steps.closeWarningPopup();
-            //TODO: Need to add error message according to question types
-            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'exist');
-            autoScoredSpecifyCorrectAnswerSection.alternativeAnswerAccordion()
-                .eq(1)
-                .should('have.attr', 'aria-expanded', 'true');
-        });
-    },
 }
 
 export const fillInTheGapsTextCommonComponent = {

package/cypress/pages/components/hideExpressionListComponent.js

@@ -0,0 +1,53 @@
+import utilities from "../../support/helpers/utilities";
+const css = Cypress.env('css');
+
+const selectors = {
+    hideExpressionListLabel: () => cy.get('[data-ngie-testid="hide-expression-list-checkbox"] .MuiFormControlLabel-label'),
+    hideExpressionListCheckbox: () => cy.get('[data-ngie-testid="hide-expression-list-checkbox"] input'),
+}
+
+const steps = {
+    verifyHideExpressionListCheckboxUnchecked: () => {
+        hideExpressionListComponent.hideExpressionListCheckbox()
+            .should('not.be.checked');
+    },
+    checkHideExpressionListCheckbox: () => {
+        hideExpressionListComponent.hideExpressionListCheckbox()
+            .click()
+            .should('be.checked');
+    },
+}
+const tests = {
+    verifyHideExpressionList: () => {
+        it('\'Hide expression list\' label and checkbox should be displayed and by default it should be unchecked', () => {
+            utilities.verifyInnerText(hideExpressionListComponent.hideExpressionListLabel(), 'Hide expression list');
+            utilities.verifyElementVisibilityState(hideExpressionListComponent.hideExpressionListLabel(), 'visible');
+            hideExpressionListComponent.steps.verifyHideExpressionListCheckboxUnchecked();
+        });
+
+        it('User should be able to check the \'Hide expression list\' checkbox', () => {
+            hideExpressionListComponent.steps.checkHideExpressionListCheckbox();
+        });
+
+        it('CSS of hide expression list checkbox and label', { tags: 'css' }, () => {
+            utilities.verifyCSS(hideExpressionListComponent.hideExpressionListLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(hideExpressionListComponent.hideExpressionListCheckbox().parents('[data-ngie-testid="hide-expression-list-checkbox"]').find('svg g').eq(1), {
+                'fill': css.color.primaryBtnBg
+            });
+        });
+
+        it('Accessibility of hide expression list', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(hideExpressionListComponent.hideExpressionListCheckbox().parents('[data-ngie-testid="hide-expression-list-checkbox"]'))
+        });
+    }
+}
+
+export const hideExpressionListComponent = {
+    ...selectors,
+    steps,
+    tests
+}

package/cypress/pages/components/index.js

@@ -69,3 +69,4 @@ export * from './draggableOptionsStyleAndLayoutComponent';
 export * from './connectorStyleStyleAndLayoutCustomizationComponent';
 export * from './equationEditorSectionCommonComponent';
 export * from './ckEditorAudioPlayerComponent';
+export * from './hideExpressionListComponent';

package/cypress/pages/components/optionsWrapperComponent.js

@@ -78,7 +78,7 @@ const steps = {
             .eq(index)
             .within(() => {
                 commonComponents.errorMessage()
-                    .should('have.text', 'Error: Option is required.');
+                    .should('not.exist');
             });
     },
 

package/cypress/pages/desmos3DGraphingPage.js

@@ -0,0 +1,368 @@
+import utilities from "../support/helpers/utilities";
+import { commonComponents, createQuestionBasePage, questionInstructionsComponent, additionalSettingsPanel, scoringSectionBaseEditTab, additionalSettingsAccessibilitySectionComponent, studentViewSettingsLabelComponent, hideExpressionListComponent } from "./components";
+import { desmosToolComponent } from "./components/desmosToolComponent";
+const css = Cypress.env('css');
+
+const selectors = {
+    ...desmosToolComponent,
+    ...scoringSectionBaseEditTab,
+    ...commonComponents,
+    ...additionalSettingsPanel,
+    ...questionInstructionsComponent,
+    desmosGraphingTool: () => cy.get('[id*="desmos-graph-tool"]'),
+    desmosGraphingToolExpressionPanel: () => cy.get('[id*="desmos-graph-tool"] .dcg-exppanel-container.dcg-add-shadow'),
+    studentViewSettingsLabel: () => cy.get('[class*="StudentViewWrapper"]'),
+    hideExpressionListLabel: () => cy.get('[data-ngie-testid="hide-expression-list-checkbox"] .MuiFormControlLabel-label'),
+    hideExpressionListCheckbox: () => cy.get('[data-ngie-testid="hide-expression-list-checkbox"] input'),
+    showHideListButton: () => cy.get('.dcg-show-expressions-tab[role="button"]'),
+    desmosGraphingWidthLabel: () => cy.get('[class*="LabelInputWrapper"]').eq(0),
+    desmosGraphingWidthInputField: () => cy.get('[class*="DimensionInputWrapper"] input').eq(0),
+    desmosGraphingHeightLabel: () => cy.get('[class*="LabelInputWrapper"]').eq(1),
+    desmosGraphingHeightInputField: () => cy.get('[class*="DimensionInputWrapper"] input').eq(1),
+    desmosGraphingExpressionPreviewTab: () => cy.get('.edit-question-preview-wrapper .dcg-expressionlist .dcg-main .dcg-mathquill-wrapper'),
+    desmosGraphingOutput: () => cy.get('.dcg-evaluation-container .dcg-typeset-math .dcg-mq-mathspeak').eq(1),
+    buttonAspectRatio: () => cy.get('[class*="LockIconWrapper"] button'),
+    buttonResetDimensions: () => cy.get('[class*="ResetIconWrapper"] button'),
+    specifyPredefinedExpressionLabel: () => cy.get('.label-wrapper'),
+    addExpressionButton: () => cy.get('.dcg-add-expression-btn:visible'),
+    expressionListNewFolderOption: () => cy.get('.dcg-action-newfolder'),
+    folderInExpressionList: () => cy.get('.dcg-expressionfolder'),
+    accessibilityLabel: () => cy.get('[class*="Accessibilitystyles__AccessibilityLabelWrapper"]'),
+    flagNonAccessibleCheckbox: () => cy.get('[data-ngie-testid="response-option-checkbox"] input'),
+    flagNonAccessibleLabel: () => cy.get('[data-ngie-testid="response-option-checkbox"] .MuiFormControlLabel-label'),
+    widthInputField: () => cy.get('[class*="StudentViewSettingsstyles__DimensionWrapper"] .text-input-field input').eq(0),
+    heightInputField: () => cy.get('[class*="StudentViewSettingsstyles__DimensionWrapper"] .text-input-field input').eq(1),
+    insertResourceLinkLabel: () => cy.get('.label-wrapper'),
+    insertResourceLinkInputField: () => cy.get('.additional-option-placeholder-input .MuiOutlinedInput-input'),
+    httpsLabel: () => cy.get('.start-adornment'),
+    errorMessage: () => cy.get('.error-text-message'),
+    resourceLinkPreviewTitle: () => cy.get('[class*="DesmosGraphingstyles__ResourceLinkPreviewLabel"]'),
+    desmosComponent: () => cy.get('[class*="DesmosGraphingstyles__DesmosComponentWrapper"]'),
+}
+
+const steps = {
+    ...desmosToolComponent.steps,
+    ...createQuestionBasePage.steps,
+    ...scoringSectionBaseEditTab.steps,
+    ...additionalSettingsPanel.steps,
+    ...questionInstructionsComponent.steps,
+    ...commonComponents.steps,
+    verifyHideExpressionListCheckboxUnchecked: () => {
+        desmos3DGraphingPage.hideExpressionListCheckbox()
+            .should('not.be.checked');
+    },
+
+    checkHideExpressionListCheckbox: () => {
+        desmos3DGraphingPage.hideExpressionListCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    uncheckHideExpressionListCheckbox: () => {
+        desmos3DGraphingPage.hideExpressionListCheckbox()
+            .click()
+            .should('not.be.checked');
+    },
+
+    verifyExpressionListPanelVisible: () => {
+        utilities.verifyElementVisibilityState(desmos3DGraphingPage.desmosGraphingToolExpressionPanel(), 'visible');
+    },
+
+    verifyPreviewTabExpressionListPanelVisible: () => {
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                utilities.verifyElementVisibilityState(desmos3DGraphingPage.desmosGraphingToolExpressionPanel(), 'visible');
+            });
+    },
+
+    verifyPreviewTabExpressionListPanelHidden: () => {
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                desmos3DGraphingPage.desmosGraphingToolExpressionPanel()
+                    .should('not.exist');
+            });
+    },
+
+    showHideList: () => {
+        desmos3DGraphingPage.showHideListButton()
+            .click();
+    },
+
+    verifyDesmosGraphingWidthInputField: (width) => {
+        desmos3DGraphingPage.desmosGraphingWidthInputField()
+            .should('have.value', width);
+    },
+
+    verifyDesmosGraphingHeightInputField: (height) => {
+        desmos3DGraphingPage.desmosGraphingHeightInputField()
+            .should('have.value', height);
+    },
+
+    /**
+    * @param {number} width value to enter in width input field
+    * @description this function enters value in width input field
+    */
+    enterInputInDesmosGraphingWidthInputField: (width) => {
+        desmos3DGraphingPage.desmosGraphingWidthInputField()
+            .clear()
+            .type(width)
+            .should('have.value', width);
+    },
+
+    /**
+    * @param {number} height value to enter in height input field
+    * @description this function enters value in height input field
+    */
+    enterInputInDesmosGraphingHeightInputField: (height) => {
+        desmos3DGraphingPage.desmosGraphingHeightInputField()
+            .clear()
+            .type(height)
+            .should('have.value', height);
+    },
+
+    /**
+     * @description this function locks aspect ratio
+     */
+    lockAspectRatio: () => {
+        desmos3DGraphingPage.buttonAspectRatio()
+            .click();
+        steps.verifyButtonAspectRatioLocked();
+    },
+
+    /**
+     * @description this function unlocks aspect ratio
+     */
+    unlockAspectRatio: () => {
+        desmos3DGraphingPage.buttonAspectRatio()
+            .click();
+        steps.verifyButtonAspectRatioUnlocked();
+    },
+
+    /**
+     * @description this function verifies aspect ratio is locked
+     */
+    verifyButtonAspectRatioLocked: () => {
+        desmos3DGraphingPage.buttonAspectRatio()
+            .should('have.attr', 'aria-label', 'Locked aspect ratio')
+    },
+
+    /**
+    * @description this function verifies aspect ratio is unlocked
+    */
+    verifyButtonAspectRatioUnlocked: () => {
+        desmos3DGraphingPage.buttonAspectRatio()
+            .should('have.attr', 'aria-label', 'Unlocked aspect ratio')
+    },
+    /**
+    * @description this function verifies aspect ratio is disabled
+    */
+    verifyButtonAspectRatioDisabled: () => {
+        desmos3DGraphingPage.buttonAspectRatio()
+            .should('be.disabled')
+    },
+
+    /**
+    * @description this function verifies the reset dimensions button is disabled
+    */
+    verifyButtonResetDimensionsDisabled: () => {
+        desmos3DGraphingPage.buttonResetDimensions()
+            .should('be.disabled');
+    },
+
+    /**
+    * @description this function verifies the reset dimensions button is enabled
+    */
+    verifyButtonResetDimensionsEnabled: () => {
+        desmos3DGraphingPage.buttonResetDimensions()
+            .should('be.enabled');
+    },
+
+    /**
+    * @description this function resets dimensions
+    */
+    resetDimensions: () => {
+        desmos3DGraphingPage.buttonResetDimensions()
+            .click();
+    },
+
+    verifyDesmosGraphingDimensions: (width, height) => {
+        desmos3DGraphingPage.desmosGraphingTool()
+            .should('have.css', 'width', width)
+            .and('have.css', 'height', height);
+    },
+
+    verifyPreviewTabDesmosGraphingDimensions: (width, height) => {
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                desmos3DGraphingPage.desmosGraphingTool()
+                    .should('have.css', 'width', `${width}px`)
+                    .and('have.css', 'height', `${height}px`);
+            });
+    },
+
+    addExpression: () => {
+        desmos3DGraphingPage.addExpressionButton()
+            .click();
+    },
+
+    selectNewFolderOptionFromExpressionList: () => {
+        desmos3DGraphingPage.expressionListNewFolderOption()
+            .click();
+    },
+
+    addFolderInPreviewTabExpressionList: () => {
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                steps.addExpression();
+                steps.selectNewFolderOptionFromExpressionList();
+            });
+    },
+
+    verifyDesmosGraphingOutput: (output) => {
+        utilities.verifyInnerText(desmos3DGraphingPage.desmosGraphingOutput(), output);
+    },
+
+    verifyPreviewTabDesmosGraphingOutput: (output) => {
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                utilities.verifyInnerText(desmos3DGraphingPage.desmosGraphingOutput(), output);
+            });
+    },
+
+    verifyFolderInExpressionListVisible: () => {
+        utilities.verifyElementVisibilityState(desmos3DGraphingPage.folderInExpressionList(), 'notExist');
+    },
+
+    verifyFlagThisItemNonAccessibleCheckboxIsUnchecked: () => {
+        desmos3DGraphingPage.flagNonAccessibleCheckbox()
+            .should('not.be.checked');
+    },
+
+    checkFlagThisItemNonAccessibleCheckbox: () => {
+        desmos3DGraphingPage.flagNonAccessibleCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    verifyInputInPreviewTabTextAreaField: (inputText) => {
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                utilities.verifyInnerText(desmosToolComponent.previewTabDesmosTextArea(), inputText);
+            });
+    },
+    /**
+         * @param {number} width holds value of width attribute
+         * @description function updates width in input field
+         */
+    updateWidth: (width) => {
+        desmos3DGraphingPage.widthInputField()
+            .clear()
+            .type(width);
+    },
+    /**
+         * @param {number} width holds value of width attribute
+         * @description function verifies width in input field
+         */
+    verifyWidth: (width) => {
+        desmos3DGraphingPage.widthInputField()
+            .should('have.value', width);
+    },
+    /**
+         * @param {number} height holds value of height attribute
+         * @description function updates height in input field
+         */
+    updateHeight: (height) => {
+        desmos3DGraphingPage.heightInputField()
+            .clear()
+            .type(height);
+    },
+    /**
+         * @param {number} height holds value of height attribute
+         * @description function verifies height in input field
+         */
+    verifyHeight: (height) => {
+        desmos3DGraphingPage.heightInputField()
+            .should('have.value', height);
+    },
+    /**
+         * @param {number} width holds value of width attribute
+         * @description function verifies width property in image
+         */
+    verifyUpdatedWidthOfImage: (width) => {
+        rulerPage.widthInputField()
+            .should('have.attr', 'width', width)
+    },
+    /**
+     * @param {number} height holds value of height attribute
+     * @description function verifies height property in image
+     */
+    verifyUpdatedHeightOfImage: (height) => {
+        rulerPage.uploadedImagePreview()
+            .find('img')
+            .should('have.attr', 'height', height)
+    },
+    verifyInsertResourceLinkPlaceholderText: () => {
+        desmos3DGraphingPage.insertResourceLinkInputField()
+            .should('have.attr', 'placeholder', 'www.desmos.com/');
+    },
+    /**
+ * @description add desmos 3D Link to insert resource link input field
+ * @param {string} inputURL 
+ */
+    addInputToInsertResourceLinkInputField: (inputURL) => {
+        desmos3DGraphingPage.insertResourceLinkInputField()
+            .focus()
+            .clear()
+            .type(`${inputURL}`);
+        utilities.hoverAwayFromElement();
+    },
+    verifyInsertResourceLinkPlaceholderTextNotDisplayed: () => {
+        desmos3DGraphingPage.insertResourceLinkInputField()
+            .should('not.have.attr', 'placeholder');
+    },
+    clearInputToInsertResourceLinkInputField: () => {
+        desmos3DGraphingPage.insertResourceLinkInputField()
+            .clear();
+        cy.get('body')
+            .click();
+    },
+}
+
+const tests = {
+    ...createQuestionBasePage.tests,
+    ...questionInstructionsComponent.tests,
+    ...scoringSectionBaseEditTab.tests,
+    ...additionalSettingsPanel.tests,
+    ...commonComponents.tests,
+    ...additionalSettingsAccessibilitySectionComponent.tests,
+    ...studentViewSettingsLabelComponent.tests,
+    ...hideExpressionListComponent.tests,
+    
+    verifyGraphingQuestionSpecifyPredefinedExpressionContent: () => {
+        it('When user selects a scoring type the contents of the Specify predefined expression should be displayed', () => {
+            utilities.verifyElementVisibilityState(desmos3DGraphingPage.desmosGraphingTool(), 'exist');
+            utilities.verifyElementVisibilityState(desmos3DGraphingPage.previewTabDesmosToolGraph(), 'exist');
+            utilities.verifyElementVisibilityState(desmosToolComponent.previewTabDesmosToolKeypadButton(), 'exist');
+        });
+    },
+
+    verifyErrorMessageCSSAndA11y: () => {
+        it('CSS of error message', { tags: 'css' }, () => {
+            utilities.verifyCSS(desmos3DGraphingPage.errorMessage(), {
+                'color': css.color.desmosErrorText,
+                'font-size': css.fontSize.small,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('Accessibility of error message', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(commonComponents.nextGenCreateItemWrapper());
+        });
+    }
+}
+
+export const desmos3DGraphingPage = {
+    ...selectors,
+    steps,
+    tests
+}