itemengine-cypress-automation 1.0.166-migrationScripts-b8c79a0.0 → 1.0.166

package/cypress/pages/textSelectionPage.js

@@ -0,0 +1,582 @@
+import constants from "../fixtures/constants";
+import utilities from "../support/helpers/utilities";
+import { createQuestionBasePage, autoScoredScoringPreviewTab, scoringSectionBaseEditTab, questionInputFieldComponent, questionInstructionsComponent, autoScoredStudentViewSettings, correctIncorrectAnswerLabelComponent, autoScoredSpecifyCorrectAnswerSection, autoScoredScoringSectionMultiResponseType } from "./components";
+import { dialogBoxBase } from "./dialogBoxBase";
+import { setPointsPopupBase } from "./components/setPointsPopupBase";
+const css = Cypress.env('css');
+const colorLibrary = css.textSelectionColorLibrary;
+
+const paragraphTextArray = ['All animals have a unique role to play in maintaining the balance of nature.', 'A lot of animal species exist in both, land and water. As a result, each of them has a purpose for their existence.', 'The animals divide into specific groups in biology. Amphibians are those which can live on both, land and water.', 'Mammals are ones which give birth to their offspring in the womb and have mammary glands.', 'Birds are creatures with feathers, beaks, and the ability to lay eggs.', 'Many animal species are undocumented even today.', 'Research is going on to discover new species in the far corners of the earth']
+
+const selectors = {
+    ...questionInstructionsComponent,
+    ...autoScoredScoringSectionMultiResponseType,
+    questionInputField: () => cy.get('[class*="Highlightstyles__QuestionComponentWrapper"] [title="Question"]'),
+    highlightOptionsTextFieldWrapper: () => cy.get('[class*="Highlightstyles__HighLightWrapper"]'),
+    textSelectionMode: (ariaLabel = null) => {
+        if (ariaLabel) {
+            return cy.get(`.text-selection-mode [type="button"][aria-label*="${ariaLabel}"]`)
+        } else {
+            return cy.get('.text-selection-mode [type="button"]')
+        }
+    },
+    highlightOptionsSpans: () => cy.get('[class*="Highlightstyles__HighLightWrapper"] span'),
+
+    //Specify correct answer section
+    optionSpecifyCorrectAnswer: () => cy.get('[class*="Highlightstyles__Wrapper"] .highlighted'),
+    setPointsButton: () => cy.get('[class*="Highlightstyles__SetPointsPopupWrapper"] button'),
+
+    //Preview tab
+    questionTextPreviewTab: () => cy.get('[class*="Highlightstyles__HighlightPreviewWrapper"] [class*="QuestionTextstyle__QuestionTextWrapper"] p'),
+    optionPreviewTab: () => cy.get('[class*="Highlightstyles__HighlightPreviewWrapper"] .highlighted'),
+    optionCorrectAnswerSection: () => cy.get('[class*="Highlightstyles__Wrapper"]').eq(1).find('.highlighted'),
+    correctAnswerSection: () => cy.get('[class*="Highlightstyles__Wrapper"]').eq(1),
+    correctIncorrectAnswerLabelWrapper: () => cy.get('[class*="AnswerStatusWrapper"]'),
+    correctIncorrectAnswerLabel: () => cy.get('[class*="AnswerStatusText"]'),
+    correctAnswersLabel: () => cy.get('[class*="Highlightstyles__CorrectAnswerHeader-"]'),
+}
+
+const steps = {
+    ...createQuestionBasePage.steps,
+    ...scoringSectionBaseEditTab.steps,
+    ...autoScoredScoringPreviewTab.steps,
+    ...questionInstructionsComponent.steps,
+    ...autoScoredStudentViewSettings.steps,
+    ...correctIncorrectAnswerLabelComponent.steps,
+    ...autoScoredSpecifyCorrectAnswerSection.steps,
+    ...autoScoredScoringSectionMultiResponseType.steps,
+    addInputToQuestionInputField: (text) => {
+        textSelectionPage.questionInputField()
+            .type(text);
+    },
+
+    clearQuestionInputField: () => {
+        textSelectionPage.questionInputField()
+            .clear();
+    },
+
+    focusInQuestionInputField: () => {
+        textSelectionPage.questionInputField()
+            .focus();
+    },
+
+    focusOutOfQuestionInputField: () => {
+        textSelectionPage.questionInputField()
+            .blur();
+    },
+
+    verifyErroredStateOfQuestionInputField: () => {
+        utilities.verifyCSS(textSelectionPage.questionInputField(), {
+            'border-color': css.color.errorFieldBorder,
+            'background-color': css.color.errorFieldBg
+        });
+    },
+
+    verifyErroredStateOfHighlightOptionsSection: () => {
+        utilities.verifyCSS(textSelectionPage.highlightOptionsTextFieldWrapper(), {
+            'border-color': css.color.errorFieldBorder,
+            'background-color': css.color.errorFieldBg
+        });
+    },
+
+    verifyImageAndAltTextInQuestionInputField: () => {
+        textSelectionPage.questionInputField()
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    verifyEquationInQuestionInputField: () => {
+        textSelectionPage.questionInputField()
+            .find('[data-widget="ngie_equation"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    verifyLinkInQuestionInputField: () => {
+        textSelectionPage.questionInputField()
+            .find('a')
+            .should('have.text', 'lorem')
+            .and('have.attr', 'href', `${Cypress.config().baseUrl}`);
+    },
+
+    verifyBoldTextInQuestionInputField: () => {
+        textSelectionPage.questionInputField()
+            .find('strong')
+            .should('exist')
+            .should('have.text', '​​​​​​​This is Bold text input.');
+    },
+
+    verifyImageAndAltTextInHighlightOptionsSection: () => {
+        textSelectionPage.highlightOptionsTextFieldWrapper()
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    verifyEquationInHighlightOptionsSection: () => {
+        textSelectionPage.highlightOptionsTextFieldWrapper()
+            .find('span[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    verifyLinkInHighlightOptionsSection: () => {
+        textSelectionPage.highlightOptionsTextFieldWrapper()
+            .find('a')
+            .should('have.text', 'lorem')
+            .and('have.attr', 'href', `${Cypress.config().baseUrl}`);
+    },
+
+    verifyBoldTextInHighlightOptionsSection: () => {
+        textSelectionPage.highlightOptionsTextFieldWrapper()
+            .find('strong')
+            .should('exist')
+            .should('have.text', 'This is Bold text input.lorem');
+    },
+
+    verifyHighlightOptionsFieldErrorMessage: () => {
+        textSelectionPage.highlightOptionsTextFieldWrapper()
+            .next()
+            .should('have.text', 'Error: Minimum one highlight option is required.');
+    },
+
+    /**
+     * @param {string} textSelectionType Type of text selection
+     * @description Switch text selection type in text selection dropdown
+     */
+    switchTextSelectionMode: (textSelectionType) => {
+        textSelectionPage.textSelectionMode(textSelectionType)
+            .click();
+    },
+
+    /**
+     * @param {string} optionText Text of the option in highlight options section
+     * @description Click on option in highlight options section
+     */
+    clickOnOptionInHighlightOptionsSection: (optionText) => {
+        textSelectionPage.highlightOptionsSpans()
+            .contains(optionText)
+            .click();
+    },
+
+    /**
+     * @param {string} optionText Text of the option in set correct answer section
+     * @description Click on option in set correct answer section
+     */
+    clickOnOptionInSpecifyCorrectAnswerSection: (optionText) => {
+        textSelectionPage.optionSpecifyCorrectAnswer()
+            .contains(optionText)
+            .click();
+    },
+
+    /**
+    * @param {string} optionText Text of the option in preview tab
+    * @description Click on option in preview tab
+    */
+    clickOnOptionInPreviewTab: (optionText) => {
+        textSelectionPage.optionPreviewTab()
+            .contains(optionText)
+            .click();
+    },
+
+    /**
+     * @param {*} optionText Text of the option in set correct answer section
+     * @description Select an option in set correct answer section
+     */
+    selectOptionInSpecifyCorrectAnswerSection: (optionText) => {
+        textSelectionPage.steps.clickOnOptionInSpecifyCorrectAnswerSection(optionText);
+        textSelectionPage.steps.verifyOptionIsSelectedInSpecifyCorrectAnswerSection(optionText);
+    },
+
+    /**
+     * @param {*} optionText Text of the option in set correct answer section
+     * @description Deselect an option in set correct answer section
+     */
+    deselectOptionInSpecifyCorrectAnswerSection: (optionText) => {
+        textSelectionPage.steps.clickOnOptionInSpecifyCorrectAnswerSection(optionText);
+        textSelectionPage.steps.verifyOptionIsNotSelectedInSpecifyCorrectAnswerSection(optionText);
+    },
+
+    /**
+     * @param {*} optionText Text of the option in preview tab
+     * @description Select an option in preview tab
+     */
+    selectOptionInPreviewTab: (optionText) => {
+        textSelectionPage.steps.clickOnOptionInPreviewTab(optionText);
+        textSelectionPage.steps.verifyOptionIsSelectedInPreviewTab(optionText);
+    },
+
+    /**
+     * @param {*} optionText Text of the option in preview tab
+     * @description Deselect an option in preview tab
+     */
+    deselectOptionInPreviewTab: (optionText) => {
+        textSelectionPage.steps.clickOnOptionInPreviewTab(optionText);
+        textSelectionPage.steps.verifyOptionIsNotSelectedInPreviewTab(optionText);
+    },
+
+    /**
+    * @param {string} optionText Text of the option in highlight options section
+    * @description Verify that option is in selected state in highlight options section
+    */
+    verifyOptionIsSelectedInHighlightOptionsSection: (optionText) => {
+        textSelectionPage.highlightOptionsSpans()
+            .contains(optionText)
+            .should('have.class', 'highlighted')
+            .and('have.attr', 'aria-checked', 'true');
+    },
+
+    /**
+     * @param {string} optionText Text of the option in highlight options section
+     * @description Verify that option does not exist in highlight options section
+     */
+    verifyOptionDoesNotExistInHighlightOptionsSection: (optionText) => {
+        utilities.verifyElementVisibilityState(textSelectionPage.highlightOptionsSpans().contains(optionText), 'notExist');
+    },
+
+    verifyCorrectAnswerSectionNotExists: () => {
+        utilities.verifyElementVisibilityState(textSelectionPage.correctAnswerSection(), 'notExist');
+    },
+
+    /**
+    * @param {string} optionText Text of the option in highlight options section
+    * @description Verify hover state of the deselected option in highlight options section
+    */
+    verifyHoverStateOfDeselectedOptionInHighlightOptionsSection: (optionText) => {
+        textSelectionPage.steps.hoverOnDeselectedOptionInHighlightOptionsSection(optionText);
+        utilities.verifyCSS(textSelectionPage.highlightOptionsSpans()
+            .contains(optionText), {
+            'color': css.color.text,
+            'font-size': css.fontSize.default,
+            'font-weight': css.fontWeight.regular,
+            'background-color': colorLibrary.selectionColor.hoverBackground,
+            'border': `1px solid ${colorLibrary.selectionColor.hoverBorder}`
+        });
+    },
+
+    /**
+    * @param {string} optionText Text of the option in highlight options section
+    * @description Hover on deselected option in highlight options section
+    */
+    hoverOnDeselectedOptionInHighlightOptionsSection: (optionText) => {
+        textSelectionPage.highlightOptionsSpans()
+            .contains(optionText)
+            .realHover();
+    },
+
+    /**
+     * @param {string[]} optionArray Array of text of options in highlight options section
+     * @description Verify the options displayed in highlight options section
+     */
+    verifyOptionsInHighlightOptionsSection: (optionArray) => {
+        optionArray.forEach((optionText, optionIndex) => {
+            utilities.verifyInnerText(textSelectionPage.highlightOptionsSpans().eq(optionIndex), optionText)
+        });
+        utilities.verifyElementCount(textSelectionPage.highlightOptionsSpans(), optionArray.length);
+    },
+
+    /**
+     * @param {string} optionText Text of the option in set correct answer section
+     * @description Verify that option is not in selected state in set correct answer section
+     */
+    verifyOptionIsNotSelectedInSpecifyCorrectAnswerSection: (optionText) => {
+        textSelectionPage.optionSpecifyCorrectAnswer()
+            .contains(optionText)
+            .should('not.have.class', 'correct_answer')
+            .and('have.attr', 'aria-checked', 'false');
+    },
+
+    /**
+     * @param {string[]} optionArray Array of text of options in highlight options section
+     * @description Verify the options displayed in highlight options section
+     */
+    verifyOptionsInSpecifyCorrectAnswerSection: (optionArray) => {
+        optionArray.forEach((optionText, optionIndex) => {
+            utilities.verifyInnerText(textSelectionPage.optionSpecifyCorrectAnswer().eq(optionIndex), optionText)
+        });
+        utilities.verifyElementCount(textSelectionPage.optionSpecifyCorrectAnswer(), optionArray.length);
+    },
+
+    /**
+     * @param {string} optionText Text of the option in set correct answer section
+     * @description Hover on deselected option in set correct answer section
+     */
+    hoverOnDeselectedOptionInSpecifyCorrectAnswerSection: (optionText) => {
+        textSelectionPage.optionSpecifyCorrectAnswer()
+            .contains(optionText)
+            .realHover();
+    },
+
+    /**
+    * @param {string[]} optionArray Array of text of options in preview tab
+    * @description Verify the options displayed in preview tab
+    */
+    verifyOptionInPreviewTab: (optionArray) => {
+        optionArray.forEach((optionText, optionIndex) => {
+            utilities.verifyInnerText(textSelectionPage.optionPreviewTab().eq(optionIndex), optionText)
+        });
+        utilities.verifyElementCount(textSelectionPage.optionPreviewTab(), optionArray.length);
+    },
+
+    /**
+     * @param {string} optionText Text of the option in preview tab
+     * @description Hover on deselected option in preview tab
+     */
+    hoverOnDeselectedOptionInPreviewTab: (optionText) => {
+        textSelectionPage.optionPreviewTab()
+            .contains(optionText)
+            .realHover();
+    },
+
+    /**
+     * @param {string} optionText Text of the option in set correct answer section
+     * @description Verify hover state of the deselected option in set correct answer section
+     */
+    verifyHoverStateOfDeselectedOptionInSpecifyCorrectAnswerSection: (optionText) => {
+        textSelectionPage.steps.hoverOnDeselectedOptionInSpecifyCorrectAnswerSection(optionText);
+        utilities.verifyCSS(textSelectionPage.optionSpecifyCorrectAnswer().contains(optionText), {
+            'color': css.color.text,
+            'font-size': css.fontSize.default,
+            'font-weight': css.fontWeight.regular,
+            'background-color': colorLibrary.selectionColor.hoverBackground,
+            'border': `1px solid ${colorLibrary.selectionColor.hoverBorder}`
+        });
+    },
+
+    /**
+    * @param {string} optionText Text of the option in preview tab
+     * @param {string} selectionColor type of color used for selection of option
+    * @description Verify hover state of the deselected option in preview tab
+     * @example verifyHoverStateOfOptionInPreviewTab('Sample text', "blue")
+    */
+    verifyHoverStateOfOptionInPreviewTab: (optionText, selectionColor) => {
+        utilities.hoverOverElement(textSelectionPage.optionPreviewTab().contains(optionText));
+        utilities.verifyCSS(textSelectionPage.optionPreviewTab().contains(optionText), {
+            'color': css.color.text,
+            'font-size': css.fontSize.default,
+            'font-weight': css.fontWeight.regular,
+            'background-color': colorLibrary[selectionColor].hoverBackground,
+            'border': `2px solid ${colorLibrary[selectionColor].hoverBorder}`
+        });
+        utilities.hoverAwayFromElement(textSelectionPage.optionPreviewTab().contains(optionText));
+    },
+
+    /**
+    * @param {string} optionText Text of the option in preview tab
+     * @param {string} selectionColor type of color used for selection of option
+     * @example verifySelectedStateOptionInPreviewTab('Sample text', "blue")
+     */
+    verifySelectedStateOptionInPreviewTab: (optionText, selectionColor) => {
+        utilities.verifyCSS(textSelectionPage.optionPreviewTab().contains(optionText), {
+            'color': css.color.whiteText,
+            'font-size': css.fontSize.default,
+            'font-weight': css.fontWeight.regular,
+            'background-color': colorLibrary[selectionColor].background
+        });
+    },
+
+    /**
+    * @param {string} optionText Text of the option in preview tab
+     * @example verifyDeselectedStateOptionInPreviewTab('Sample text')
+     */
+    verifyDeselectedStateOptionInPreviewTab: (optionText) => {
+        utilities.verifyCSS(textSelectionPage.optionPreviewTab().contains(optionText), {
+            'color': css.color.text,
+            'font-size': css.fontSize.default,
+            'font-weight': css.fontWeight.regular,
+            'background-color': css.color.transparent
+        });
+    },
+
+    /**
+     * @param {string} optionText Text of the option in preview tab
+     * @description Verify check-mark icon is displayed for option
+     */
+    verifyCorrectIconForOption: (optionText) => {
+        textSelectionPage.optionPreviewTab()
+            .contains(optionText)
+            .should('have.class', 'correct_answer')
+            .within(() => {
+                autoScoredScoringPreviewTab.correctIcon()
+                    .should('be.visible');
+            });
+    },
+
+    /**
+     * @param {string} optionText Text of the option in preview tab
+     * @description Verify cross-mark icon is displayed for option
+     */
+    verifyIncorrectIconForOption: (optionText) => {
+        textSelectionPage.optionPreviewTab()
+            .contains(optionText)
+            .should('have.class', 'correct_answer')
+            .within(() => {
+                autoScoredScoringPreviewTab.incorrectIcon()
+                    .should('be.visible');
+            });
+    },
+
+    /**
+    * @param {string} optionText Text of the option in preview tab
+    * @description Verify check-mark icon is displayed for option
+    */
+    verifyCorrectIncorrectIconForOptionNotExist: (optionText) => {
+        textSelectionPage.optionPreviewTab()
+            .contains(optionText)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'notExist');
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'notExist');
+            });
+    },
+
+    /**
+    * @param {string} optionText Text of the option in preview tab
+    * @description Verify check-mark icon is displayed for option
+    */
+    verifyCorrectIncorrectIconForCorrectAnswerOptionNotExist: (optionText) => {
+        textSelectionPage.optionPreviewTab()
+            .contains(optionText)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'notExist');
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'notExist');
+            });
+    },
+
+    /**
+    * @param {string} optionText Text of the option in correct answer section preview tab
+    * @description Verify check-mark icon is displayed for option
+    */
+    verifyCorrectIconForOptionCorrectAnswerSection: (optionText) => {
+        textSelectionPage.optionCorrectAnswerSection()
+            .contains(optionText)
+            .should('have.class', 'correct_answer')
+            .within(() => {
+                autoScoredScoringPreviewTab.correctIcon()
+                    .should('be.visible');
+            });
+    },
+
+    /**
+     * @param {string} optionText Text of the option in set correct answer section
+     * @description Verify that option is in selected state in set correct answer section
+     */
+    verifyOptionIsSelectedInSpecifyCorrectAnswerSection: (optionText) => {
+        textSelectionPage.optionSpecifyCorrectAnswer()
+            .contains(optionText)
+            .should('have.class', 'correct_answer')
+            .and('have.attr', 'aria-checked', 'true');
+    },
+
+    /**
+     * @param {string} optionText Text of the option in highlight options section
+     * @description Verify that option is not in selected state in highlight options section
+     */
+    verifyOptionIsNotSelectedInHighlightOptionsSection: (optionText) => {
+        textSelectionPage.highlightOptionsSpans()
+            .contains(optionText)
+            .should('not.have.class', 'highlighted')
+            .and('have.attr', 'aria-checked', 'false');
+    },
+
+    /**
+     * @param {string} optionText Text of the option in preview tab
+     * @description Verify that option is in selected state in preview tab
+     */
+    verifyOptionIsSelectedInPreviewTab: (optionText) => {
+        textSelectionPage.optionPreviewTab()
+            .contains(optionText)
+            .should('have.class', 'correct_answer')
+            .and('have.attr', 'aria-checked', 'true');
+    },
+
+    /**
+     * @param {string} optionText Text of the option in preview tab
+     * @description Verify that option is not in selected state in preview tab
+     */
+    verifyOptionIsNotSelectedInPreviewTab: (optionText) => {
+        textSelectionPage.optionPreviewTab()
+            .contains(optionText)
+            .should('not.have.class', 'correct_answer')
+            .and('have.attr', 'aria-checked', 'false');
+    },
+
+    verifyNoOptionIsSelectedInPreviewTab: () => {
+        textSelectionPage.optionPreviewTab()
+            .should('not.have.class', 'correct_answer')
+            .and('have.attr', 'aria-checked', 'false');
+    },
+
+    /**
+    * @param {("correct" | "incorrect")} answerStatus - The status of the answer.
+    * @description Verifies the visibility and content of the correct/incorrect answer label block.
+    * If the answer is correct, it also verifies the visibility of the correct icon; otherwise, it verifies the visibility of the incorrect icon.
+    */
+    verifyCorrectIncorrectAnswerLabel: (answerStatus) => {
+        utilities.verifyElementVisibilityState(textSelectionPage.correctIncorrectAnswerLabel(), 'exist');
+        utilities.verifyInnerText(textSelectionPage.correctIncorrectAnswerLabel(), `Your answer is\n${answerStatus}`)
+        textSelectionPage.correctIncorrectAnswerLabelWrapper()
+            .within(() => {
+                if (answerStatus === 'correct') {
+                    utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'visible');
+                } else {
+                    utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'visible');
+                }
+            });
+    },
+
+    setQuestionAndOptionsInEditTab: () => {
+        textSelectionPage.steps.clearQuestionInputField();
+        paragraphTextArray.forEach((paragraphText) => {
+            textSelectionPage.steps.addInputToQuestionInputField(`${paragraphText}{enter}`);
+        });
+        textSelectionPage.steps.addInputToQuestionInputField('{backspace}');
+        textSelectionPage.steps.switchTextSelectionMode('Paragraph');
+        textSelectionPage.steps.clickOnOptionInHighlightOptionsSection(paragraphTextArray[0]);
+        textSelectionPage.steps.clickOnOptionInHighlightOptionsSection(paragraphTextArray[1]);
+        textSelectionPage.steps.clickOnOptionInHighlightOptionsSection(paragraphTextArray[2]);
+        textSelectionPage.steps.clickOnOptionInHighlightOptionsSection(paragraphTextArray[3]);
+        textSelectionPage.steps.clickOnOptionInHighlightOptionsSection(paragraphTextArray[4]);
+        textSelectionPage.steps.clickOnOptionInHighlightOptionsSection(paragraphTextArray[5]);
+    },
+
+    /**
+    * @param {number[]} pointsArray Array of partial different points for options
+    * @description Add points to options in set points popup
+    */
+    addPartialDifferentWeightsPointsInSetPointsPopup: (pointsArray) => {
+        textSelectionPage.setPointsButton()
+            .click();
+        setPointsPopupBase.steps.allotPointsToSetPointsPopupPointsInputField(pointsArray);
+        setPointsPopupBase.steps.saveSetPointsPopup();
+    },
+
+    /**
+     * Verify non-optional text is not interactive in preview tab
+     * @param {string} optionText Non-optional text in preview tab
+     */
+    verifyNonOptionTextIsNotInteractiveInPreviewTab: (optionText) => {
+        utilities.hoverOverElement(textSelectionPage.questionTextPreviewTab().contains(optionText));
+        utilities.verifyCSS(textSelectionPage.questionTextPreviewTab().contains(optionText), {
+            'background-color': css.color.transparent
+        });
+        utilities.hoverAwayFromElement(textSelectionPage.questionTextPreviewTab().contains(optionText));
+        textSelectionPage.questionTextPreviewTab()
+            .contains(optionText)
+            .click();
+        textSelectionPage.questionTextPreviewTab()
+            .contains(optionText)
+            .should('not.have.class', 'correct_answer')
+            .and('have.attr', 'aria-checked', 'false');
+    }
+}
+
+const tests = {
+    ...autoScoredScoringPreviewTab.tests,
+}
+
+export const textSelectionPage = {
+    ...selectors,
+    steps,
+    tests
+}

package/cypress/support/migrationHelpers/extractLrnQuestionData.js

@@ -471,7 +471,7 @@ export const extractLrnQuestionData = {
 
     figText: (lrnQuestionDataArr, index) => {
         let obj = {};
-        cy.log(`Extracting the question instructions, question, response count, response field properties from question ${index}`);
+        cy.log(`Extracting the question instructions, question and response count from question ${index}`);
         obj.questionIndex = index;
         obj.questionType = 'figText';
         lrnPage.steps.extractQuestionInstructions(obj, index);
@@ -496,7 +496,7 @@ export const extractLrnQuestionData = {
                     .parent()
                     .then(($responseField) => {
                         obj.isMultiline = $responseField[0].type === 'textarea' ? true : false;
-                        if ($responseField[0].innerHTML.includes('lrn_charactermapbutton')) {
+                        if($responseField[0].innerHTML.includes('lrn_charactermapbutton')) {
                             obj.specialCharactersEnabled = true;
                         }
                     });
@@ -518,7 +518,7 @@ export const extractLrnQuestionData = {
 
     figTextGrading: (lrnQuestionDataArr, index) => {
         let obj = {};
-        cy.log(`Extracting the question instructions, question, response count, response field properties from question ${index}`);
+        cy.log(`Extracting the question instructions, question and response count from question ${index}`);
         obj.questionIndex = index;
         obj.questionType = 'figText';
         lrnPage.steps.extractQuestionInstructions(obj, index);
@@ -550,15 +550,6 @@ export const extractLrnQuestionData = {
         lrnQuestionDataArr.push(obj);
     },
 
-    figDropdown: (lrnQuestionDataArr, index) => {
-        let obj = {};
-        cy.log(`Extracting the question instructions, question, response count, response field properties from question ${index}`);
-        obj.questionIndex = index;
-        obj.questionType = 'figDropdown';
-        lrnPage.steps.extractQuestionInstructions(obj, index);
-        lrnQuestionDataArr.push(obj);
-    },
-
     /*     singleSelection: (lrnQuestionDataArr, index) => {
             let obj = {};
             cy.log(`Extracting the question instructions and options from question ${index}`);

package/cypress/support/migrationHelpers/lrnQestionTypesENUM.js

@@ -10,7 +10,6 @@ const lrnQuestionTypesENUM = {
     multipleSelection: 'Multiple choice – multiple response',
     trueOrFalse: 'True or false',
     figText: 'Cloze with text',
-    figDropdown: 'Cloze with drop down',
 }
 
 export default lrnQuestionTypesENUM;

package/cypress/support/migrationHelpers/migrationScript.js

@@ -24,7 +24,6 @@ const extractLrnPreviewData = (currQuestionType, lrnQuestionDataArr, index) => {
         case lrnQuestionTypesENUM.drawingResponse: return extractLrnQuestionData.drawingResponse(lrnQuestionDataArr, index);
         case lrnQuestionTypesENUM.dndIntoCategories: return extractLrnQuestionData.dndIntoCategories(lrnQuestionDataArr, index);
         case lrnQuestionTypesENUM.figText: return extractLrnQuestionData.figText(lrnQuestionDataArr, index);
-        case lrnQuestionTypesENUM.figDropdown: return extractLrnQuestionData.figDropdown(lrnQuestionDataArr, index);
         default: throw new Error('Invalid lrn question type');
     }
 }
@@ -39,7 +38,6 @@ const verifyIePreviewData = (questionType, questionData, index) => {
         case 'drawingResponse': return verifyIeQuestionData.drawingResponse(questionData, index);
         case 'dndIntoCategories': return verifyIeQuestionData.dndIntoCategories(questionData, index);
         case 'figText': return verifyIeQuestionData.figText(questionData, index);
-        case 'figDropdown': return verifyIeQuestionData.figDropdown(questionData, index);
         default: throw new Error('Invalid ngie question type');
     }
 }
@@ -49,12 +47,8 @@ const extractLrnGradingData = (currQuestionType, lrnGradingDataArr, index) => {
         case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcqGrading(lrnGradingDataArr, index);
         case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMathGrading(lrnGradingDataArr, index);
         case lrnQuestionTypesENUM.textEntryMathImage: return extractLrnQuestionData.textEntryMathImageGrading(lrnGradingDataArr, index);
-        case lrnQuestionTypesENUM.essayResponse: return cy.log('Manually Graded Question Type');
-        case lrnQuestionTypesENUM.essayResponseBasic: return cy.log('Manually Graded Question Type');
-        case lrnQuestionTypesENUM.drawingResponse: return cy.log('Manually Graded Question Type');
         case lrnQuestionTypesENUM.dndIntoCategories: return extractLrnQuestionData.dndIntoCategoriesGrading(lrnGradingDataArr, index);
         case lrnQuestionTypesENUM.figText: return extractLrnQuestionData.figTextGrading(lrnGradingDataArr, index);
-        case lrnQuestionTypesENUM.figDropdown: return;
         default: throw new Error('Invalid lrn question type');
     }
 }
@@ -64,12 +58,8 @@ const verifyIeGradingData = (questionType, questionData, index) => {
         case 'mcq': return verifyIeQuestionData.mcqGrading(questionData, index);
         case 'textEntryMath': return verifyIeQuestionData.textEntryMathGrading(questionData, index);
         case 'textEntryMathImage': return verifyIeQuestionData.textEntryMathImageGrading(questionData, index);
-        case 'essayResponse': return cy.log('Manually Graded Question Type');
-        case 'essayResponseBasic': return cy.log('Manually Graded Question Type');
-        case 'drawingResponse': return cy.log('Manually Graded Question Type');
         case 'dndIntoCategories': return verifyIeQuestionData.dndIntoCategoriesGrading(questionData, index);
         case 'figText': return verifyIeQuestionData.figTextGrading(questionData, index);
-        case 'figDropdown': return;
         default: throw new Error('Invalid ngie question type');
     }
 }