itemengine-cypress-automation 1.0.198-drawingResponseEnumUpdate-1aa98cf.0 → 1.0.198

package/cypress/pages/listOrderingPage.js

@@ -1,6 +1,6 @@
 import constants from "../fixtures/constants";
 import utilities from "../support/helpers/utilities";
-import { autoScoredScoringPreviewTab, autoScoredScoringSectionMultiResponseType, autoScoredSpecifyCorrectAnswerSection, autoScoredStudentViewSettings, commonComponents, correctIncorrectAnswerLabelComponent, createQuestionBasePage, optionsWrapperComponent, questionInstructionsComponent, randomizeOptionsComponent, scoringSectionBaseEditTab, studentViewSettingsLabelComponent, additionalSettingsPanel, additionalSettingsAccessibilitySectionComponent } from "./components"
+import { autoScoredScoringPreviewTab, autoScoredScoringSectionMultiResponseType, autoScoredSpecifyCorrectAnswerSection, autoScoredStudentViewSettings, commonComponents, correctIncorrectAnswerLabelComponent, createQuestionBasePage, optionsWrapperComponent, questionInstructionsComponent, randomizeOptionsComponent, scoringSectionBaseEditTab, studentViewSettingsLabelComponent, additionalSettingsPanel, additionalSettingsAccessibilitySectionComponent, enableOuterBorderComponent } from "./components"
 const options = ['sprout', 'plant', 'flower', 'seed'];
 const css = Cypress.env('css');
 
@@ -14,21 +14,21 @@ const selectors = {
     ...additionalSettingsPanel,
     ...correctIncorrectAnswerLabelComponent,
     ...autoScoredSpecifyCorrectAnswerSection,
+    ...enableOuterBorderComponent,
     //Specify correct answer section
     optionSpecifyCorrectAnswerSection: () => cy.get('.list-ordering-set-correct-answer .draggable-item-wrapper[role="button"]'),
     optionWrapperSpecifyCorrectAnswerSection: () => cy.get('[class*="ListOrderingResponsestyles__DroppableWrapper"]'),
     partialDifferentWeightsPointsLabel: () => cy.get('.partial-points-per-response-label'),
     pointsPerResponseValue: () => cy.get('.alternate-points-points-per-value-span'),
-    //Student view settings
-    enableOuterBorderForQuestionLabel: () => cy.get('[data-ngie-testid*="enable-outer-border-for-question-checkbox"] .MuiFormControlLabel-label'),
-    enableOuterBorderForQuestionCheckbox: () => cy.get('[data-ngie-testid*="enable-outer-border-for-question-checkbox"] input'),
+    draggableOptionDragIcon: () => cy.get('.drag-indicator-icon'),
     //Preview Tab
     optionPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .draggable-item-wrapper[role="button"]'),
     optionWrapperPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .orderlist-option-wrapper'),
-    correctAnswersLabel: () => cy.get('.check-answer-and-status-wrapper [class*="CorrectAnswerLabel"]'),
+    correctAnswersLabel: () => cy.get('[class*="CorrectAnswerstyles__CorrectAnswerLabel"]'),
     correctAnswerSectionAnswerWrapper: () => cy.get('[class*="CorrectAnswers"] [class*="__OptionsWrapper"]'),
     correctAnswerSectionWrapper: () => cy.get('[class*="ListOrderingResponsestyles__CorrectAnswers"]'),
     correctAnswerSectionAnswerText: () => cy.get('.question-text-wrapper'),
+    correctAnswerSectionIconWrapper: () => cy.get('[class*="CorrectAnswerstyles__IconWrapper"]'),
     questionBorderPreviewTab: () => cy.get('[class*="ListOrderingResponsestyles__DroppableDiv"]'),
     //grading view and correct answer view
     optionGradingView: () => cy.get('[class*="DraggableItemsWrapper"] [class*="OptionTextWrapper"]'),
@@ -68,7 +68,16 @@ const selectors = {
     positionDropdownPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .response-dropdown-wrapper [role="combobox"]'),
     positionDropdownCorrectAnswerSection: () => cy.get('[class*="ListOrderingResponsestyles__CorrectAnswers"] .response-dropdown-wrapper [role="combobox"]'),
     dropdownWrapperCorrectAnswerSection: () => cy.get('[class*="ListOrderingResponsestyles__CorrectAnswers"] [class*="DropdownLayoutstyles__ResponseWrapper"]'),
-    alertMessage: () => cy.get('[class*="ListOrderingResponsestyles__DisabledWrapper"]')
+    alertMessage: () => cy.get('[class*="ListOrderingResponsestyles__DisabledWrapper"]'),
+
+    //horizontal orientation
+    horizontalOptionSpecifyCorrectAnswerSection: () => cy.get('.horizontal-drag-item-wrapper'),
+    horizontalOptionPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .horizontal-drag-item-wrapper'),
+
+    //set points popup
+    setPointsButton: () => cy.get('.list-ordering-set-correct-answer button'),
+    optionWrapperSetPointsPopup: () => cy.get('[class*="OptionContainerstyle__OptionsWrapper"]'),
+    pointsLabelSetPointsPopup: () => cy.get('.dialog-content [class*="PointsLabel-"]')
 }
 
 const steps = {
@@ -84,6 +93,7 @@ const steps = {
     ...randomizeOptionsComponent.steps,
     ...commonComponents.steps,
     ...additionalSettingsPanel.steps,
+    ...enableOuterBorderComponent.steps,
     /**
      * @param {string} optionsText text content of the option
      * @param {number} targetIndex the position at which the options is being dropped
@@ -345,28 +355,6 @@ const steps = {
             .and('match', /0px none/);
     },
 
-    verifyEnableOuterBorderForQuestionCheckboxCheckedState: () => {
-        listOrderingPage.enableOuterBorderForQuestionCheckbox()
-            .should('be.checked');
-    },
-
-    verifyEnableOuterBorderForQuestionCheckboxUncheckedState: () => {
-        listOrderingPage.enableOuterBorderForQuestionCheckbox()
-            .should('not.be.checked');
-    },
-
-    checkEnableOuterBorderForQuestionCheckbox: () => {
-        listOrderingPage.enableOuterBorderForQuestionCheckbox()
-            .click()
-            .should('be.checked');
-    },
-
-    uncheckEnableOuterBorderForQuestionCheckbox: () => {
-        listOrderingPage.enableOuterBorderForQuestionCheckbox()
-            .click()
-            .should('not.be.checked');
-    },
-
     /**
      * @description Verifies that the image in the Specify Correct Answer section has the correct source and alt text.
      * @param {number} index - The index of the option in the Specify Correct Answer section.
@@ -592,6 +580,26 @@ const steps = {
         utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.dropdownOptionWrapperGradingView(), index), optionsText);
     },
 
+    verifyCorrectOptionIconsDropdownLayoutCorrectAnswersSectionNotExists: () => {
+        listOrderingPage.dropdownWrapperCorrectAnswerSection()
+            .each(($element) => {
+                cy.wrap($element)
+                    .within(() => {
+                        utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'notExist');
+                    })
+            })
+    },
+
+    verifyCorrectOptionIconsDropdownLayoutCorrectAnswersSection: () => {
+        listOrderingPage.dropdownWrapperCorrectAnswerSection()
+            .each(($element) => {
+                cy.wrap($element)
+                    .within(() => {
+                        utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'visible');
+                    })
+            })
+    },
+
     /**
      * @param {string[]} optionsTextArray array of options in the correct answer section
      * @description this function verifies the correct order of options in correct answer section
@@ -724,25 +732,249 @@ const steps = {
             .should('not.have.text', '')
             .and('not.have.text', previousOrderOfOptionsArray.join(''));
     },
+    /**
+     * Selects the orientation option on the list ordering page.
+     * @param {'Vertical' | 'Horizontal'} orientationOption - The orientation option to select.
+     */
+    selectOptionOrientation: (orientationOption) => {
+        switch (orientationOption) {
+            case 'Vertical':
+                listOrderingPage.verticalButton()
+                    .click()
+                    .should('have.class', 'single-select-toggle-button-selected');
+                break;
+            case 'Horizontal':
+                listOrderingPage.horizontalButton()
+                    .click()
+                    .should('have.class', 'single-select-toggle-button-selected');
+                break;
+        }
+    },
 
-    verifyCorrectOptionIconsDropdownLayoutCorrectAnswersSectionNotExists: () => {
-        listOrderingPage.dropdownWrapperCorrectAnswerSection()
-            .each(($element) => {
-                cy.wrap($element)
-                    .within(() => {
-                        utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'notExist');
-                    })
-            })
+    /**
+     * @param {string[]} optionsTextArray options array for set correct answer options
+     * @description this function verifies options text content in the horizontal orientation
+     */
+    verifyTextContentOfHorizontalOptionInSpecifyCorrectAnswerSection: (optionsText, index) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.horizontalOptionSpecifyCorrectAnswerSection(), index), optionsText);
     },
 
-    verifyCorrectOptionIconsDropdownLayoutCorrectAnswersSection: () => {
-        listOrderingPage.dropdownWrapperCorrectAnswerSection()
+    /**
+     * @param {string} optionsText text content of the option
+     * @param {number} targetIndex the position at which the options is being dropped
+     * @description click and drop a option into a position in the specify correct answer section in the horizontal orientation
+     */
+    clickAndReorderHorizontalOptionInSpecifyCorrectAnswerSection: (optionsText, targetIndex) => {
+        listOrderingPage.horizontalOptionSpecifyCorrectAnswerSection()
+            .contains(optionsText)
+            .click();
+        listOrderingPage.horizontalOptionSpecifyCorrectAnswerSection()
+            .eq(targetIndex)
+            .click();
+    },
+
+    /**
+     * @param {string} optionsText text content of the option
+     * @param {number} targetIndex the position at which the options is being dropped
+     * @description click and drop a option into a position in the preview tab in the horizontal orientation
+     */
+    clickAndReorderHorizontalOptionInPreviewTab: (optionsText, targetIndex) => {
+        listOrderingPage.horizontalOptionPreviewTab()
+            .contains(optionsText)
+            .click();
+        listOrderingPage.horizontalOptionPreviewTab()
+            .eq(targetIndex)
+            .click();
+    },
+
+    /**
+     * Verifies the order of options in the "Specify Correct Answer" section.
+     * @param {string[]} optionsTextArray - An array containing the text of options in the expected order for horizontal orientation.
+     */
+    verifyHorizontalOptionsOrderInSpecifyCorrectAnswerSection: (optionsTextArray) => {
+        optionsTextArray.forEach((option, index) => {
+            utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.horizontalOptionSpecifyCorrectAnswerSection(), index), option);
+        });
+    },
+
+    /**
+     * Verifies the order of options in the preview tab
+     * @param {string[]} optionsTextArray - An array containing the text of options in the expected order for horizontal orientation.
+     */
+    verifyHorizontalOptionsOrderInPreviewTab: (optionsTextArray) => {
+        optionsTextArray.forEach((option, index) => {
+            utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.horizontalOptionPreviewTab(), index), option);
+        });
+    },
+
+    getHorizontalOptionsArray: () => {
+        const optionsArray = []
+        listOrderingPage.horizontalOptionPreviewTab()
+            .each(($el) => {
+                cy.wrap($el)
+                    .invoke('text')
+                    .then((text) => {
+                        optionsArray.push(text);
+                    });
+            });
+        return optionsArray;
+    },
+
+    /**
+     * @param {string[]} optionsArray array of options set in the options section 
+     * @description this function verifies if the options are Randomized in the preview tab for horizontal option orientation
+     */
+    verifyRandomizeHorizontalOptionOrder: (optionsArray) => {
+        let currentOptionsArray = [...optionsArray]
+        for (let index = 0; index < currentOptionsArray.length; index++) {
+            listOrderingPage.horizontalOptionPreviewTab()
+                .eq(index)
+                .then(($element) => {
+                    expect($element.text()).to.be.oneOf(currentOptionsArray);
+                    currentOptionsArray = currentOptionsArray.filter((value) => value !== $element.text())
+                });
+        };
+        listOrderingPage.steps.verifyHorizontalOptionsAreReRandomized(optionsArray)
+    },
+
+    /**
+    * @param {string[]} previousOrderOfOptionsArray array of previous order of options
+    * @description this function verifies that the order of the options is different from the previous order for horizontal option orientation
+    */
+    verifyHorizontalOptionsAreReRandomized: (previousOrderOfOptionsArray) => {
+        listOrderingPage.horizontalOptionPreviewTab()
+            .should('not.have.text', '')
+            .and('not.have.text', previousOrderOfOptionsArray.join(''));
+    },
+
+    //Note: Update the below functions when https://redmine.zeuslearning.com/issues/571751 gets resolved
+    /**
+    * @param {string} optionsText option to be checked for the correct icon
+    * @description This function verifies the correct icon in the preview tab for an option in horizontal option orientation
+    */
+    verifyCorrectOptionIconHorizontalOrientation: (optionsText) => {
+        listOrderingPage.horizontalOptionPreviewTab()
+            .contains(optionsText)
+            .parents('[id*="choice"][role]')
+            .prev('.tick-icon-wrapper')
+            .then(($element) => {
+                expect($element[0].className.includes('icon-correct')).to.be.true;
+            });
+    },
+
+    /**
+    * @param {string} optionsText option to be checked for the correct icon
+    * @description This function verifies the correct icon in the preview tab for an option in horizontal option orientation
+    */
+    verifyIncorrectOptionIconHorizontalOrientation: (optionsText) => {
+        listOrderingPage.horizontalOptionPreviewTab()
+            .contains(optionsText)
+            .parents('[id*="choice"][role]')
+            .prev('.tick-icon-wrapper')
+            .then(($element) => {
+                expect($element[0].className.includes('icon-incorrect')).to.be.true;
+            });
+    },
+
+    verifyCorrectOptionIconsCorrectAnswerSection: () => {
+        listOrderingPage.correctAnswerSectionIconWrapper()
             .each(($element) => {
-                cy.wrap($element)
-                    .within(() => {
-                        utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'visible');
-                    })
-            })
+                cy.wrap($element).within(() => {
+                    utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'visible');
+                });
+            });
+    },
+
+    clickOnSetPointsButton: () => {
+        listOrderingPage.setPointsButton()
+            .click()
+    },
+
+    /**
+    * @description Verifies that the image in the Preview tab has the correct source and alt text.
+    * @param {number} optionIndex - The index of the option in the Preview tab.
+    */
+    verifyImageOptionInSetPointsPopup: (optionIndex) => {
+        listOrderingPage.optionWrapperSetPointsPopup()
+            .eq(optionIndex)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    /**
+     * @description Verifies that the bold text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyBoldTextOptionInSetPointsPopup: (optionIndex) => {
+        listOrderingPage.optionWrapperSetPointsPopup()
+            .eq(optionIndex)
+            .find('strong')
+            .should('have.text', 'This is a bold option');
+    },
+
+    /**
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyEquationOptionInSetPointsPopup: (optionIndex) => {
+        listOrderingPage.optionWrapperSetPointsPopup()
+            .eq(optionIndex)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    /**
+     * Verifies the text content of a specified option in the "Set Points" popup.
+     * @param {number} optionIndex - The index of the option to verify (0-based).
+     * @param {string} textContent - The expected text content of the option.
+     */
+    verifyTextContentOfOptionInSetPointsPopup: (optionIndex, textContent) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionWrapperSetPointsPopup(), optionIndex), textContent);
+    },
+
+    /**
+    * @description Verifies that the image in the Preview tab has the correct source and alt text.
+    * @param {number} optionIndex - The index of the option in the Preview tab.
+    */
+    verifyHorizontalOptionWithImageInPreviewTab: (optionIndex) => {
+        listOrderingPage.horizontalOptionPreviewTab()
+            .eq(optionIndex)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    /**
+     * @description Verifies that the bold text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyHorizontalOptionWithBoldTextInPreviewTab: (optionIndex) => {
+        listOrderingPage.horizontalOptionPreviewTab()
+            .eq(optionIndex)
+            .find('strong')
+            .should('have.text', 'This is a bold option');
+    },
+
+    /**
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyHorizontalOptionWithEquationTextInPreviewTab: (optionIndex) => {
+        listOrderingPage.horizontalOptionPreviewTab()
+            .eq(optionIndex)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    /**
+     * @param {string[]} optionsTextArray options array for preview tab options
+     * @description this function verifies options text content
+     */
+    verifyTextContentOfHorizontalOptionInPreviewTab: (optionsText, index) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.horizontalOptionPreviewTab(), index), optionsText);
     }
 }
 
@@ -760,11 +992,13 @@ const tests = {
     ...additionalSettingsPanel.tests,
     ...additionalSettingsAccessibilitySectionComponent.tests,
     ...createQuestionBasePage.tests,
+    ...enableOuterBorderComponent.tests,
     verifyContentsOfSpecifyCorrectAnswerSection: () => {
         it('When user selects a scoring type then in the \'Correct\' accordion, all the contents should be displayed', () => {
             utilities.verifyElementCount(listOrderingPage.optionSpecifyCorrectAnswerSection(), 4);
             options.forEach((optionText, index) => {
                 listOrderingPage.steps.verifyTextContentOfOptionInSpecifyCorrectAnswerSection(optionText, index);
+                utilities.verifyElementVisibilityState(utilities.getNthElement(listOrderingPage.draggableOptionDragIcon(), index * 2), 'visible');
             });
         });
     },
@@ -777,6 +1011,16 @@ const tests = {
             });
         });
     },
+
+    verifyContentsOfSpecifyCorrectAnswerSectionHorizontalOrientation: () => {
+        it('By default, 4 options in horizontal orientation in the specify correct answer section', () => {
+            utilities.verifyElementCount(listOrderingPage.horizontalOptionSpecifyCorrectAnswerSection(), 4);
+            options.forEach((optionText, index) => {
+                listOrderingPage.steps.verifyTextContentOfHorizontalOptionInSpecifyCorrectAnswerSection(optionText, index);
+                utilities.verifyElementVisibilityState(listOrderingPage.draggableOptionDragIcon(), 'visible');
+            });
+        });
+    },
 }
 
 export const listOrderingPage = {

package/cypress/pages/textSelectionPage.js

@@ -1,6 +1,6 @@
 import constants from "../fixtures/constants";
 import utilities from "../support/helpers/utilities";
-import { createQuestionBasePage, autoScoredScoringPreviewTab, scoringSectionBaseEditTab, questionInputFieldComponent, questionInstructionsComponent, autoScoredStudentViewSettings, correctIncorrectAnswerLabelComponent, autoScoredSpecifyCorrectAnswerSection, autoScoredScoringSectionMultiResponseType, setPointsPopupBase, commonComponents, ckEditorToolbar, equationEditorFlyout, studentViewSettingsLabelComponent, enableOuterBorderComponent, additionalSettingsPanel, additionalSettingsAccessibilitySectionComponent, styleAndLayoutCustomizationAccordionComponent, colorPopupComponent } from "./components";
+import { createQuestionBasePage, autoScoredScoringPreviewTab, scoringSectionBaseEditTab, questionInputFieldComponent, questionInstructionsComponent, autoScoredStudentViewSettings, correctIncorrectAnswerLabelComponent, autoScoredSpecifyCorrectAnswerSection, autoScoredScoringSectionMultiResponseType, setPointsPopupBase, commonComponents, ckEditorToolbar, equationEditorFlyout, studentViewSettingsLabelComponent, enableOuterBorderComponent, additionalSettingsPanel, additionalSettingsAccessibilitySectionComponent, styleAndLayoutCustomizationAccordionComponent, colorPopupComponent, showAvailableOptionsToStudents, showStudentMaximumNumberOfPossibleSelections } from "./components";
 import { dialogBoxBase } from "./dialogBoxBase";
 const css = Cypress.env('css');
 const colorLibrary = css.textSelectionColorLibrary;
@@ -17,6 +17,8 @@ const selectors = {
     ...additionalSettingsPanel,
     ...correctIncorrectAnswerLabelComponent,
     ...colorPopupComponent,
+    ...showAvailableOptionsToStudents,
+    ...showStudentMaximumNumberOfPossibleSelections,
     questionLabel: () => cy.get('[class*="Highlightstyles__QuestionComponentWrapper"] .title-casing'),
     questionInputField: () => cy.get('[class*="Highlightstyles__QuestionComponentWrapper"] [title="Question"]'),
     specifyPossibleOptionsTextFieldWrapper: () => cy.get('[class*="Highlightstyles__HighLightWrapper"] .question-text-wrapper'),
@@ -52,20 +54,8 @@ const selectors = {
     specifyCorrectAnswerTextParagraphs: () => cy.get('[class*="Highlightstyles__Wrapper"] p'),
     optionSpecifyCorrectAnswer: () => cy.get('[class*="Highlightstyles__Wrapper"] .highlighted'),
     setPointsButton: () => cy.get('[class*="SetPointsPopupWrapper"] button'),
-    maximumOptionsCanBeSelectedErrorMessage: () => cy.get('[class*="Highlightstyles__AuthoringErrorMsg"]'),
-    maximumOptionsCanBeSelectedErrorMessagePreviewTab: () => cy.get('[class*="Highlightstyles__ErrorMessage"]'),
-    maximumOptionsCanBeSelectedErrorMessageWrapperPreviewTab: () => cy.get('.preview-selection-limit-error-wrapper'),
     partialEqualWeightsPointsPerResponseScore: () => cy.get('[class*="Highlightstyles__PartialPointsPerResponseValue"]'),
     specifyCorrectAnswerErrorMessage: () => cy.get('[class*="ErrorMessageContainer"]').eq(1),
-    //Student view settings
-    showAvailableOptionsToStudentsLabel: () => cy.get('[data-ngie-testid="show-the-available-options-to-students-checkbox"] [class*="label"]'),
-    showAvailableOptionsToStudentsCheckbox: () => cy.get('[data-ngie-testid="show-the-available-options-to-students-checkbox"] input'),
-    maxNumberOfPossibleSelectionsLabel: () => cy.get('#Maximum-number-of-possible-selections-dropdown-label'),
-    maxNumberOfPossibleSelectionsDropdown: () => cy.get('#Maximum-number-of-possible-selections-select'),
-    showStudentMaximumNumberOfPossibleSelectionsCheckbox: () => cy.get('[data-ngie-testid="show-student-the-maximum-number-of-possible-selections-checkbox"] input'),
-    showStudentMaximumNumberOfPossibleSelectionsLabel: () => cy.get('[data-ngie-testid="show-student-the-maximum-number-of-possible-selections-checkbox"] [class*="label"]'),
-    maximumNumberOfSelectionsHelpText: () => cy.get('[class*="Highlightstyles__LimitWrapper"]'),
-
     //Style and customization layout
     filledInStyleLabel: () => cy.get('.text-selection-style-title'),
     fillColorLabel: () => cy.get('[class*="StyleAndLayoutCustomizationstyles__SubSectionLabel"]'),
@@ -106,6 +96,8 @@ const steps = {
     ...additionalSettingsPanel.steps,
     ...styleAndLayoutCustomizationAccordionComponent.steps,
     ...colorPopupComponent.steps,
+    ...showAvailableOptionsToStudents.steps,
+    ...showStudentMaximumNumberOfPossibleSelections.steps,
     addInputToQuestionInputField: (text) => {
         textSelectionPage.questionInputField()
             .type(text);
@@ -899,64 +891,6 @@ const steps = {
         });
     },
 
-    verifyShowAvailableOptionsToStudentsCheckboxIsUnchecked: () => {
-        textSelectionPage.showAvailableOptionsToStudentsCheckbox()
-            .should('not.be.checked');
-    },
-
-    verifyShowAvailableOptionsToStudentsCheckboxIsChecked: () => {
-        textSelectionPage.showAvailableOptionsToStudentsCheckbox()
-            .should('be.checked');
-    },
-
-    uncheckShowAvailableOptionsToStudentsCheckbox: () => {
-        textSelectionPage.showAvailableOptionsToStudentsCheckbox()
-            .click()
-            .should('not.be.checked');
-    },
-
-    checkShowAvailableOptionsToStudentsCheckbox: () => {
-        textSelectionPage.showAvailableOptionsToStudentsCheckbox()
-            .click()
-            .should('be.checked');
-    },
-
-    expandMaxNumberOfPossibleSelectionsDropdown: () => {
-        textSelectionPage.maxNumberOfPossibleSelectionsDropdown()
-            .click();
-    },
-
-    /**
-     * Verify maximum number of possible selections dropdown options
-     * @param {string[]} options array of dropdown options 
-     */
-    verifyMaxNumberOfPossibleSelectionsDropdownListOptions: (options) => {
-        options.forEach((option, count) => {
-            utilities.verifyInnerText(utilities.getNthElement(textSelectionPage.dropdownListOption(), count), option);
-        });
-    },
-
-    /**
-    * @param {string} listOption - The option to be selected from the maximum number of possible selections dropdown
-    * @description Selects an option from the maximum number of possible selections dropdown. The dropdown options are dependent on the number of available options.
-    */
-    selectOptionFromMaxNumberOfPossibleSelectionsDropdown: (listOption) => {
-        textSelectionPage.dropdownListOption()
-            .contains(listOption)
-            .click();
-    },
-
-    verifyShowStudentTheMaxNumberOfSelectionsCheckboxIsUnchecked: () => {
-        textSelectionPage.showStudentMaximumNumberOfPossibleSelectionsCheckbox()
-            .should('not.be.checked');
-    },
-
-    checkShowStudentTheMaxNumberOfSelectionsCheckbox: () => {
-        textSelectionPage.showStudentMaximumNumberOfPossibleSelectionsCheckbox()
-            .click()
-            .should('be.checked');
-    },
-
     clickOnEditColorButton: () => {
         textSelectionPage.editColorButton()
             .click();
@@ -1037,6 +971,7 @@ const tests = {
     ...additionalSettingsPanel.tests,
     ...additionalSettingsAccessibilitySectionComponent.tests,
     ...styleAndLayoutCustomizationAccordionComponent.tests,
+    ...showAvailableOptionsToStudents.tests,
     verifyContentsOfSpecifyCorrectAnswerSection: () => {
         it('When user selects a scoring type, then in the \'Correct\' accordion all the contents should be displayed', () => {
             textSelectionPage.specifyCorrectAnswerTextSpans()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itemengine-cypress-automation",
-  "version": "1.0.198-drawingResponseEnumUpdate-1aa98cf.0",
+  "version": "1.0.198",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -35,4 +35,4 @@
     "node-fetch": "^3.3.2",
     "react-uuid": "^2.0.0"
   }
-}
+}