itemengine-cypress-automation 1.0.247-06SeptUpdates-b1623d7.0 → 1.0.247

package/cypress/pages/components/autoScoredScoringSection.js

@@ -1,199 +0,0 @@
-import { autoScoredPreviewBase } from "./autoScoredPreviewBase";
-import { autoScoredSetCorrectAnswerSection } from "./autoScoredSetCorrectAnswerSection";
-import { createQuestionBasePage } from "./createQuestionBasePage";
-import { scoringSectionBase } from "./scoringSectionBase";
-import { commonComponents } from "./commonComponents";
-import { previewScoringAndShowCorrectAnswerComponent } from "./previewScoringAndShowCorrectAnswerComponent";
-const css = Cypress.env('css');
-//Note: deprecated file
-const steps = {
-    correctIncorrectLabelAndBorderExists: (questionType) => {
-        switch (questionType) {
-            case 'multiple selection':
-                return true;
-            case 'single selection':
-                return false;
-            case 'fill in the gaps - text':
-                return true;
-            case 'fill in the gaps - dropdown':
-                return true;
-            case 'fill in the gaps - drag and drop':
-                return true;
-            case 'short text response':
-                return false;
-            case 'fill in the gaps - drag and drop':
-                return true;
-            case 'list matching':
-                return true;
-            case 'list ordering':
-                return true;
-            case 'list sorting':
-                return true;
-            case 'highlight':
-                return true;
-            case 'fill in the gaps over image - text':
-                return true;
-            case 'fill in the gaps over image - dropdown':
-                return true;
-            default:
-                throw new Error('Invalid question type');
-        }
-    },
-
-    verifyPreviewTabPointsBackgroundForIncorrectOrPartiallyCorrectAnswer: () => {
-        previewScoringAndShowCorrectAnswerComponent.previewScoreText()
-            .should('have.css', 'color', css.color.text)
-            .and('not.have.css', 'background-color', css.color.correctAnswer);
-    },
-
-    verifyPreviewTabPointsBackgroundForCorrectAnswer: () => {
-        previewScoringAndShowCorrectAnswerComponent.previewScoreText()
-            .should('have.css', 'color', css.color.whiteText)
-            .and('have.css', 'background-color', css.color.correctAnswer);
-    }
-}
-
-const tests = {
-    verifyAutoScoredAllOrNothingPointsAndMinimumScoreAwardedLabelAndInputField: () => {
-        it('When the user selects \'Auto Scored\' option from the Scoring Type dropdown, then \'Points\' and \'Minimum score awarded (if attempted)\' labels and input fields should be displayed', () => {
-            scoringSectionBase.pointsLabel()
-                .verifyInnerText('Points')
-                .and('be.visible');
-            scoringSectionBase.pointsInputField()
-                .should('have.value', '')
-                .and('be.visible');
-            scoringSectionBase.steps.expandMinimumScoringDropdown();
-            scoringSectionBase.steps.selectMinimumScoringTypeListOption('Award minimum score only if attempted');
-            scoringSectionBase.minimumScoreIfAttemptedLabel()
-                .verifyInnerText('Minimum points')
-                .and('be.visible');
-            scoringSectionBase.minimumScoreIfAttemptedInputField()
-                .should('have.value', '')
-                .and('be.visible');
-        });
-
-        it('CSS of \'Points\' and \'Minimum score awarded (if attempted)\' labels', { tags: 'css' }, () => {
-            scoringSectionBase.minimumScoreIfAttemptedLabel()
-                .verifyCSS(css.color.labels, css.fontSize.normal, css.fontWeight.semibold);
-            scoringSectionBase.pointsLabel()
-                .verifyCSS(css.color.labels, css.fontSize.normal, css.fontWeight.semibold);
-        });
-
-        it('Accessibility of \'Points\' and \'Minimum score awarded (if attempted)\' labels and input fields', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(scoringSectionBase.minimumScoreIfAttemptedInputField());
-            cy.checkAccessibility(scoringSectionBase.pointsInputField());
-        });
-    },
-
-    verifyEditTabNonScoredScoringSectionContents: () => {
-        it('When the user selects \'Non Scored\' option from the Scoring Type dropdown, then the \'Set Correct Answer\' section should be displayed and \'Points\' input field should be displayed in disabled state with prefilled \'0\' points and \'Minimum score awarded (if attempted)\' input field should not be displayed', () => {
-            scoringSectionBase.steps.selectAScoringTypeFromScoringTypeDropdown('Non scored');
-            autoScoredSetCorrectAnswerSection.setCorrectAnswerLabel()
-                .should('be.visible');
-            autoScoredSetCorrectAnswerSection.correctTab()
-                .should('be.visible');
-            scoringSectionBase.pointsLabel()
-                .should('be.visible')
-                .verifyInnerText('Points');
-            scoringSectionBase.pointsInputField()
-                .should('have.value', '0')
-                .should('be.disabled');
-            scoringSectionBase.minimumScoringDropdown()
-                .should('not.exist');
-        });
-
-        it('Accessibility of disabled Points field', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(scoringSectionBase.pointsLabel().parents('.set-correct-answer-points-wrapper'));
-        });
-    },
-
-    verifyShowCorrectAnswerAndPointsInPreviewTabWhenNoCorrectAnswerIsSet: () => {
-        it('When the user has not set correct answer option(s) and alloted points, \'Student view\' radio button should be checked, \'Grading view\' button should not be checked, 0 points should be displayed and no correct or incorrect icons should be displayed in the preview tab', () => {
-            createQuestionBasePage.steps.switchToPreviewTab();
-            previewScoringAndShowCorrectAnswerComponent.studentViewRadioButton()
-                .should('be.checked');
-            previewScoringAndShowCorrectAnswerComponent.gradingViewRadioButton()
-                .should('not.be.checked');
-            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
-                .should('have.text', '0/0');
-            autoScoredPreviewBase.correctIcon()
-                .should('not.exist');
-            autoScoredPreviewBase.incorrectIcon()
-                .should('not.exist');
-        });
-    },
-
-    verifyCSSAndA11yOfCorrectAnswerIcon: () => {
-        it('Check CSS of correct answer icon', { tags: 'css' }, () => {
-            for (let index = 0; index < 2; index++) {
-                autoScoredPreviewBase.correctIcon()
-                    .verifyPseudoClassBeforeProperty('color', css.color.correctAnswer);
-            };
-        });
-
-        it('Accessibility of correct answer icon', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(autoScoredPreviewBase.correctIcon());
-        });
-    },
-
-    verifyCSSAndA11yOfFullScoreTextAndCorrectAnswerLabel: (questionType) => {
-        it('CSS of check score text full score state and Correct Answer label', { tags: 'css' }, () => {
-            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
-                .should('have.css', 'color', css.color.primaryBtn)
-                .and('have.css', 'background-color', css.color.correctAnswer)
-            if (steps.correctIncorrectLabelAndBorderExists(questionType)) {
-                autoScoredPreviewBase.correctIncorrectAnswerLabel()
-                    .verifyCSS(css.color.correctAnswer, css.fontSize.normal, css.fontWeight.bold)
-                    .parent()
-                    .find('.icon-correct')
-                    .verifyPseudoClassBeforeProperty('color', css.color.correctAnswer);
-                autoScoredPreviewBase.steps.verifyCorrectAttemptBorder();
-            } else {
-                autoScoredPreviewBase.correctIncorrectAnswerLabel()
-                    .should('not.exist');
-                autoScoredPreviewBase.correctIncorrectAnswerBorder()
-                    .should('not.exist');
-            }
-        });
-
-        it('Accessibility of check score text full score state and Correct Answer label', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(commonComponents.previewTabQuestionWrapper());
-        });
-    },
-
-    verifyCSSAndA11yOfIncorrectAnswerLabel: (questionType) => {
-        it('CSS of incorrect answer state', { tags: 'css' }, () => {
-            cy.log('Pre requisite: The user has attempted the question incorrectly')
-            cy.log('Pre step: Select show answer checkbox')
-            previewScoringAndShowCorrectAnswerComponent.steps.checkShowCorrectAnswerCheckbox();
-            cy.log('Verifying CSS of incorrect crossmark icon')
-            autoScoredPreviewBase.incorrectIcon()
-                .eq(0)
-                .verifyPseudoClassBeforeProperty('color', css.color.incorrectAnswer);
-            if (steps.correctIncorrectLabelAndBorderExists(questionType)) {
-                autoScoredPreviewBase.correctIncorrectAnswerLabel()
-                    .verifyCSS(css.color.incorrectAnswer, css.fontSize.normal, css.fontWeight.bold)
-                    .parent()
-                    .find('.icon-incorrect')
-                    .verifyPseudoClassBeforeProperty('color', css.color.incorrectAnswer);
-                autoScoredPreviewBase.steps.verifyIncorrectAttemptBorder();
-            } else {
-                autoScoredPreviewBase.correctIncorrectAnswerLabel()
-                    .should('not.exist');
-                autoScoredPreviewBase.correctIncorrectAnswerBorder()
-                    .should('not.exist');
-            }
-        });
-
-        it('Accessibility of incorrect answer state', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(commonComponents.previewTabQuestionWrapper());
-            cy.log('Post step: Deselect show answer checkbox')
-            previewScoringAndShowCorrectAnswerComponent.steps.uncheckShowCorrectAnswerCheckbox();
-        });
-    }
-}
-
-export const autoScoredScoringSection = {
-    tests,
-    steps
-}

package/cypress/pages/components/autoScoredScoringSectionMultipleResponsesType.js

@@ -1,377 +0,0 @@
-import utilities from "../../support/helpers/utilities";
-import { commonComponents } from "./commonComponents";
-import { scoringSectionBase } from "./scoringSectionBase";
-const css = Cypress.env('css');
-//Note: deprecated file
-const selectors = {
-    allOrNothingCheckboxLabel: () => cy.get('label[for*="defaultScoring"]'),
-    allOrNothingCheckbox: () => cy.get('input[type*="radio"][aria-label="All or Nothing"]'),
-    partialDifferentWeightsCheckboxLabel: () => cy.get('label[for*="partialScoring"]'),
-    partialDifferentWeightsCheckbox: () => cy.get('input[type*="radio"][aria-label="Partial - different weights"]'),
-    partialEqualWeightsCheckbox: () => cy.get('input[type="radio"][aria-label="Partial - equal weights"]'),
-    partialEqualWeightsCheckboxLabel: () => cy.get('label[for*="partialEqualScoring"]'),
-    pointsPerResponseLabel: () => cy.get('[class*="PartialPointsPerResponseLabel"]'),
-    partialEqualWeightsPointsPerResponseScore: () => cy.get('[class*="EqualPoints"]'),
-    penaltyPointsLabel: () => cy.get('.penalty-points-label'),
-    penaltyPointsInputField: () => cy.get('.penlty-points-input-field [type="text"]'),
-    rounddownScoreCheckboxLabel: () => cy.get('#rounding-dropdown-label'),
-    rounddownScoreCheckbox: () => cy.get('[data-ngie-testid="round-down-score-checkbox"] input'),
-    roundingLabel: () => cy.get('#rounding-dropdown-label'),
-    roundingDropdown: () => cy.get('#rounding-select'),
-    roundingDropdownListOptions: (ariaLabel = null) => {
-        if (ariaLabel) {
-            return cy.get(`[aria-labelledby*="rounding-dropdown-label"] [role="option"][aria-label*="${ariaLabel}"]`)
-        } else {
-            return cy.get('[aria-labelledby*="rounding-dropdown-label"] [role="option"]')
-        }
-    },
-    penaltyScoringLabel: () => cy.get('#penalty-scoring-dropdown-label'),
-    penaltyScoringDropdown: () => cy.get('#penalty-scoring-select'),
-    penaltyScoringDropdownListOptions: (ariaLabel = null) => {
-        if (ariaLabel) {
-            return cy.get(`[aria-labelledby*="penalty-scoring-dropdown-label"] [role="option"][aria-label*="${ariaLabel}"]`)
-        } else {
-            return cy.get('[aria-labelledby*="penalty-scoring-dropdown-label"] [role="option"]')
-        }
-    },
-    minimumPointsLabel: () => cy.get('.min-score-points-label'),
-    minimumPointsInputField: () => cy.get('.min-score-points-input-field input'),
-    roundNegativeScoresToZeroCheckboxLabel: () => cy.get('[data-ngie-testid="round-negative-scores-to-zero-checkbox"]'),
-    roundNegativeScoresToZeroCheckbox: () => cy.get('[data-ngie-testid="round-negative-scores-to-zero-checkbox"] input'),
-}
-
-const steps = {
-    //V3 - This function should be updated in all files
-    selectAllOrNothingCheckbox: () => {
-        autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckbox()
-            .click()
-            .should('be.checked');
-    },
-
-    //V3 - This function should be updated in all files
-    selectPartialEqualWeightsCheckbox: () => {
-        autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckbox()
-            .click()
-            .should('be.checked');
-    },
-
-    //V3 - This function should be updated in all files
-    selectPartialDifferentWeightsCheckbox: () => {
-        autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckbox()
-            .click()
-            .should('be.checked');
-    },
-
-    //V3 - This function should be updated in all files
-    verifyDefaultPenaltyPointsInputFieldAndLabel: () => {
-        autoScoredScoringSectionMultipleResponsesType.steps.expandPenaltyScoringDropdown();
-        autoScoredScoringSectionMultipleResponsesType.steps.selectOptionFromPenaltyScoringDropdown('Penalty points for the entire question');
-        autoScoredScoringSectionMultipleResponsesType.penaltyPointsLabel()
-            .verifyInnerText('Penalty points')
-            .should('be.visible');
-        autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
-            .should('have.value', '')
-            .and('be.visible');
-    },
-
-    //V3 - This function should be updated in all files
-    verifyDefaultRoundDownScoreCheckboxCheckedAndLabel: () => {
-        autoScoredScoringSectionMultipleResponsesType.rounddownScoreCheckboxLabel()
-            .verifyInnerText('Rounding')
-            .and('be.visible');
-        autoScoredScoringSectionMultipleResponsesType.roundingDropdown()
-            .verifyInnerText('None');
-    },
-
-    expandRoundingDropdown: () => {
-        autoScoredScoringSectionMultipleResponsesType.roundingDropdown()
-            .click();
-    },
-
-    /**
-     * @param {("none" | "round down if <= 0.99" | "round down if <= 0.50"|"round down if <= 0.50; Round up if > 0.50")} dropdownOption aria-label of dropdown options
-     * @description this function selects dropdown option from rounding dropdown
-     */
-    selectOptionFromRoundingDropdownOption: (dropdownOption) => {
-        autoScoredScoringSectionMultipleResponsesType.roundingDropdownListOptions(dropdownOption)
-            .click();
-    },
-
-    expandPenaltyScoringDropdown: () => {
-        autoScoredScoringSectionMultipleResponsesType.penaltyScoringDropdown()
-            .click();
-    },
-
-    /**
-     * @param {("No penalty points" | "Penalty points for the entire question" | "Penalty points for each incorrect option")} dropdownOption aria-label of dropdown options
-     * @description this function selects dropdown option from penalty points dropdown
-     */
-    selectOptionFromPenaltyScoringDropdown: (dropdownOption) => {
-        autoScoredScoringSectionMultipleResponsesType.penaltyScoringDropdownListOptions(dropdownOption)
-            .click();
-    },
-
-    //V3 - This function should be updated in all files
-    allotPenaltyPoints: (points) => {
-        autoScoredScoringSectionMultipleResponsesType.steps.expandPenaltyScoringDropdown();
-        autoScoredScoringSectionMultipleResponsesType.steps.selectOptionFromPenaltyScoringDropdown('Penalty points for the entire question');
-        autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
-            .clear()
-            .type(points)
-            .should('have.value', points);
-    },
-
-    //V3 - This function should be updated in all files
-    clearPenaltyPoints: () => {
-        autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
-            .clear()
-            .should('have.value', '');
-    },
-
-    //V3 - This function should be updated in all files
-    uncheckRoundDownScoreCheckbox: () => {
-        autoScoredScoringSectionMultipleResponsesType.rounddownScoreCheckbox()
-            .click()
-            .should('not.be.checked');
-    },
-
-    //V3 - This function should be updated in all files
-    addPartialDifferentWeightsPoints: (responsePointsArray) => {
-        responsePointsArray.forEach((points, count) => {
-            scoringSectionBase.pointsInputField()
-                .eq(count)
-                .clear()
-                .type(points, { delay: 500 })
-                .blur()
-                .should('have.value', points);
-        });
-    },
-
-    //V3 - This function should be updated in all files
-    /**
-    * @param {number} points points displayed in partial equal weights points per response
-    * @description Verify points displayed in partial equal weights points per response
-    */
-    verifyPartialEqualWeightsPointsPerResponseScore: (points) => {
-        autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsPointsPerResponseScore()
-            .each(($element) => {
-                cy.wrap($element)
-                    .verifyInnerText(`${points}`);
-            });
-    },
-
-    //V3 - This function should be updated in all files
-    verifyPointsPerResponseLabel: () => {
-        autoScoredScoringSectionMultipleResponsesType.pointsPerResponseLabel()
-            .verifyInnerText('Points per response')
-            .should('be.visible');
-    },
-
-    //V3 - This function should be updated in all files
-    verifyPartialDifferentWeightsPointsInputFieldIsEmpty: () => {
-        scoringSectionBase.pointsInputField()
-            .each(($element) => {
-                cy.wrap($element)
-                    .should('have.value', '')
-                    .and('exist');
-            });
-    },
-
-    //V3 - This function should be updated in all files
-    verifyPartialDifferentWeightsPointsInputFieldIsDisabled: () => {
-        scoringSectionBase.pointsInputField()
-            .each(($element) => {
-                cy.wrap($element)
-                    .should('be.disabled');
-            });
-    },
-
-    //V3 - This function should be updated in all files
-    verifyPartialDifferentWeightsPointsInputFieldIsEnabled: (index) => {
-        scoringSectionBase.pointsInputField()
-            .eq(index)
-            .should('not.be.disabled');
-    },
-
-    //V3 - This function should be updated in all files
-    verifyCheckedStateOfRoundDownScoreCheckbox: () => {
-        autoScoredScoringSectionMultipleResponsesType.rounddownScoreCheckbox()
-            .should('be.checked');
-    },
-
-    //V3 - This function should be updated in all files
-    verifyPartialDifferentWeightsPointsInputFieldValue: (pointsFieldArray) => {
-        pointsFieldArray.forEach((points, count) => {
-            scoringSectionBase.pointsInputField()
-                .eq(count)
-                .should('have.value', points);
-        });
-    },
-
-    verifyAllOrNothingRadioButtonIsChecked: () => {
-        autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckbox()
-            .should('be.checked');
-    },
-
-    verifyPartialEqualWeightsRadioButtonIsUnchecked: () => {
-        autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckbox()
-            .should('not.be.checked');
-    },
-
-    verifyPartialDifferentWeightsRadioButtonIsUnchecked: () => {
-        autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckbox()
-            .should('not.be.checked');
-    },
-
-    allotMinimumPoints: (points) => {
-        autoScoredScoringSectionMultipleResponsesType.minimumPointsInputField()
-            .clear()
-            .type(points)
-            .should('have.value', points);
-    },
-
-    focusInAndOutOfMinimumPointsInputField: () => {
-        autoScoredScoringSectionMultipleResponsesType.minimumPointsInputField()
-            .click()
-            .blur();
-    },
-
-    clearMinimumPointsInputField: () => {
-        autoScoredScoringSectionMultipleResponsesType.minimumPointsInputField()
-            .clear()
-            .should('have.value', '');
-    },
-
-    verifyDefaultRoundingNegativeScoresToZeroCheckboxCheckedAndLabel: () => {
-        utilities.verifyInnerText(autoScoredScoringSectionMultipleResponsesType.roundNegativeScoresToZeroCheckboxLabel(), 'Round negative scores to zero')
-        utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.roundNegativeScoresToZeroCheckboxLabel(), 'visible')
-        autoScoredScoringSectionMultipleResponsesType.roundNegativeScoresToZeroCheckbox()
-            .should('be.checked');
-    },
-}
-
-const tests = {
-    verifyAutoScoredScoringTypeSectionWithCSSAnda11y: () => {
-        it('\'All or nothing\', \'Partial - equal weights\' and \'Partial - different weights\' labels and radio buttons should be displayed and by default \'All or nothing\' radio button should be selected', () => {
-            utilities.verifyInnerText(autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckboxLabel(), 'All or nothing');
-            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckboxLabel(), 'visible');
-            autoScoredScoringSectionMultipleResponsesType.steps.verifyAllOrNothingRadioButtonIsChecked();
-            utilities.verifyInnerText(autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckboxLabel(), 'Partial - equal weights');
-            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckboxLabel(), 'visible');
-            autoScoredScoringSectionMultipleResponsesType.steps.verifyPartialEqualWeightsRadioButtonIsUnchecked();
-            utilities.verifyInnerText(autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckboxLabel(), 'Partial - different weights');
-            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckboxLabel(), 'visible');
-            autoScoredScoringSectionMultipleResponsesType.steps.verifyPartialDifferentWeightsRadioButtonIsUnchecked();
-        });
-
-        it('CSS of Scoring section', { tags: 'css' }, () => {
-            utilities.verifyCSS(scoringSectionBase.scoringLabel(), {
-                'color': css.color.sectionHeading,
-                'font-size': css.fontSize.default,
-                'font-weight': css.fontWeight.semibold
-            });
-            utilities.verifyCSS(scoringSectionBase.scoringTypeLabel(), {
-                'color': css.color.labels,
-                'font-size': css.fontSize.normal,
-                'font-weight': css.fontWeight.semibold
-            });
-            utilities.verifyCSS(scoringSectionBase.scoringTypeDropdown().find('.dropdown-label-text'), {
-                'color': css.color.liText,
-                'font-size': css.fontSize.default,
-                'font-weight': css.fontWeight.regular
-            });
-            utilities.verifyCSS(autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckboxLabel(), {
-                'color': css.color.labelText,
-                'font-size': css.fontSize.normal,
-                'font-weight': css.fontWeight.regular
-            });
-            utilities.verifyCSS(autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckboxLabel(), {
-                'color': css.color.labelText,
-                'font-size': css.fontSize.normal,
-                'font-weight': css.fontWeight.regular
-            });
-            utilities.verifyCSS(autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckboxLabel(), {
-                'color': css.color.labelText,
-                'font-size': css.fontSize.normal,
-                'font-weight': css.fontWeight.regular
-            });
-        });
-
-        it('Accessibility of Scoring Section', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(scoringSectionBase.scoringTypeDropdown());
-            cy.checkAccessibility(autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckbox().parents('.ngie-radio-group-wrapper'));
-        });
-    },
-
-    //V3- need to update this for all files
-    verifyPenaltyPointsInputField: () => {
-        it('User should be able to enter points in \'Penalty Points\' input field', () => {
-            autoScoredScoringSectionMultipleResponsesType.steps.allotPenaltyPoints(2);
-        });
-
-        it('CSS of \'Penalty Points\' label and input field', { tags: 'css' }, () => {
-            autoScoredScoringSectionMultipleResponsesType.penaltyPointsLabel()
-                .verifyCSS(css.color.labels, css.fontSize.normal, css.fontWeight.semibold);
-            autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
-                .verifyCSS(css.color.text, css.fontSize.default, css.fontWeight.regular);
-        });
-
-        it('Accessibility of \'Penalty Points\' label and input field', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(autoScoredScoringSectionMultipleResponsesType.penaltyPointsLabel().parents('.points-container'));
-        });
-    },
-
-    //V3- need to update this for all files
-    verifyPenaltyPointsErroredState: (allocatedPoints, penaltyPoints) => {
-        it('When the user focuses in and out of the empty \'Penalty points\' input field, any validation text should not be displayed', () => {
-            autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
-                .click()
-                .blur();
-            commonComponents.errorMessage()
-                .should('not.exist');
-        });
-
-        it(`If the user enters points more than the allocated points in \'Penalty points\' input field, an error message \'Error: Penalty points cannot be greater than allocated points: ${allocatedPoints}\' should be displayed`, () => {
-            autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
-                .clear()
-                .type(penaltyPoints)
-                .should('have.value', penaltyPoints)
-                .blur();
-            commonComponents.errorMessage()
-                .verifyInnerText(`Error: Penalty points cannot be greater than allocated points:${allocatedPoints}`);
-        });
-
-        it('The error message should disappear once the user removes the entered points from the \'Penalty points\' input field', () => {
-            autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
-                .clear()
-                .blur();
-            commonComponents.errorMessage()
-                .should('not.exist');
-        });
-    },
-
-    //V3- need to update this for all files
-    verifyCSSandA11yOfRoundDownScoreCheckboxInCheckedState: () => {
-        it('CSS of \'Round down score\' checkbox - checked state', { tags: 'css' }, () => {
-            autoScoredScoringSectionMultipleResponsesType.rounddownScoreCheckboxLabel()
-                .verifyCSS(css.color.labelText, css.fontSize.normal, css.fontWeight.regular);
-            utilities.verifyCSS(autoScoredScoringSectionMultipleResponsesType.roundingDropdown(), {
-                'color': css.color.liText,
-                'font-size': css.fontSize.default,
-                'font-weight': css.fontWeight.regular,
-                'border': `1px solid ${css.color.defaultDropdownBorder}`
-            })
-        });
-
-        it('Accessibility of \'Round down score\' checkbox  - checked state', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(autoScoredScoringSectionMultipleResponsesType.roundingDropdown());
-        });
-    },
-}
-
-
-export const autoScoredScoringSectionMultipleResponsesType = {
-    ...selectors,
-    steps,
-    tests
-}