itemengine-cypress-automation 1.0.2

package/cypress/pages/components/mcqPreviewComponents.js

@@ -0,0 +1,78 @@
+import { autoScoredPreviewBase } from "./autoScoredPreviewBase";
+import { commonComponents } from "./commonComponents";
+import { mcqOptionsComponent } from "./mcqOptionsComponent";
+
+const steps = {
+    verifyCorrectOptionCheckmarkIcon: (option) => {
+        mcqOptionsComponent.previewTabOptionsWrapper(option)
+            .within(() => {
+                autoScoredPreviewBase.correctIcon()
+                    .should('be.visible');
+            });
+    },
+
+    verifyIncorrectOptionCrossmarkIcon: (option) => {
+        mcqOptionsComponent.previewTabOptionsWrapper(option)
+            .within(() => {
+                autoScoredPreviewBase.incorrectIcon()
+                    .should('be.visible');
+            });
+    },
+
+    verifyCorrectOption: (option) => {
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                mcqOptionsComponent.previewTabOptionsText()
+                    .contains(option)
+                    .parents('.mcq-option-wrapper')
+                    .within(() => {
+                        autoScoredPreviewBase.correctIcon()
+                            .should('be.visible');
+                    });
+            });
+    },
+
+    verifyIncorrectOption: (option) => {
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                mcqOptionsComponent.previewTabOptionsText()
+                    .contains(option)
+                    .parents('.mcq-option-wrapper')
+                    .within(() => {
+                        autoScoredPreviewBase.incorrectIcon()
+                            .should('be.visible');
+                    });
+            });
+    },
+
+    verifyPreviewTabOptionsText: (optionsArray) => {
+        optionsArray.forEach((optionText, count) => {
+            mcqOptionsComponent.previewTabOptionsWrapper(count)
+                .within(() => {
+                    mcqOptionsComponent.previewTabOptionsText()
+                        .verifyInnerText(optionText);
+                });
+        });
+    },
+
+    verifyPreviewTabOptionsNumeration: (optionNumerationArray, inputType) => {
+        optionNumerationArray.forEach((optionNumeration, count) => {
+            mcqOptionsComponent.previewTabOptionsWrapper(count)
+                .within(() => {
+                    mcqOptionsComponent.optionNumeration()
+                        .should('have.text', optionNumeration);
+                    if (inputType === 'radio') {
+                        mcqOptionsComponent.optionsRadioButton()
+                            .should('not.be.visible');
+                    } else if (inputType === 'checkbox') {
+                        mcqOptionsComponent.previewTabOptionsCheckbox()
+                            .should('not.be.visible');
+                    };
+                });
+        });
+    }
+}
+
+export const mcqPreviewComponents = {
+    steps
+}

package/cypress/pages/components/mcqQuestionCommonComponents.js

@@ -0,0 +1,265 @@
+import { additionalSettingsPanel } from "./additionalSettingsPanel";
+import { autoScoredSetCorrectAnswerSection } from "./autoScoredSetCorrectAnswerSection";
+import { commonComponents } from "./commonComponents";
+import { createQuestionBasePage } from "./createQuestionBasePage";
+import { mcqOptionsComponent } from "./mcqOptionsComponent";
+import { mcqSetCorrectAnswerSection } from "./mcqSetCorrectAnswerSection";
+import { questionInstructionsComponent } from "./questionInstructionsComponent";
+import { scoringSectionBase } from "./scoringSectionBase";
+const css = Cypress.env('css');
+
+const selectors = {
+    shuffleOptionCheckbox: () => cy.get('[data-ngie-testid="shuffle-option-order-checkbox"] input'),
+    shuffleOptionLabel: () => cy.get('[data-ngie-testid="shuffle-option-order-checkbox"] .MuiFormControlLabel-label')
+}
+
+const steps = {
+    verifyShuffleOptionOrder: (optionArray, numberOfOptions) => {
+        let currentOptions = [...optionArray]
+        let optionsString = currentOptions.join('');
+        for (let index = 0; index < numberOfOptions; index++) {
+            mcqOptionsComponent.previewTabOptionsWrapper(index)
+                .within(() => {
+                    mcqOptionsComponent.previewTabOptionsText()
+                        .then(($element) => {
+                            expect($element.text()).to.be.oneOf(currentOptions);
+                            currentOptions = currentOptions.filter((value) => value !== $element.text())
+                        });
+                });
+        };
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                mcqOptionsComponent.previewTabOptionsText()
+                    .should('not.have.text', optionsString);
+            });
+    }
+}
+
+const tests = {
+    verifyCompulsoryFieldsErrorMessages: () => {
+        it('Validation error messages should be displayed below required input fields', () => {
+            questionInstructionsComponent.questionInstructionsLabelEditTab()
+                .parents('.edit-question-instruction-wrapper')
+                .within(() => {
+                    commonComponents.errorMessage()
+                        .should('be.visible')
+                        .verifyInnerText('Error: Question instructions are required.');
+                });
+            for (let index = 0; index < 4; index++) {
+                mcqOptionsComponent.editTabOptionsWrapper(index)
+                    .within(() => {
+                        commonComponents.errorMessage()
+                            .verifyInnerText('Error: Option is required.');
+                    });
+            };
+            scoringSectionBase.pointsLabel()
+                .parents('.points-wrapper')
+                .within(() => {
+                    commonComponents.errorMessage()
+                        .verifyInnerText('Error: Please enter points.');
+                });
+            autoScoredSetCorrectAnswerSection.setCorrectAnswerErrorIcon()
+                .should('have.text', 'Error-Icon');
+            mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(0)
+                .parents('.edit-set-correct-answer-mcq-control')
+                .within(() => {
+                    commonComponents.errorMessage()
+                        .verifyInnerText('Error: Please set a correct answer.');
+                });
+        });
+
+        it('Validation error messages should disappear when required input fields are filled', () => {
+            //Question instructions error message
+            questionInstructionsComponent.steps.addQuestionInstructions();
+            questionInstructionsComponent.questionInstructionsLabelEditTab()
+                .parents('.edit-question-instruction-wrapper')
+                .within(() => {
+                    commonComponents.errorMessage()
+                        .should('not.exist');
+                });
+            //Options error message
+            mcqOptionsComponent.steps.addOptionsText(4);
+            mcqOptionsComponent.editTabOptionsWrapper(0)
+                .parents('.edit-mcq-options-wrapper')
+                .within(() => {
+                    commonComponents.errorMessage()
+                        .should('not.exist');
+                });
+            //Set correct answer error messages
+            mcqSetCorrectAnswerSection.steps.setCorrectAnswers(2);
+            scoringSectionBase.steps.allotPoints(20);
+            scoringSectionBase.pleaseEnterPointsErrorMessage()
+                .should('not.exist');
+            mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(0)
+                .parents('.edit-set-correct-answer-mcq-control')
+                .within(() => {
+                    commonComponents.errorMessage()
+                        .should('not.exist');
+                });
+            autoScoredSetCorrectAnswerSection.setCorrectAnswerErrorIcon()
+                .should('not.exist');
+        });
+
+        commonComponents.tests.verifya11yOfCreateItemWrapperContents();
+    },
+
+    verifyCSSanda11yOfSelectedNumericalInCorrectAnswerSectionAndPreviewTab: () => {
+        it('CSS of selected state of options and numbers in the \'Set Correct Answer\' section as well as in the \'Preview\' tab', { tags: 'css' }, () => {
+            cy.log('Selecting an option in Preview tab to check CSS of selected option')
+            mcqOptionsComponent.previewTabOptionsWrapper(0)
+                .click()
+                .within(() => {
+                    mcqOptionsComponent.optionNumeration()
+                        .verifyCSS(css.color.whiteText, css.fontSize.default, css.fontWeight.bold)
+                        .should('have.css', 'background-color', css.color.optionsSelectedText);
+                    mcqOptionsComponent.previewTabOptionsText()
+                        .verifyCSS(css.color.optionsSelectedText, css.fontSize.default, css.fontWeight.bold)
+                        .parents('[data-ngie-testid="response-option-checkbox"]')
+                        .should('have.css', 'background-color', css.color.defaultBackground)
+                        .and('have.css', 'border', `2px solid ${css.color.activeComponentBorder}`);
+                });
+            cy.log('Switching to Edit tab')
+            createQuestionBasePage.steps.switchToEditTab();
+            cy.log('Selecting an option in Correct answer section to check CSS of selected option')
+            mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(0)
+                .click()
+                .within(() => {
+                    mcqOptionsComponent.optionNumeration()
+                        .verifyCSS(css.color.whiteText, css.fontSize.default, css.fontWeight.bold)
+                        .should('have.css', 'background-color', css.color.optionsSelectedText);
+                    mcqOptionsComponent.editTabOptionsText()
+                        .verifyCSS(css.color.optionsSelectedText, css.fontSize.default, css.fontWeight.bold)
+                        .parents('[data-ngie-testid="response-option-checkbox"]')
+                        .should('have.css', 'background-color', css.color.defaultBackground)
+                        .and('have.css', 'border', `2px solid ${css.color.activeComponentBorder}`);
+                });
+            cy.log('Post step: Deselecting the options and switching to Preview tab')
+            mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(0)
+                .click();
+            createQuestionBasePage.steps.switchToPreviewTab();
+        });
+
+        it('Accessibility of selected state of options and numbers in the \'Set Correct Answer\' section as well as in the \'Preview\' tab', { tags: 'a11y' }, () => {
+            cy.log('Selecting an option in Preview tab to check accessibility of Preview tab options')
+            mcqOptionsComponent.previewTabOptionsWrapper(0)
+                .click();
+            cy.checkAccessibility(commonComponents.previewTabQuestionWrapper());
+            cy.log('Switching to Edit tab')
+            createQuestionBasePage.steps.switchToEditTab();
+            cy.log('Selecting an option in Correct answer section to check Accessibility Correct answer section options')
+            mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(0)
+                .click();
+            cy.checkAccessibility(mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(0).parents('.mcq_Group'));
+            cy.log('Post step:Deselecting option and switching to Preview tab')
+            mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(0)
+                .click();
+            createQuestionBasePage.steps.switchToPreviewTab();
+        });
+    },
+
+    verifyEditTabCorrectAnswerSectionAndPreviewTabFontSize: () => {
+        //TODO: Comment: we'll need to move to object loopings in case of 2 parameters please ask for more details
+        const fontsizes = ['Default', 'Small', 'Normal', 'Large', 'Extra large', 'Huge'];
+        const font = ['16px', '12px', '14px', '17px', '20px', '24px'];
+        fontsizes.forEach((option, count) => {
+            it(`When the user selects \'${option}\' option from the Font Size dropdown, then font size of the preview (options, question instructions and check answer button) should be changed to ${option} in the \'Set Correct Answer\' section as well as in the \'Preview\' tab`, () => {
+                additionalSettingsPanel.fontSizeDropdown()
+                    .click();
+                additionalSettingsPanel.fontSizeListOptions(count)
+                    .click();
+                additionalSettingsPanel.fontSizeDropdown()
+                    .verifyInnerText(`${option}`);
+                cy.log('Checking correct answer section font size')
+                mcqOptionsComponent.editTabOptionsText()
+                    .each(($element) => {
+                        expect($element).to.have.css('font-size', font[count]);
+                    });
+                cy.log('Switching to Preview tab')
+                createQuestionBasePage.steps.switchToPreviewTab();
+                cy.log('Checking Preview section font size')
+                questionInstructionsComponent.questionInstructionsText()
+                    .should('have.css', 'font-size', font[count]);
+                commonComponents.previewTabQuestionWrapper()
+                    .within(() => {
+                        mcqOptionsComponent.editTabOptionsText()
+                            .each(($element) => {
+                                expect($element).to.have.css('font-size', font[count]);
+                            });
+                    });
+                cy.log('Post step: Switch to Edit tab')
+                createQuestionBasePage.steps.switchToEditTab();
+            });
+        });
+    },
+
+    verifyShuffleOptionOrderFunctionality: () => {
+        let options = ['Pollution caused by treating chemical waste', 'Pollution caused by cement production', 'Pollution caused by methane production', 'Pollution caused by cement and methane production'];
+        let shuffledOptions = '';
+        it('\'Shuffle option order\' checkbox should be present and by default \'Shuffle option order\' checkbox should be unchecked', () => {
+            mcqQuestionCommonComponents.shuffleOptionCheckbox()
+                .should('not.be.checked');
+        });
+
+        it('User should be able to shuffle answer options for students using \'Shuffle option order\' checkbox and The options should get shuffled in the \'Preview\' tab', () => {
+            mcqQuestionCommonComponents.shuffleOptionCheckbox()
+                .click()
+                .should('be.checked');
+            createQuestionBasePage.steps.switchToPreviewTab()
+            mcqQuestionCommonComponents.steps.verifyShuffleOptionOrder(options, 4)
+        });
+
+        it('When user switches to Edit tab and makes no changes (edit/updates) and switches back to the Preview tab, the options should not get shuffled, ', () => {
+            commonComponents.previewTabQuestionWrapper()
+                .within(() => {
+                    mcqOptionsComponent.editTabOptionsText()
+                        .then(($element) => {
+                            shuffledOptions = $element.text();
+                        });
+                });
+            createQuestionBasePage.steps.switchToEditTab()
+            createQuestionBasePage.steps.switchToPreviewTab()
+            commonComponents.previewTabQuestionWrapper()
+                .within(() => {
+                    mcqOptionsComponent.previewTabOptionsText()
+                        .should('have.text', shuffledOptions);
+                });
+        });
+
+        it('When user switches to Edit tab and makes some changes (edit/updates) and switches back to the Preview tab, the options should get re-shuffled', () => {
+            createQuestionBasePage.steps.switchToEditTab()
+            scoringSectionBase.pointsInputField()
+                .clear()
+                .type('10')
+                .should('have.value', '10');
+            createQuestionBasePage.steps.switchToPreviewTab()
+            mcqQuestionCommonComponents.steps.verifyShuffleOptionOrder(options, 4);
+            commonComponents.previewTabQuestionWrapper()
+                .within(() => {
+                    mcqOptionsComponent.previewTabOptionsText()
+                        .should('not.have.text', shuffledOptions);
+                });
+        });
+
+        it('CSS of Shuffle option order', { tags: 'css' }, () => {
+            cy.log('Pre-step: switching back to the edit tab')
+            createQuestionBasePage.steps.switchToEditTab()
+            mcqQuestionCommonComponents.shuffleOptionCheckbox()
+                .parent()
+                .find('svg g g')
+                .should('have.css', 'fill', css.color.activeButtons);
+            mcqQuestionCommonComponents.shuffleOptionLabel()
+                .verifyCSS(css.color.labelText, css.fontSize.normal, css.fontWeight.regular);
+            cy.log('Post step: Deselecting Shuffle option order checkbox')
+            mcqQuestionCommonComponents.shuffleOptionCheckbox()
+                .click()
+            cy.log('Pre-step: switching back to the preview tab')
+            createQuestionBasePage.steps.switchToPreviewTab();
+        });
+    }
+}
+
+export const mcqQuestionCommonComponents = {
+    ...selectors,
+    steps,
+    tests
+}

package/cypress/pages/components/mcqScoringComponent.js

@@ -0,0 +1,120 @@
+import { autoScoredPreviewBase } from "./autoScoredPreviewBase";
+import { createQuestionBasePage } from "./createQuestionBasePage";
+import { scoringSectionBase } from "./scoringSectionBase";
+import { mcqSetCorrectAnswerSection } from "./mcqSetCorrectAnswerSection";
+import { mcqOptionsComponent } from "./mcqOptionsComponent";
+import { mcqPreviewComponents } from "./mcqPreviewComponents";
+import { previewScoringAndShowCorrectAnswerComponent } from "./previewScoringAndShowCorrectAnswerComponent";
+
+const tests = {
+    verifyMCQShowCorrectAnswerFunctionality: (questionType) => {
+        it('When the user has set correct answer option(s) and alloted points \'Show correct answer\' checkbox should be displayed and it should be unchecked by default and points for the question should be displayed beside it', () => {
+            createQuestionBasePage.steps.switchToEditTab();
+            switch (questionType) {
+                case 'multiple selection':
+                    mcqSetCorrectAnswerSection.steps.setCorrectAnswers(2);
+                    break;
+                case 'single selection':
+                    mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(1)
+                        .click();
+                    break;
+                default:
+                    throw new Error('Invalid question type');
+            }
+            scoringSectionBase.steps.allotPoints(20);
+            createQuestionBasePage.steps.switchToPreviewTab();
+            previewScoringAndShowCorrectAnswerComponent.showCorrectAnswerCheckbox()
+                .should('not.be.checked')
+                .parents('.MuiIconButton-label')
+                .should('be.visible');
+            previewScoringAndShowCorrectAnswerComponent.showCorrectAnswerCheckboxLabel()
+                .verifyInnerText('Show correct answer');
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .verifyInnerText('0/20');
+        });
+
+        it('When the user attempts question in preview tab and switches to edit tab, then on re-switching to the preview tab users response should not persist', () => {
+            cy.log('Attempting the question in preview tab to verify')
+            switch (questionType) {
+                case 'multiple selection':
+                    mcqOptionsComponent.previewTabOptionsWrapper(0)
+                        .click()
+                        .within(() => {
+                            mcqOptionsComponent.previewTabOptionsCheckbox()
+                                .should('be.checked');
+                        });
+                    break;
+                case 'single selection':
+                    mcqOptionsComponent.previewTabOptionsWrapper(0)
+                        .click()
+                        .within(() => {
+                            mcqOptionsComponent.optionsRadioButton()
+                                .should('be.checked');
+                        });
+                    break;
+                default:
+                    throw new Error('Invalid question type');
+            }
+            cy.log('Re-switching to Preview tab and checking options')
+            createQuestionBasePage.steps.switchToEditTab();
+            createQuestionBasePage.steps.switchToPreviewTab();
+            switch (questionType) {
+                case 'multiple selection':
+                    mcqOptionsComponent.previewTabOptionsWrapper(0)
+                        .within(() => {
+                            mcqOptionsComponent.previewTabOptionsCheckbox()
+                                .should('not.be.checked');
+                        });
+                    break;
+                case 'single selection':
+                    mcqOptionsComponent.previewTabOptionsWrapper(0)
+                        .within(() => {
+                            mcqOptionsComponent.optionsRadioButton()
+                                .should('not.be.checked');
+                        });
+                    break;
+                default:
+                    throw new Error('Invalid question type');
+            }
+        });
+
+        it('When the user selects \'Show correct answer\' checkbox without attempting the question, green checkmark icon should be displayed besides correct answer option(s), no correct answer border should appear and no label should be displayed below the option(s)', () => {
+            previewScoringAndShowCorrectAnswerComponent.showCorrectAnswerCheckbox()
+                .click()
+                .should('be.checked');
+            switch (questionType) {
+                case 'multiple selection':
+                    mcqPreviewComponents.steps.verifyCorrectOptionCheckmarkIcon(0);
+                    mcqPreviewComponents.steps.verifyCorrectOptionCheckmarkIcon(1);
+                    autoScoredPreviewBase.steps.verifyCorrectIncorrectBorderNotExists();
+                    break;
+                case 'single selection':
+                    mcqPreviewComponents.steps.verifyCorrectOptionCheckmarkIcon(1);
+                    break;
+                default:
+                    throw new Error('Invalid question type');
+            }
+            autoScoredPreviewBase.correctIncorectAnswerLabel()
+                .should('not.exist');
+        });
+    },
+
+    verifyMinimumScoreAwardedForIncorrectAnswer: (totalPoints) => {
+        it('When user has provided minimum score awarded (if attempted) points, then in Preview tab on entering incorrect answer, minimum score should be provided for the question', () => {
+            cy.log('Switch to edit tab and set minimum score if attempted points')
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.minimumScoreIfAttemptedInputField()
+                .type('1')
+                .should('have.value', '1');
+            createQuestionBasePage.steps.switchToPreviewTab()
+            mcqOptionsComponent.previewTabOptionsWrapper(3)
+                .click();
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .verifyInnerText(`1/${totalPoints}`);
+        });
+    }
+}
+
+export const mcqScoringComponent = {
+    tests
+}

package/cypress/pages/components/mcqSetCorrectAnswerSection.js

@@ -0,0 +1,143 @@
+import { commonComponents } from "./commonComponents";
+import { mcqOptionsComponent } from "./mcqOptionsComponent";
+import { questionInstructionsComponent } from "./questionInstructionsComponent";
+import { autoScoredSetCorrectAnswerSection } from "./autoScoredSetCorrectAnswerSection";
+const css = Cypress.env('css');
+
+const selectors = {
+    correctAnswerOptionsWrapper: (optionNumber) => cy.get('.edit-question-edit-tab-wrapper [class*="edit-set-correct-answer"] div[class*="option-wrapper"]').eq(optionNumber),
+    optionsRadioButton: () => cy.get('input[type="radio"]')
+}
+
+const steps = {
+    setCorrectAnswers: (CorrectAnswers) => {
+        for (let index = 0; index < CorrectAnswers; index++) {
+            mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(index)
+                .click();
+        }
+    },
+
+    checkUncheckCorrectAnswer: (option, checkedUnchecked) => {
+        mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(option)
+            .click()
+            .within(() => {
+                mcqOptionsComponent.editTabOptionsCheckbox()
+                    .should(checkedUnchecked);
+            });
+    },
+
+    checkCorrectAnswerRadioButton: (option) => {
+        //TODO: Move to Single selection POM
+        mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(option)
+            .click()
+            .within(() => {
+                mcqOptionsComponent.optionsRadioButton()
+                    .should('be.checked');
+            });
+    },
+
+    verifyEditTabCorrectAnswerSectionOptionsText: (optionsArray) => {
+        optionsArray.forEach((optionText, count) => {
+            mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(count)
+                .within(() => {
+                    mcqOptionsComponent.editTabOptionsText()
+                        .verifyInnerText(optionText);
+                });
+        });
+    },
+
+    verifyEditTabCorrectAnswerSectionOptionsNumeration: (optionNumerationArray, inputType) => {
+        optionNumerationArray.forEach((optionNumeration, count) => {
+            mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(count)
+                .within(() => {
+                    mcqOptionsComponent.optionNumeration()
+                        .should('have.text', optionNumeration);
+                    if (inputType === 'radio') {
+                        mcqOptionsComponent.optionsRadioButton()
+                            .should('not.be.visible');
+                    } else if (inputType === 'checkbox') {
+                        mcqOptionsComponent.editTabOptionsCheckbox()
+                            .should('not.be.visible');
+                    };
+                });
+        });
+    }
+}
+
+const tests = {
+    verifyCorrectAnswerSection: (inputType) => {
+        it(`In the Set Correct Answer section, all the 4 empty options with ${inputType} should be displayed`, () => {
+            for (let index = 0; index < 4; index++) {
+                mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(index)
+                    .within(() => {
+                        if (inputType === 'radio') {
+                            mcqOptionsComponent.optionsRadioButton()
+                                .should('not.be.checked');
+                        } else if (inputType === 'checkbox') {
+                            mcqOptionsComponent.editTabOptionsCheckbox()
+                                .should('not.be.checked');
+                        };
+                        mcqOptionsComponent.editTabOptionsText()
+                            .verifyInnerText('');
+                    });
+            };
+        });
+
+        it('Pre-step: Adding question instructions and options', () => {
+            questionInstructionsComponent.steps.addQuestionInstructions()
+            mcqOptionsComponent.steps.addOptionsText(4)
+        });
+
+        it(`User should be able to set correct answer by checking the ${inputType} besides the options`, () => {
+            if (inputType === 'radio') {
+                mcqSetCorrectAnswerSection.steps.checkCorrectAnswerRadioButton(1);
+            } else if (inputType === 'checkbox') {
+                mcqSetCorrectAnswerSection.steps.setCorrectAnswers(2);
+            };
+        });
+
+        it('CSS of Set answer in the Correct answer tab', { tags: 'css' }, () => {
+            mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(1)
+                .find('label')
+                .verifyCSS(css.color.optionsSelectedText, css.fontSize.default, css.fontWeight.bold)
+                .should('have.css', 'background-color', css.color.defaultBackground);
+        });
+
+        it('Accessibility of Set answer in the Correct answer tab', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(0).parents('.mcq_Group'));
+        });
+    },
+
+    verifyCorrectAnswerSectionErrorMessages: () => {
+        autoScoredSetCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty('Correct tab');
+
+        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', () => {
+            mcqOptionsComponent.editTabOptionsWrapper(0)
+                .within(() => {
+                    commonComponents.deleteButton()
+                        .click();
+                    commonComponents.deleteButton()
+                        .click();
+                });
+            commonComponents.errorMessage()
+                .should('be.visible');
+            autoScoredSetCorrectAnswerSection.setCorrectAnswerErrorIcon()
+                .should('be.visible');
+        });
+
+        autoScoredSetCorrectAnswerSection.tests.verifyCSSAndA11yOfAutoScoredSetCorrectAnswerErrorMessage();
+
+        it('On reselecting correct answer option(s), \'Error: Please set a correct answer.\' validation error message should disappear', () => {
+            mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(1)
+                .click();
+            commonComponents.errorMessage()
+                .should('not.exist');
+        });
+    }
+}
+
+export const mcqSetCorrectAnswerSection = {
+    ...selectors,
+    steps,
+    tests
+}