itemengine-cypress-automation 1.0.77 → 1.0.79

package/cypress/pages/multipleSelectionPage.js

@@ -1,23 +1,77 @@
+import constants from "../fixtures/constants";
 import utilities from "../support/helpers/utilities"
-import { autoScoredSpecifyCorrectAnswerSection, commonComponents, createQuestionBasePage, optionsWrapperComponent, scoringSectionBase } from "./components"
+import { autoScoredScoringSectionMultiResponseType, autoScoredSpecifyCorrectAnswerSection, commonComponents, createQuestionBasePage, optionsWrapperComponent, questionInstructionsComponent, scoringSectionBaseEditTab, autoScoredScoringPreviewTab, autoScoredStudentViewSettings, additionalSettingsPanel, ckEditorToolbar, equationEditorFlyout, mcqAdditionalSettingsBase, randomizeOptionsComponent, lockUnlockOptionComponent } from "./components"
 const css = Cypress.env('css');
+const options = ['Pollution caused by treating chemical waste', 'Pollution caused by cement production', 'Pollution caused by methane production', 'Pollution caused by cement and methane production'];
 
 const selectors = {
     ...autoScoredSpecifyCorrectAnswerSection,
     ...createQuestionBasePage,
     ...optionsWrapperComponent,
+    ...autoScoredScoringSectionMultiResponseType,
+    ...scoringSectionBaseEditTab,
+    ...questionInstructionsComponent,
+    ...additionalSettingsPanel,
+    ...autoScoredStudentViewSettings,
+    ...questionInstructionsComponent,
+    ...mcqAdditionalSettingsBase,
+    ...commonComponents,
+    ...autoScoredScoringPreviewTab,
+    ...equationEditorFlyout,
+    ...randomizeOptionsComponent,
+    ...lockUnlockOptionComponent,
+    //Specify correct answer section
     optionWrapperSpecifyCorrectAnswerSection: () => cy.get('.mcq-option-wrapper'),
-    optionsTextSpecifyCorrectAnswerSection: () => cy.get('.mcq-label'),
+    optionsText: () => cy.get('.mcq-label'),
+    optionsCheckboxWrapperSpecifyCorrectAnswerSection: () => cy.get('[data-ngie-testid="response-option-checkbox"]:visible'),
+    optionsCheckboxWrapperPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [data-ngie-testid="response-option-checkbox"]:visible'),
     //TODO: Need to update below selectors, once https://redmine.zeuslearning.com/issues/553983 gets resolved
-    optionsCheckboxSpecifyCorrectAnswerSection: () => cy.get('[data-ngie-testid="response-option-checkbox"]:visible [type="checkbox"]'),
-    optionsCheckboxWrapperSpecifyCorrectAnswerSection: () => cy.get('[data-ngie-testid="response-option-checkbox"]:visible')
+    optionsCheckbox: () => cy.get('[data-ngie-testid="response-option-checkbox"]:visible [type="checkbox"]'),
+    optionsCheckboxPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [data-ngie-testid="response-option-checkbox"] [type="checkbox"]'),
+    optionsWrapperGradingView: () => cy.get('.mcq-answer-checked .mcq-option-wrapper'),
+    optionsWrapperStudentView: () => cy.get('.mcq-option-attempted .mcq-option-wrapper'),
+    optionWrapperPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .mcq-option-wrapper'),
+    setMinMaxNumberOfAnswersLabel: () => cy.get('[data-ngie-testid="set-minimum/maximum-number-of-answers-checkbox"] .MuiFormControlLabel-label'),
+    setMinMaxNumberOfAnswersCheckbox: () => cy.get('[data-ngie-testid="set-minimum/maximum-number-of-answers-checkbox"] input'),
+    minimumNumberOfAnswersLabel: () => cy.get('#Minimum-number-of-answers-dropdown-label'),
+    minimumNumberOfAnswersDropdown: () => cy.get('#Minimum-number-of-answers-select'),
+    minimumNumberOfAnswersDropdownOptions: (ariaLabel = null) => {
+        if (ariaLabel) {
+            return cy.get(`[aria-labelledby*="Minimum-number-of-answers-dropdown-label"] [role="option"][aria-label*="${ariaLabel}"]`).eq(0)
+        } else {
+            return cy.get('[aria-labelledby*="Minimum-number-of-answers-dropdown-label"] [role="option"]')
+        }
+    },
+    maximumNumberOfAnswersLabel: () => cy.get('#Maximum-number-of-answers-dropdown-label'),
+    maximumNumberOfAnswersDropdown: () => cy.get('#Maximum-number-of-answers-select'),
+    maximumNumberOfAnswersDropdownOptions: (ariaLabel = null) => {
+        if (ariaLabel) {
+            return cy.get(`[aria-labelledby*="Maximum-number-of-answers-dropdown-label"] [role="option"][aria-label="${ariaLabel}"]`)
+        } else {
+            return cy.get('[aria-labelledby*="Maximum-number-of-answers-dropdown-label"] [role="option"]')
+        }
+    },
+    minMaxWarningMessage: () => cy.get('.min-max-answer-error-wrapper')
 }
 
 const steps = {
     ...autoScoredSpecifyCorrectAnswerSection.steps,
     ...createQuestionBasePage.steps,
     ...optionsWrapperComponent.steps,
-    ...scoringSectionBase.steps,
+    ...scoringSectionBaseEditTab.steps,
+    ...autoScoredScoringSectionMultiResponseType.steps,
+    ...questionInstructionsComponent.steps,
+    ...additionalSettingsPanel.steps,
+    ...autoScoredStudentViewSettings.steps,
+    ...autoScoredScoringPreviewTab.steps,
+    ...questionInstructionsComponent.steps,
+    ...ckEditorToolbar.steps,
+    ...equationEditorFlyout.steps,
+    ...commonComponents.steps,
+    ...mcqAdditionalSettingsBase.steps,
+    ...commonComponents.steps,
+    ...randomizeOptionsComponent.steps,
+    ...lockUnlockOptionComponent.steps,
     /**
      * Verifies the contents of an option wrapper in the 'Specify correct answer' section for multiple selection questions.
      * @param {number} optionIndex - The index of the option wrapper to be verified.
@@ -27,8 +81,23 @@ const steps = {
         multipleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
             .eq(optionIndex)
             .within(() => {
-                utilities.verifyInnerText(multipleSelectionPage.optionsTextSpecifyCorrectAnswerSection(), '');
-                multipleSelectionPage.optionsCheckboxSpecifyCorrectAnswerSection()
+                utilities.verifyInnerText(multipleSelectionPage.optionsText(), '');
+                multipleSelectionPage.optionsCheckbox()
+                    .should('not.be.checked');
+            });
+    },
+
+    /**
+        * Verifies the contents of an option wrapper in the 'Specify correct answer' section for multiple selection questions.
+        * @param {number} optionIndex - The index of the option wrapper to be verified.
+        * @example - verifyOptionWrapperContentsPreviewTab(0);
+        */
+    verifyOptionWrapperContentsPreviewTab: (optionIndex) => {
+        multipleSelectionPage.optionWrapperPreviewTab()
+            .eq(optionIndex)
+            .within(() => {
+                utilities.verifyInnerText(multipleSelectionPage.optionsText(), '');
+                multipleSelectionPage.optionsCheckbox()
                     .should('not.be.checked');
             });
     },
@@ -40,10 +109,137 @@ const steps = {
      * @example - checkOptionsCheckboxInSpecifyCorrectAnswerSection(0);
      */
     checkOptionsCheckboxInSpecifyCorrectAnswerSection: (optionIndex) => {
-        multipleSelectionPage.optionsCheckboxSpecifyCorrectAnswerSection()
+        multipleSelectionPage.optionsCheckbox()
             .eq(optionIndex)
             .click()
-            .should('be.checked')
+            .should('be.checked');
+    },
+
+    /**
+     * @description. Unchecks the options checkbox in the 'Specify correct answer' section for multiple selection questions.
+     * @param {number} optionIndex - The index of the option checkbox to be unchecked.
+     * @throws {Error} Will throw an error if the checkbox is not unchecked after the operation.
+     * @example - uncheckOptionsCheckboxInSpecifyCorrectAnswerSection(0);
+     */
+    uncheckOptionsCheckboxInSpecifyCorrectAnswerSection: (optionIndex) => {
+        multipleSelectionPage.optionsCheckbox()
+            .eq(optionIndex)
+            .click()
+            .should('not.be.checked');
+    },
+
+    /**
+     * @description. Checks the options checkbox in the 'Preview tab' for multiple selection questions.
+     * @param {number} optionIndex - The index of the option checkbox to be checked.
+     * @throws {Error} Will throw an error if the checkbox is not checked after the operation.
+     * @example - checkOptionsCheckboxInPreviewTab(0);
+     */
+    checkOptionsCheckboxInPreviewTab: (optionIndex) => {
+        multipleSelectionPage.optionWrapperPreviewTab()
+            .eq(optionIndex)
+            .within(() => {
+                multipleSelectionPage.optionsCheckbox()
+                    .click()
+                    .should('be.checked');
+            });
+    },
+
+    /**
+     * Verifies that the options checkbox in the preview tab is in the unchecked state for a specified option index.
+     * @param {number} optionIndex - The index of the option to verify in the preview tab.
+     */
+    verifyOptionsCheckboxInPreviewTabUncheckedState: (optionIndex) => {
+        multipleSelectionPage.optionWrapperPreviewTab()
+            .eq(optionIndex)
+            .within(() => {
+                multipleSelectionPage.optionsCheckbox()
+                    .should('not.be.checked');
+            });
+    },
+
+    /**
+     * Verifies that the options checkbox in the preview tab is in the checked state for a specified option index.
+     * @param {number} optionIndex - The index of the option to verify in the preview tab.
+     */
+    verifyOptionsCheckboxInPreviewTabCheckedState: (optionIndex) => {
+        multipleSelectionPage.optionWrapperPreviewTab()
+            .eq(optionIndex)
+            .within(() => {
+                multipleSelectionPage.optionsCheckbox()
+                    .should('be.checked');
+            });
+    },
+
+    /**
+     * Verifies the presence of the correct option icon in the grading view for a specified option index.
+     * @param {number} optionIndex - The index of the option to verify in the grading view.
+     */
+    verifyCorrectOptionIconGradingView: (optionIndex) => {
+        multipleSelectionPage.optionsWrapperGradingView()
+            .eq(optionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'visible');
+            });
+    },
+
+    /**
+     * Verifies the presence of the incorrect option icon in the grading view for a specified option index.
+     * @param {number} optionIndex - The index of the option to verify in the grading view.
+     */
+    verifyIncorrectOptionIconGradingView: (optionIndex) => {
+        multipleSelectionPage.optionsWrapperGradingView()
+            .eq(optionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'visible');
+            });
+    },
+
+    /**
+     * Verifies the presence of the correct option icon in the student view for a specified option index.
+     * @param {number} optionIndex - The index of the option to verify in the student view.
+     */
+    verifyCorrectOptionIconStudentView: (optionIndex) => {
+        multipleSelectionPage.optionsWrapperStudentView()
+            .eq(optionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'visible');
+            });
+    },
+
+    /**
+     * Verifies the presence of the incorrect option icon in the student view for a specified option index.
+     * @param {number} optionIndex - The index of the option to verify in the student view.
+     */
+    verifyIncorrectOptionIconStudentView: (optionIndex) => {
+        multipleSelectionPage.optionsWrapperStudentView()
+            .eq(optionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'visible');
+            });
+    },
+
+    /**
+     * Verifies that the correct and incorrect icons are not visible in the grading view for a specified option index.
+     * @param {number} optionIndex - The index of the option to verify in the grading view.
+     */
+    verifyCorrectIncorrectIconNotVisibleGradingView: (optionIndex) => {
+        multipleSelectionPage.optionsWrapperGradingView()
+            .eq(optionIndex)
+            .within(() => {
+                autoScoredScoringPreviewTab.steps.verifyCorrectIncorrectIconsNotExist();
+            });
+    },
+
+    /**
+     * Verifies that the correct and incorrect icons are not visible in the student view for a specified option index.
+     * @param {number} optionIndex - The index of the option to verify in the student view.
+     */
+    verifyCorrectIncorrectIconNotVisibleStudentView: (optionIndex) => {
+        multipleSelectionPage.optionsWrapperStudentView()
+            .eq(optionIndex)
+            .within(() => {
+                autoScoredScoringPreviewTab.steps.verifyCorrectIncorrectIconsNotExist();
+            });
     },
 
     /**
@@ -53,15 +249,312 @@ const steps = {
      * @example - uncheckOptionsCheckboxInSpecifyCorrectAnswerSection(0);
      */
     uncheckOptionsCheckboxInSpecifyCorrectAnswerSection: (optionIndex) => {
-        multipleSelectionPage.optionsCheckboxSpecifyCorrectAnswerSection()
+        multipleSelectionPage.optionsCheckbox()
             .eq(optionIndex)
             .click()
             .should('not.be.checked')
+    },
+
+    /**
+     * @description. Unchecks the options checkbox in the 'Preview tab' for multiple selection questions.
+     * @param {number} optionIndex - The index of the option checkbox to be unchecked.
+     * @throws {Error} Will throw an error if the checkbox is not checked after the operation.
+     * @example - uncheckOptionsCheckboxInPreviewTab(0);
+     */
+    uncheckOptionsCheckboxInPreviewTab: (optionIndex) => {
+        multipleSelectionPage.optionWrapperPreviewTab()
+            .eq(optionIndex)
+            .within(() => {
+                multipleSelectionPage.optionsCheckbox()
+                    .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.
+     */
+    verifyImageInSpecifyCorrectAnswerSection: (index) => {
+        multipleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
+            .eq(index)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    /**
+     * @description Verifies that the link text in the Specify Correct Answer section is correct and has the correct href attribute.
+     * @param {number} index - The index of the option in the Specify Correct Answer section.
+     */
+    verifyLinkTextInSpecifyCorrectAnswerSection: (index) => {
+        multipleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
+            .eq(index)
+            .find('a')
+            .should('have.text', 'lorem')
+            .and('have.attr', 'href', `${Cypress.config().baseUrl}`);
+    },
+
+    /**
+     * @description Verifies that the bold text in the Specify Correct Answer section is correct.
+     * @param {number} index - The index of the option in the Specify Correct Answer section.
+     */
+    verifyBoldTextInSpecifyCorrectAnswerSection: (index) => {
+        multipleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
+            .eq(index)
+            .find('strong')
+            .should('have.text', 'This is a bold option');
+    },
+
+    /**
+     * @description Verifies that the equation text in the Specify Correct Answer section is correct.
+     * @param {number} index - The index of the option in the Specify Correct Answer section.
+     */
+    verifyEquationTextInSpecifyCorrectAnswerSection: (index) => {
+        multipleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
+            .eq(index)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    /**
+     * @description Verifies that the image in the Preview tab has the correct source and alt text.
+     * @param {number} index - The index of the option in the Preview tab.
+     */
+    verifyImageInPreviewTab: (index) => {
+        multipleSelectionPage.optionWrapperPreviewTab()
+            .eq(index)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    /**
+     * @description Verifies that the link text in the Preview tab is correct and has the correct href attribute.
+     * @param {number} index - The index of the option in the Preview tab.
+     */
+    verifyLinkTextInPreviewTab: (index) => {
+        multipleSelectionPage.optionWrapperPreviewTab()
+            .eq(index)
+            .find('a')
+            .should('have.text', 'lorem')
+            .and('have.attr', 'href', `${Cypress.config().baseUrl}`);
+    },
+
+    /**
+     * @description Verifies that the bold text in the Preview tab is correct.
+     * @param {number} index - The index of the option in the Preview tab.
+     */
+    verifyBoldTextInPreviewTab: (index) => {
+        multipleSelectionPage.optionWrapperPreviewTab()
+            .eq(index)
+            .find('strong')
+            .should('have.text', 'This is a bold option');
+    },
+
+    /**
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} index - The index of the option in the Preview tab.
+     */
+    verifyEquationTextInPreviewTab: (index) => {
+        multipleSelectionPage.optionWrapperPreviewTab()
+            .eq(index)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    checkOptionsWrapperInSpecifyCorrectAnswerSection: (optionIndex) => {
+        multipleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
+            .eq(optionIndex)
+            .click()
+            .find('span')
+            .should('have.class', 'Mui-checked');
+    },
+
+    /**
+    * @param {string[]} optionsTextArray options array for set correct answer option
+    * @description this function verifies options text content
+    */
+    verifyOptionsTextContentInSpecifyCorrectAnswerSection: (optionsTextArray) => {
+        optionsTextArray.forEach((optionsText, index) => {
+            multipleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
+                .eq(index)
+                .within(() => {
+                    multipleSelectionPage.optionsText()
+                        .verifyInnerText(optionsText);
+                });
+        });
+    },
+
+    /**
+    * @param {string[]} optionsTextArray options array for set correct answer option
+    * @description this function verifies options text content
+    */
+    verifyOptionsTextContentInPreviewTab: (optionsTextArray) => {
+        optionsTextArray.forEach((optionsText, index) => {
+            multipleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
+                .eq(index)
+                .within(() => {
+                    multipleSelectionPage.optionsText()
+                        .verifyInnerText(optionsText);
+                });
+        });
+    },
+
+    getOptionsArray: () => {
+        const optionsArray = []
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                multipleSelectionPage.optionsText()
+                    .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
+     */
+    verifyRandomizeOptionOrder: (optionsArray, lockedOptionIndex) => {
+        let currentOptionsArray = [...optionsArray]
+        for (let index = 0; index < currentOptionsArray.length; index++) {
+            commonComponents.previewTabQuestionWrapper()
+                .within(() => {
+                    multipleSelectionPage.optionsText()
+                        .eq(index)
+                        .then(($element) => {
+                            if (lockedOptionIndex !== null && index === lockedOptionIndex) {
+                                expect($element.text()).to.equal(optionsArray[lockedOptionIndex]);
+                            } else {
+                                expect($element.text()).to.be.oneOf(currentOptionsArray);
+                                currentOptionsArray = currentOptionsArray.filter((value) => value !== $element.text())
+                            }
+                        });
+                });
+        };
+        multipleSelectionPage.steps.verifyOptionsAreRerandomized(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
+    */
+    verifyOptionsAreRerandomized: (previousOrderOfOptionsArray) => {
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                multipleSelectionPage.optionsText()
+                    .should('not.have.text', '')
+                    .and('not.have.text', previousOrderOfOptionsArray.join(''));
+            });
+    },
+
+    /**
+     * @description. Checks if option is disabled in the 'Preview tab' for multiple selection questions
+     * @param {number} optionIndex - The index of the option checkbox to be verified
+     */
+    verifyOptionInPreviewTabIsDisabled: (optionIndex) => {
+        multipleSelectionPage.optionsCheckboxPreviewTab()
+            .eq(optionIndex)
+            .should('be.disabled')
+    },
+
+    /**
+    * @description. Checks if option is disabled in the 'Preview tab' for single selection questions
+    * @param {number} optionIndex - The index of the option radio button to be verified
+    */
+    verifyOptionInPreviewTabIsNotDisabled: (optionIndex) => {
+        multipleSelectionPage.optionsCheckboxPreviewTab()
+            .eq(optionIndex)
+            .should('not.be.disabled')
+    },
+
+    verifySetMinMaxNumberOfAnswersCheckbox: () => {
+        multipleSelectionPage.setMinMaxNumberOfAnswersCheckbox()
+            .should('not.be.checked');
+    },
+
+    checkSetMinMaxNumberOfAnswersCheckbox: () => {
+        multipleSelectionPage.setMinMaxNumberOfAnswersCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    expandMinimumNumberOfAnswersDropdown: () => {
+        multipleSelectionPage.minimumNumberOfAnswersDropdown()
+            .click();
+    },
+
+    /**
+     * @param {("None"|"Any option from 1 to 4")} dropdownOption 
+     * @description this function selects option from minimum number of options dropdown
+     */
+    selectOptionFromMinimumNumberOfAnswersDropdown: (dropdownOption) => {
+        multipleSelectionPage.minimumNumberOfAnswersDropdownOptions(dropdownOption)
+            .click();
+    },
+
+    expandMaximumNumberOfAnswersDropdown: () => {
+        multipleSelectionPage.maximumNumberOfAnswersDropdown()
+            .click();
+    },
+
+    /**
+     * @param {("None"|"Any option from 1 to 4")} dropdownOption 
+     * @description this function selects option from maximum number of options dropdown
+     */
+    selectOptionFromMaximumNumberOfAnswersDropdown: (dropdownOption) => {
+        multipleSelectionPage.maximumNumberOfAnswersDropdownOptions(dropdownOption)
+            .click();
+    },
+
+    verifyMinMaxWarningMessage: (warningMessage) => {
+        utilities.verifyInnerText(multipleSelectionPage.minMaxWarningMessage(), warningMessage);
+    },
+
+    verifyMinMaxErrorMessageNotExist: () => {
+        utilities.verifyElementVisibilityState(multipleSelectionPage.minMaxWarningMessage(), 'notExist');
+    },
+
+    selectPreviewTabOption: (index) => {
+        multipleSelectionPage.optionWrapperPreviewTab()
+            .eq(index)
+            .click();
+    },
+
+    selectSpecifyCorrectAnswerOption: (index) => {
+        multipleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
+            .eq(index)
+            .click();
+    },
+
+    verifyOptionCheckBoxIsDisabled: (index) => {
+        multipleSelectionPage.optionsCheckbox()
+            .eq(index)
+            .parents('.ngie-checkbox')
+            .should('have.class', 'checkbox-option-disabled');
     }
 }
 
 const tests = {
+    ...createQuestionBasePage.tests,
+    ...questionInstructionsComponent.tests,
+    ...scoringSectionBaseEditTab.tests,
+    ...autoScoredScoringSectionMultiResponseType.tests,
     ...autoScoredSpecifyCorrectAnswerSection.tests,
+    ...additionalSettingsPanel.tests,
+    ...autoScoredScoringPreviewTab.tests,
+    ...questionInstructionsComponent.tests,
+    ...optionsWrapperComponent.tests,
+    ...equationEditorFlyout.tests,
+    ...commonComponents.tests,
     /**
      * Verifies the contents and functionality of the 'Specify correct answer' accordion for multiple selection questions.
      * @param {{'Correct' | 'Alternative'}} accordionName - The name of the accordion to be used in the validation.
@@ -100,12 +593,12 @@ const tests = {
         autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(accordionName);
 
         it('CSS of \'Correct\' accordion contents', { tags: 'css' }, () => {
-            utilities.verifyCSS(multipleSelectionPage.optionsTextSpecifyCorrectAnswerSection(), {
+            utilities.verifyCSS(multipleSelectionPage.optionsText(), {
                 'color': css.color.text,
                 'font-size': css.fontSize.default,
                 'font-weight': css.fontWeight.regular
             });
-            utilities.verifyCSS(multipleSelectionPage.optionsCheckboxSpecifyCorrectAnswerSection().parent().find('svg'), {
+            utilities.verifyCSS(multipleSelectionPage.optionsCheckbox().parent().find('svg'), {
                 'fill': css.color.secondaryBtn
             });
             cy.log('CSS of selected options')
@@ -114,12 +607,12 @@ const tests = {
                 'color': css.color.activeButtons,
                 'border': `2px solid ${css.color.activeComponentBorder}`
             });
-            utilities.verifyCSS(utilities.getNthElement(multipleSelectionPage.optionsTextSpecifyCorrectAnswerSection(), 1).find('.question-text-wrapper'), {
+            utilities.verifyCSS(utilities.getNthElement(multipleSelectionPage.optionsText(), 1).find('.question-text-wrapper'), {
                 'color': css.color.optionsSelectedText,
                 'font-size': css.fontSize.default,
                 'font-weight': css.fontWeight.regular
             });
-            multipleSelectionPage.optionsCheckboxSpecifyCorrectAnswerSection()
+            multipleSelectionPage.optionsCheckbox()
                 .eq(1)
                 .parent()
                 .verifyPseudoClassBeforeProperty('color', css.color.activeButtons);
@@ -129,6 +622,15 @@ const tests = {
             cy.checkAccessibility(multipleSelectionPage.optionWrapperSpecifyCorrectAnswerSection().parents('.correct-answer-accordion'))
         });
     },
+
+    verifyContentsOfSpecifyCorrectAnswerSection: () => {
+        it('In the \'Correct\' accordion, all options with checkboxes should be displayed', () => {
+            utilities.verifyElementCount(multipleSelectionPage.optionWrapperSpecifyCorrectAnswerSection(), 4);
+            options.forEach((option, index) => {
+                utilities.verifyInnerText(utilities.getNthElement(multipleSelectionPage.optionsText(), index), option);
+            });
+        });
+    }
 }
 
 export const multipleSelectionPage = {

package/cypress/pages/passagePage.js

@@ -10,6 +10,7 @@ const selectors = {
     ...ckEditorToolbar,
     ...equationEditorFlyout,
     ...additionalSettingsPanel,
+    ...createQuestionBasePage,
     //TODO: Need to update selectors https://redmine.zeuslearning.com/issues/518498
     headingLabel: () => cy.get('.inline-text-property-label').eq(0),
     headingInputField: () => cy.get('.inline-text-question-prefix-wrapper input').eq(0),
@@ -371,6 +372,15 @@ const steps = {
         passagePage.paginationText()
             .should('have.text', `${currentPage} of ${TotalPages}`);
     },
+
+    createBasicPassageResourceAndTool: (inputHeadingText, inputBodyText) => {
+        passagePage.headingInputField()
+            .type(inputHeadingText);
+        passagePage.bodyInputField()
+            .type(inputBodyText);
+        passagePage.saveQuestionButton()
+            .click();
+    },
 }
 
 const tests = {