itemengine-cypress-automation 1.0.78 → 1.0.80

package/cypress/pages/singleSelectionPage.js

@@ -1,61 +1,520 @@
-import { additionalSettingsPanel, autoScoredPreviewBase, createQuestionBasePage, mcqAdditionalSettingsBase, mcqPreviewComponents, mcqQuestionCommonComponents, mcqSetCorrectAnswerSection, scoringSectionBase, autoScoredAdditionalSettings, autoScoredSetCorrectAnswerSection, autoScoredScoringSection, mcqScoringComponent, previewScoringAndShowCorrectAnswerComponent, optionsWrapperComponent } from "./components";
-import { mcqOptionsComponent } from "./components/mcqOptionsComponent";
-import { questionInstructionsComponent } from "./components/questionInstructionsComponent";
+import constants from "../fixtures/constants";
+import utilities from "../support/helpers/utilities";
+import { additionalSettingsPanel, createQuestionBasePage, mcqAdditionalSettingsBase, scoringSectionBaseEditTab, autoScoredSpecifyCorrectAnswerSection, autoScoredScoringSection, optionsWrapperComponent, commonComponents, autoScoredScoringPreviewTab, autoScoredStudentViewSettings, ckEditorToolbar, equationEditorFlyout, randomizeOptionsComponent, lockUnlockOptionComponent, questionInstructionsComponent } 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 = {
     ...createQuestionBasePage,
     ...questionInstructionsComponent,
-    ...mcqOptionsComponent,
     ...additionalSettingsPanel,
-    ...mcqQuestionCommonComponents,
     ...mcqAdditionalSettingsBase,
-    ...autoScoredPreviewBase,
-    ...mcqSetCorrectAnswerSection,
-    ...scoringSectionBase,
-    ...autoScoredSetCorrectAnswerSection,
-    ...autoScoredAdditionalSettings,
-    ...previewScoringAndShowCorrectAnswerComponent,
+    ...scoringSectionBaseEditTab,
+    ...autoScoredSpecifyCorrectAnswerSection,
     ...optionsWrapperComponent,
-    optionsRadioButton: () => cy.get('input[type="radio"]')
+    ...commonComponents,
+    ...autoScoredStudentViewSettings,
+    ...autoScoredScoringPreviewTab,
+    ...randomizeOptionsComponent,
+    ...lockUnlockOptionComponent,
+    optionsRadioButton: () => cy.get('input[type="radio"]'),
+    optionsRadioButtonForSpecifyCorrectAnswer: () => cy.get('.radio-option-wrapper:visible input[type="radio"]'),
+    editTabOptionsWrapper: () => cy.get('.edit-mcq-option-wrapper'),
+    optionWrapperSpecifyCorrectAnswerSection: () => cy.get('[class*="edit-set-correct-answer"] [class*="option-wrapper"]:visible'),
+    optionsTextSpecifyCorrectAnswerSection: () => cy.get('.mcq_Label'),
+    //Preview tab
+    optionRadioButtonPreviewTab: () => cy.get('.radio-button-control input[type="radio"]'),
+    optionTextPreviewTab: () => cy.get('.mcq_Label'),
+    optionsWrapperGradingView: () => cy.get('.mcq-answer-checked .radio-option-wrapper'),
+    optionsWrapperStudentView: () => cy.get('.mcq-radio-control .radio-option-wrapper'),
+    optionWrapperPreviewTab: () => cy.get('.radio-button-control .radio-option-wrapper')
 };
 
 const steps = {
     ...createQuestionBasePage.steps,
     ...questionInstructionsComponent.steps,
-    ...mcqOptionsComponent.steps,
     ...additionalSettingsPanel.steps,
-    ...mcqQuestionCommonComponents.steps,
-    ...autoScoredAdditionalSettings.steps,
-    ...autoScoredPreviewBase.steps,
-    ...scoringSectionBase.steps,
-    ...mcqSetCorrectAnswerSection.steps,
-    ...mcqPreviewComponents.steps,
-    ...autoScoredSetCorrectAnswerSection.steps,
+    ...scoringSectionBaseEditTab.steps,
+    ...autoScoredSpecifyCorrectAnswerSection.steps,
     ...autoScoredScoringSection.steps,
-    checkCorrectAnswerRadioButton: (option) => {
-        mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(option)
+    ...commonComponents.steps,
+    ...optionsWrapperComponent.steps,
+    ...autoScoredScoringPreviewTab.steps,
+    ...autoScoredStudentViewSettings.steps,
+    ...mcqAdditionalSettingsBase.steps,
+    ...ckEditorToolbar.steps,
+    ...equationEditorFlyout.steps,
+    ...randomizeOptionsComponent.steps,
+    ...lockUnlockOptionComponent.steps,
+    /**
+               * Verifies the contents of an option wrapper in the 'Specify correct answer' section for single selection questions.
+               * @param {number} optionIndex - The index of the option wrapper to be verified.
+               */
+    verifyOptionWrapperContentsSpecifyCorrectAnswerSection: (optionIndex) => {
+        singleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
+            .eq(optionIndex)
+            .within(() => {
+                singleSelectionPage.optionsTextSpecifyCorrectAnswerSection()
+                    .should('have.text', '');
+                singleSelectionPage.optionsRadioButton()
+                    .should('not.be.checked');
+            });
+    },
+
+    /**
+    * Verifies the contents of an option wrapper in the 'Specify correct answer' section for single selection questions.
+    * @param {number} optionIndex - The index of the option wrapper to be verified.
+    */
+    verifyOptionWrapperContentsPreviewTab: (optionIndex) => {
+        singleSelectionPage.optionWrapperPreviewTab()
+            .eq(optionIndex)
+            .within(() => {
+                singleSelectionPage.optionTextPreviewTab()
+                    .should('have.text', '');
+                singleSelectionPage.optionsRadioButton()
+                    .should('not.be.checked');
+            });
+    },
+
+    verifyOptionWrapperContents: (option, count) => {
+        singleSelectionPage.editTabOptionsWrapper()
+            .eq(count)
+            .within(() => {
+                singleSelectionPage.optionsInputField()
+                    .verifyInnerText(option);
+                commonComponents.dragHandleButton()
+                    .should('be.visible');
+                commonComponents.deleteButton()
+                    .should('be.visible');
+            });
+    },
+
+    /**
+     * @description Checks the options checkbox in the 'Specify correct answer' section for single selection questions.
+     * @param {number} optionIndex - The index of the option checkbox to be checked.
+     */
+    checkOptionInSpecifyCorrectAnswerSection: (optionIndex) => {
+        singleSelectionPage.optionsRadioButtonForSpecifyCorrectAnswer()
+            .eq(optionIndex)
+            .click()
+            .should('be.checked');
+    },
+
+    /**
+    * @description Checks the options checkbox in the 'Specify correct answer' section for single selection questions.
+    * @param {number} optionIndex - The index of the option checkbox to be checked.
+    */
+    checkOptionWrapperInSpecifyCorrectAnswerSection: (optionIndex) => {
+        singleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
+            .eq(optionIndex)
+            .click()
+            .find('input')
+            .should('be.checked');
+    },
+
+    /**
+     * @description Unchecks the options radio button in the 'Specify correct answer' section for single selection questions.
+     * @param {number} optionIndex - The index of the option radio button to be unchecked.
+     */
+    uncheckOptionInSpecifyCorrectAnswerSection: (optionIndex) => {
+        singleSelectionPage.optionsRadioButtonForSpecifyCorrectAnswer()
+            .eq(optionIndex)
+            .click()
+            .should('not.be.checked');
+    },
+
+    /**
+     * Verifies that the options radio button 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.
+     */
+    verifyOptionInSpecifyCorrectAnswerUncheckedState: (optionIndex) => {
+        singleSelectionPage.optionsRadioButtonForSpecifyCorrectAnswer()
+            .eq(optionIndex)
+            .should('not.be.checked');
+    },
+
+    /**
+     * @description. Checks the option radio button in the 'Preview tab' for single selection questions
+     * @param {number} optionIndex - The index of the option radio button to be checked
+     */
+    checkOptionInPreviewTab: (optionIndex) => {
+        singleSelectionPage.optionRadioButtonPreviewTab()
+            .eq(optionIndex)
             .click()
+            .should('be.checked');
+    },
+
+    /**
+     * Verifies that the options radio button 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.
+     */
+    verifyOptionInPreviewTabUncheckedState: (optionIndex) => {
+        singleSelectionPage.optionRadioButtonPreviewTab()
+            .eq(optionIndex)
+            .should('not.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) => {
+        singleSelectionPage.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) => {
+        singleSelectionPage.optionsWrapperGradingView()
+            .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) => {
+        singleSelectionPage.optionsWrapperGradingView()
+            .eq(optionIndex)
+            .within(() => {
+                autoScoredScoringPreviewTab.steps.verifyCorrectIncorrectIconsNotExist();
+            });
+    },
+
+    /**
+     * 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) => {
+        singleSelectionPage.optionsWrapperStudentView()
+            .eq(optionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'visible');
+            });
+    },
+
+    /**
+    * 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) => {
+        singleSelectionPage.optionsWrapperStudentView()
+            .eq(optionIndex)
+            .within(() => {
+                autoScoredScoringPreviewTab.steps.verifyCorrectIncorrectIconsNotExist();
+            });
+    },
+
+    /**
+    * 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) => {
+        singleSelectionPage.optionsWrapperStudentView()
+            .eq(optionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'visible');
+            });
+    },
+
+    /**
+    * 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.
+    */
+    verifyOptionInPreviewTabUncheckedState: (optionIndex) => {
+        singleSelectionPage.optionWrapperPreviewTab()
+            .eq(optionIndex)
+            .within(() => {
+                singleSelectionPage.optionsRadioButton()
+                    .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.
+     */
+    verifyOptionInPreviewTabCheckedState: (optionIndex) => {
+        singleSelectionPage.optionWrapperPreviewTab()
+            .eq(optionIndex)
             .within(() => {
                 singleSelectionPage.optionsRadioButton()
                     .should('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) => {
+        singleSelectionPage.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) => {
+        singleSelectionPage.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) => {
+        singleSelectionPage.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) => {
+        singleSelectionPage.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) => {
+        singleSelectionPage.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) => {
+        singleSelectionPage.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) => {
+        singleSelectionPage.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) => {
+        singleSelectionPage.optionWrapperPreviewTab()
+            .eq(index)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    /**
+    * @param {string[]} optionsTextArray options array for set correct answer option
+    * @description this function verifies options text content
+    */
+    verifyOptionsTextContentInSpecifyCorrectAnswerSection: (optionsTextArray) => {
+        optionsTextArray.forEach((optionsText, index) => {
+            singleSelectionPage.optionsTextSpecifyCorrectAnswerSection()
+                .eq(index)
+                .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) => {
+            singleSelectionPage.optionTextPreviewTab()
+                .eq(index)
+                .verifyInnerText(optionsText);
+        });
+    },
+
+    getOptionsArray: () => {
+        const optionsArray = []
+        singleSelectionPage.optionTextPreviewTab()
+            .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++) {
+            singleSelectionPage.optionTextPreviewTab()
+                .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())
+                    }
+                });
+        };
+        singleSelectionPage.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) => {
+        singleSelectionPage.optionTextPreviewTab()
+            .should('not.have.text', '')
+            .and('not.have.text', previousOrderOfOptionsArray.join(''));
+    },
+
+    /**
+     * @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
+     */
+    verifyOptionInPreviewTabIsDisabled: (optionIndex) => {
+        singleSelectionPage.optionRadioButtonPreviewTab()
+            .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) => {
+        singleSelectionPage.optionRadioButtonPreviewTab()
+            .eq(optionIndex)
+            .should('not.be.disabled')
+    },
+
+    verifyOptionRadioButtonIsDisabled: (index) => {
+        singleSelectionPage.optionsRadioButton()
+            .eq(index)
+            .should('be.disabled');
     }
 };
 
 const tests = {
     ...createQuestionBasePage.tests,
     ...questionInstructionsComponent.tests,
-    ...mcqOptionsComponent.tests,
     ...additionalSettingsPanel.tests,
-    ...mcqQuestionCommonComponents.tests,
-    ...mcqAdditionalSettingsBase.tests,
-    ...scoringSectionBase.tests,
-    ...mcqSetCorrectAnswerSection.tests,
-    ...autoScoredAdditionalSettings.tests,
-    ...autoScoredSetCorrectAnswerSection.tests,
+    ...scoringSectionBaseEditTab.tests,
+    ...autoScoredSpecifyCorrectAnswerSection.tests,
     ...autoScoredScoringSection.tests,
-    ...mcqScoringComponent.tests,
-    ...previewScoringAndShowCorrectAnswerComponent.tests,
+    ...autoScoredScoringPreviewTab.tests,
+    ...optionsWrapperComponent.tests,
+    verifyContentsOfSpecifyCorrectAnswerSection: () => {
+        it('In the \'Correct\' accordion, all options with checkboxes should be displayed', () => {
+            utilities.verifyElementCount(singleSelectionPage.optionWrapperSpecifyCorrectAnswerSection(), 4);
+            options.forEach((option, index) => {
+                utilities.verifyInnerText(utilities.getNthElement(singleSelectionPage.optionsTextSpecifyCorrectAnswerSection(), index), option);
+            });
+        });
+    },
+
+    /**
+     * Verifies the contents and functionality of the 'Specify correct answer' accordion for single selection questions.
+     * @param {{'Correct' | 'Alternative'}} accordionName - The name of the accordion to be used in the validation.
+     */
+    verifySpecifyCorrectAnswerAccordionContentsAndFunctionality: (accordionName) => {
+        it(`The user should be able to check an option in the ${accordionName} accordion`, () => {
+            singleSelectionPage.steps.checkOptionInSpecifyCorrectAnswerSection(1);
+        });
+
+        it('On deleting correct answer option(s), \'Error: Please set a correct answer.\' validation error message should be thrown along with an error icon on the \'Correct\' tab', () => {
+            singleSelectionPage.steps.deleteOption(1);
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible');
+            autoScoredSpecifyCorrectAnswerSection.steps.verifySpecifyCorrectAnswerErrorIconIsVisible();
+        });
+
+        autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredCorrectAnswerErrorMessageCSSAndA11y();
+
+        it('On reselecting correct answer option(s), \'Error: Please set a correct answer.\' validation error message should disappear', () => {
+            singleSelectionPage.steps.checkOptionInSpecifyCorrectAnswerSection(1);
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage().contains('Error: Please set a correct answer.'), 'notExist');
+
+        });
+
+        autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(accordionName);
+
+        it(`CSS of ${accordionName} accordion contents`, { tags: 'css' }, () => {
+            utilities.verifyCSS(singleSelectionPage.optionsTextSpecifyCorrectAnswerSection(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(singleSelectionPage.optionsRadioButton().parent().find('svg'), {
+                'fill': css.color.secondaryBtn
+            });
+            cy.log('CSS of selected options')
+            utilities.verifyCSS(singleSelectionPage.optionWrapperSpecifyCorrectAnswerSection().eq(1), {
+                'background-color': css.color.defaultBackground,
+                'color': css.color.activeButtons,
+                'border': `2px solid ${css.color.activeComponentBorder}`
+            });
+            utilities.verifyCSS(utilities.getNthElement(singleSelectionPage.optionsTextSpecifyCorrectAnswerSection(), 1).find('.question-text-wrapper'), {
+                'color': css.color.optionsSelectedText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            singleSelectionPage.optionsRadioButton()
+                .eq(1)
+                .parent()
+                .verifyPseudoClassBeforeProperty('color', css.color.activeButtons);
+        });
+
+        it(`Accessibility of ${accordionName} accordion contents`, { tags: 'a11y' }, () => {
+            cy.checkAccessibility(singleSelectionPage.optionWrapperSpecifyCorrectAnswerSection().parents('.correct-answer-accordion'));
+        });
+    },
 };
 
 export const singleSelectionPage = {

package/cypress/pages/studentViewPage.js

@@ -1,6 +1,8 @@
 const selectors = {
     submitButton: () => cy.get('button[aria-label="Submit"]'),
     buttonGoToGradingView: () => cy.get('.action-btn-wrapper button'),
+    clearResponsesButton: () => cy.get('button[aria-label="Clear responses"]'),
+    checkAnswerButton: () => cy.get('.check-answer-button')
 }
 
 const steps = {
@@ -14,6 +16,17 @@ const steps = {
             .click();
         cy.url()
             .should('contain', 'grading-view');
+    },
+
+    clearResponses: () => {
+        studentViewPage.clearResponsesButton()
+            .click();
+    },
+
+    //Note: Remove after https://redmine.zeuslearning.com/issues/549542 is fixed
+    checkAnswer: () => {
+        studentViewPage.checkAnswerButton()
+            .click();
     }
 }