itemengine-cypress-automation 1.0.78 → 1.0.79

package/cypress/pages/components/autoScoredScoringSectionMultiResponseType.js

@@ -0,0 +1,624 @@
+import utilities from "../../support/helpers/utilities";
+import { commonComponents } from "./commonComponents";
+const css = Cypress.env('css');
+const penaltyScoringTypeArray = ['No penalty points', 'Penalty points for the entire question', 'Penalty points for each incorrect option'];
+const roundingTypeArray = ['None', 'Round down if <= 0.99', 'Round down if <= 0.50', 'Round down if <= 0.50; Round up if > 0.50'];
+
+const selectors = {
+    allOrNothingRadioButtonLabel: () => cy.get('label[aria-label="All or Nothing"]'),
+    allOrNothingRadioButton: () => cy.get('input[type="radio"][aria-label="All or Nothing"]'),
+    partialEqualWeightsRadioButtonLabel: () => cy.get('label[aria-label="Partial - equal weights"]'),
+    partialEqualWeightsRadioButton: () => cy.get('input[type="radio"][aria-label="Partial - equal weights"]'),
+    partialDifferentWeightsRadioButtonLabel: () => cy.get('label[aria-label="Partial - different weights"]'),
+    partialDifferentWeightsRadioButton: () => cy.get('input[type="radio"][aria-label="Partial - different weights"]'),
+    pointsPerResponseLabel: () => cy.get('[class*="PointsPerResponse"]'),
+    partialEqualWeightsPointsPerResponseScore: () => cy.get('[class*="EqualPoints"]'),
+    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"]')
+        }
+    },
+    penaltyPointsLabel: () => cy.get('.penalty-points-label'),
+    penaltyPointsInputField: () => cy.get('.penlty-points-input-field input'),
+    automaticallySetPenaltyPointsCheckboxLabel: () => cy.get('[data-ngie-testid*="automatically-set-penalty-for-each-incorrect-"] .MuiFormControlLabel-label'),
+    automaticallySetPenaltyPointsCheckbox: () => cy.get('[data-ngie-testid*="automatically-set-penalty-for-each-incorrect-"] input'),
+    specifyTotalPenaltyPointsRadioButton: () => cy.get('input[aria-label="Specify total penalty points"]'),
+    specifyTotalPenaltyPointsRadioButtonLabel: () => cy.get('label[aria-label="Specify total penalty points"]'),
+    totalPenaltyPointsInputField: () => cy.get('input[aria-label="total penalty points"]'),
+    specifyPointsForEachIncorrectOptionRadioButton: () => cy.get('input[aria-label*="Specify points for each incorrect"]'),
+    specifyPointsForEachIncorrectOptionRadioButtonLabel: () => cy.get('label[aria-label*="Specify points for each incorrect"]'),
+    penaltyPointsForEachIncorrectOptionInputField: () => cy.get('input[aria-label="penalty points for each incorrect option"]'),
+    penaltyPointsDetailsSectionInputFieldLabel: () => cy.get('[class*="PenaltyScoreForEachIncorrectstyles__PointsLabel"]'),
+    penaltyPointsDetailsSectionAllottedPointsLabel: () => cy.get('[class*="PenaltyScoreForEachIncorrectstyles__LabelFieldWrapper"]'),
+    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"]')
+        }
+    },
+    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'),
+    pointsInputField: () => cy.get('[class*="points-input-field"]:visible input[type="text"]'),
+    pointsLabel: () => cy.get('.points-label')
+}
+
+const steps = {
+    /**
+     * @param {("All or nothing" | "Partial equal weights" | "Partial different weights")} scoringSubtype option from the scoring subtype radio buttons
+     * @description this function selects scoring subtype from the scoring section
+     */
+    selectAutoScoredScoringSubtype: (scoringSubtype) => {
+        switch (scoringSubtype.toLowerCase()) {
+            case 'all or nothing':
+                autoScoredScoringSectionMultiResponseType.allOrNothingRadioButton()
+                    .click();
+                break;
+            case 'partial equal weights':
+                autoScoredScoringSectionMultiResponseType.partialEqualWeightsRadioButton()
+                    .click();
+                break;
+            case 'partial different weights':
+                autoScoredScoringSectionMultiResponseType.partialDifferentWeightsRadioButton()
+                    .click();
+                break;
+            default:
+                throw new Error(`Invalid auto scored scoring subtype: ${scoringSubtype}`);
+        }
+    },
+
+    expandPenaltyScoringDropdown: () => {
+        autoScoredScoringSectionMultiResponseType.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) => {
+        autoScoredScoringSectionMultiResponseType.penaltyScoringDropdownListOptions(dropdownOption)
+            .click();
+    },
+
+    /**
+     * @param {number} points - The penalty points to be allotted.
+     * @description Allots penalty points in the auto-scored scoring section for a question.
+     */
+    allotPenaltyPoints: (points) => {
+        autoScoredScoringSectionMultiResponseType.penaltyPointsInputField()
+            .clear()
+            .type(`${points}`)
+            .should('have.value', points);
+    },
+
+    clearPenaltyPoints: () => {
+        autoScoredScoringSectionMultiResponseType.penaltyPointsInputField()
+            .clear()
+            .should('have.value', '');
+    },
+
+    /**
+     * @param {string|number} points - The expected penalty points value to be verified.
+     * @description Verifies that the penalty points input field has the specified value in the scoring section.
+     */
+    verifyPenaltyPointsValue: (points) => {
+        autoScoredScoringSectionMultiResponseType.penaltyPointsInputField()
+            .should('have.value', points);
+    },
+
+    /**
+      * Verifies the total penalty points value in the multiple selection question.
+      * @param {number} points - The expected total penalty points value.
+      */
+    verifyTotalPenaltyPointsValue: (points) => {
+        autoScoredScoringSectionMultiResponseType.totalPenaltyPointsInputField()
+            .should('have.value', points);
+    },
+
+    /**
+     * Allots total penalty points in the multiple selection question.
+     * @param {number} points - The total penalty points to be allotted.
+     */
+    allotTotalPenaltyPoints: (points) => {
+        autoScoredScoringSectionMultiResponseType.totalPenaltyPointsInputField()
+            .clear()
+            .type(`${points}`)
+            .should('have.value', points)
+            .blur();
+    },
+
+    clearTotalPenaltyPointsInputField: () => {
+        autoScoredScoringSectionMultiResponseType.totalPenaltyPointsInputField()
+            .clear()
+            .should('have.value', '');
+    },
+
+    expandRoundingDropdown: () => {
+        autoScoredScoringSectionMultiResponseType.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
+     */
+    selectOptionFromRoundingDropdown: (dropdownOption) => {
+        autoScoredScoringSectionMultiResponseType.roundingDropdownListOptions(dropdownOption)
+            .click();
+    },
+
+    /**
+     * @param {number} optionIndex - The index of the option to verify the partial equal weights points per response score.
+     * @param {number} points - The expected points value to be verified.
+     * @description Verifies the partial equal weights points per response score for a specific option in the specify correct answer section for a multi-response type question.
+     */
+    verifyPartialEqualWeightsPointsPerResponseScore: (optionIndex, points) => {
+        autoScoredScoringSectionMultiResponseType.partialEqualWeightsPointsPerResponseScore()
+            .eq(optionIndex)
+            .then(($element) => {
+                utilities.verifyInnerText(cy.wrap($element), `${points}`);
+            });
+    },
+
+    /**
+     * @param {Object<number, number>} responsePointsObject - An object where keys are indexes of the points fields and values are the points to be allotted.
+     * @description Allots points to the enabled points input fields for each option in the scoring section based on the provided object.
+     */
+    allotPartialDifferentWeightsPoints: (responsePointsObject) => {
+        Object.entries(responsePointsObject).forEach(([index, points]) => {
+            const indexNumber = parseInt(index);
+            autoScoredScoringSectionMultiResponseType.pointsInputField()
+                .eq(indexNumber)
+                .should('not.be.disabled')
+                .clear()
+                .type(`${points}`, { delay: 500 })
+                .blur()
+                .should('have.value', points);
+        });
+    },
+
+    verifyPartialDifferentWeightsPointsInputFieldIsEmpty: () => {
+        autoScoredScoringSectionMultiResponseType.pointsInputField()
+            .each(($element) => {
+                cy.wrap($element)
+                    .should('have.value', '')
+            });
+    },
+
+    /**
+     * @param {number} index - The index of the points input field in the specify correct answer section.
+     * @description Verifies that the points input field at the specified index is disabled in the specify correct answer section.
+     */
+    verifyPartialDifferentWeightsPointsInputFieldIsDisabled: (index) => {
+        autoScoredScoringSectionMultiResponseType.pointsInputField()
+            .eq(index)
+            .should('be.disabled');
+    },
+
+    /**
+     * @param {number} index - The index of the points input field in the specify correct answer section.
+     * @description Verifies that the points input field at the specified index is enabled in the specify correct answer section.
+     */
+    verifyPartialDifferentWeightsPointsInputFieldIsEnabled: (index) => {
+        autoScoredScoringSectionMultiResponseType.pointsInputField()
+            .eq(index)
+            .should('not.be.disabled');
+    },
+
+    /**
+     * @param {Array<string>} pointsFieldArray - An array of expected points values.
+     * @description Verifies the values of points input fields in the specify correct answer section.
+     */
+    verifyPartialDifferentWeightsPointsInputFieldValue: (pointsFieldArray) => {
+        pointsFieldArray.forEach((points, count) => {
+            autoScoredScoringSectionMultiResponseType.pointsInputField()
+                .eq(count)
+                .should('have.value', points);
+        });
+    },
+
+    verifyAllOrNothingRadioButtonIsChecked: () => {
+        autoScoredScoringSectionMultiResponseType.allOrNothingRadioButton()
+            .should('be.checked');
+    },
+
+    verifyPartialEqualWeightsRadioButtonIsUnchecked: () => {
+        autoScoredScoringSectionMultiResponseType.partialEqualWeightsRadioButton()
+            .should('not.be.checked');
+    },
+
+    verifyPartialDifferentWeightsRadioButtonIsUnchecked: () => {
+        autoScoredScoringSectionMultiResponseType.partialDifferentWeightsRadioButton()
+            .should('not.be.checked');
+    },
+
+    verifyRoundNegativeScoresToZeroCheckboxAndLabelDefaultState: () => {
+        utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.roundNegativeScoresToZeroCheckboxLabel(), 'Round negative scores to zero')
+        utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.roundNegativeScoresToZeroCheckboxLabel(), 'visible')
+        autoScoredScoringSectionMultiResponseType.roundNegativeScoresToZeroCheckbox()
+            .should('be.checked');
+    },
+
+    verifyPenaltyPointsLabelAndDropdownDefaultState: () => {
+        utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.penaltyScoringLabel(), 'Penalty scoring');
+        utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.penaltyScoringDropdown(), penaltyScoringTypeArray[0]);
+        utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.penaltyScoringDropdown(), 'visible');
+    },
+
+    verifyRoundingLabelAndDropdownDefaultState: () => {
+        utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.roundingLabel(), 'Rounding');
+        utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.roundingDropdown(), roundingTypeArray[0]);
+        utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.roundingDropdown(), 'visible');
+    },
+
+    uncheckRoundNegativeScoresToZeroCheckbox: () => {
+        autoScoredScoringSectionMultiResponseType.roundNegativeScoresToZeroCheckbox()
+            .click()
+            .should('not.be.checked');
+    },
+
+    checkRoundNegativeScoresToZeroCheckbox: () => {
+        autoScoredScoringSectionMultiResponseType.roundNegativeScoresToZeroCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    verifyPointsPerResponseLabel: () => {
+        utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.pointsPerResponseLabel(), 'Points per response');
+        utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.pointsPerResponseLabel(), 'visible');
+    },
+
+
+    verifyAutomaticallySetPenaltyPointsCheckboxUncheckedState: () => {
+        autoScoredScoringSectionMultiResponseType.automaticallySetPenaltyPointsCheckbox()
+            .should('not.be.checked');
+    },
+
+    checkAutomaticallySetPenaltyPointsCheckbox: () => {
+        autoScoredScoringSectionMultiResponseType.automaticallySetPenaltyPointsCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    /**
+     * @param {("Specify total penalty points" | "Specify points for each incorrect option")} radioOption option from the penalty points for each incorrect option radio buttons
+     * @description this function selects radio button from the penalty points for each incorrect option section
+     */
+    selectPenaltyPointsForEachIncorrectOptionType: (radioOption) => {
+        switch (radioOption.toLowerCase()) {
+            case 'specify total penalty points':
+                autoScoredScoringSectionMultiResponseType.specifyTotalPenaltyPointsRadioButton()
+                    .click();
+                break;
+            case 'specify points for each incorrect option':
+                autoScoredScoringSectionMultiResponseType.specifyPointsForEachIncorrectOptionRadioButton()
+                    .click();
+                break;
+            default:
+                throw new Error(`Invalid penalty scoring for each incorrect option type: ${radioOption}`);
+        }
+    },
+
+    verifySpecifyTotalPenaltyPointsRadioButtonCheckedState: () => {
+        autoScoredScoringSectionMultiResponseType.specifyTotalPenaltyPointsRadioButton()
+            .should('be.checked');
+    },
+
+    verifySpecifyPointsForEachIncorrectOptionRadioButtonUncheckedState: () => {
+        autoScoredScoringSectionMultiResponseType.specifyTotalPenaltyPointsRadioButton()
+            .should('be.checked');
+    },
+
+    /**
+     * Verifies the penalty points value for each incorrect option in the multiple selection question.
+     * @param {number} points - The expected penalty points value for each incorrect option.
+     */
+    verifyPenaltyPointsForEachIncorrectOptionValue: (points) => {
+        autoScoredScoringSectionMultiResponseType.penaltyPointsForEachIncorrectOptionInputField()
+            .should('have.value', points);
+    },
+
+    /**
+     * Allots penalty points for each incorrect option in the multiple selection question.
+     * @param {number} points - The penalty points to be allotted for each incorrect option.
+     */
+    allotPenaltyPointsForEachIncorrectOption: (points) => {
+        autoScoredScoringSectionMultiResponseType.penaltyPointsForEachIncorrectOptionInputField()
+            .clear()
+            .type(`${points}`)
+            .should('have.value', points)
+            .blur();
+    },
+
+    verifySpecifyTotalPenaltyPointsDisabledState: () => {
+        autoScoredScoringSectionMultiResponseType.specifyTotalPenaltyPointsRadioButton()
+            .should('be.disabled');
+        autoScoredScoringSectionMultiResponseType.specifyTotalPenaltyPointsRadioButtonLabel()
+            .parent()
+            .should('have.class', 'radio-option-disabled');
+    },
+
+    verifySpecifyPointsForEachIncorrectOptionRadioButtonSelectedAndDisabledState: () => {
+        autoScoredScoringSectionMultiResponseType.specifyPointsForEachIncorrectOptionRadioButton()
+            .should('be.checked')
+            .and('be.disabled');
+        autoScoredScoringSectionMultiResponseType.specifyPointsForEachIncorrectOptionRadioButtonLabel()
+            .parent()
+            .should('have.class', 'radio-option-disabled');
+    },
+
+    /**
+     * verify the displayed penalty points for each incorrect option
+     * @param {number} penaltyPoints displayed penalty points 
+     */
+    verifyPenaltyPointsForEachIncorrectOption: (penaltyPoints) => {
+        utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.penaltyPointsDetailsSectionAllottedPointsLabel(), `Penalty points for each incorrect option: ${penaltyPoints}`);
+    },
+
+    /**
+    * verify the displayed total penalty points
+    * @param {number} penaltyPoints displayed total penalty points 
+    */
+    verifyTotalPenaltyPoints: (penaltyPoints) => {
+        utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.penaltyPointsDetailsSectionAllottedPointsLabel(), `Total penalty points: ${penaltyPoints}`);
+    },
+}
+
+const tests = {
+    verifyScoringSubtypeContentsForMultipleResponseTypeQuestion: () => {
+        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(autoScoredScoringSectionMultiResponseType.allOrNothingRadioButtonLabel(), 'All or nothing');
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.allOrNothingRadioButtonLabel(), 'visible');
+            autoScoredScoringSectionMultiResponseType.steps.verifyAllOrNothingRadioButtonIsChecked();
+            utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.partialEqualWeightsRadioButtonLabel(), 'Partial - equal weights');
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.partialEqualWeightsRadioButtonLabel(), 'visible');
+            autoScoredScoringSectionMultiResponseType.steps.verifyPartialEqualWeightsRadioButtonIsUnchecked();
+            utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.partialDifferentWeightsRadioButtonLabel(), 'Partial - different weights');
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.partialDifferentWeightsRadioButtonLabel(), 'visible');
+            autoScoredScoringSectionMultiResponseType.steps.verifyPartialDifferentWeightsRadioButtonIsUnchecked();
+        });
+
+        it('CSS of Scoring section', { tags: 'css' }, () => {
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.allOrNothingRadioButtonLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.partialEqualWeightsRadioButtonLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.partialDifferentWeightsRadioButtonLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+    },
+
+    /**
+     * @description Verify the penalty points dropdown menu
+     * @param {string[]} penaltyScoringTypeArray Array of dropdown menu options
+     */
+    verifyPenaltyScoringDropdown: (penaltyScoringTypeArray) => {
+        it(`\'Penalty Scoring\' label and dropdown should be displayed and in \'Penalty scoring\' dropdown \'${penaltyScoringTypeArray[0]}\' option should be selected by default`, () => {
+            autoScoredScoringSectionMultiResponseType.steps.verifyPenaltyPointsLabelAndDropdownDefaultState();
+        });
+
+        it(`Clicking on penalty scoring dropdown should open a list of penalty scoring types - ${penaltyScoringTypeArray}`, () => {
+            autoScoredScoringSectionMultiResponseType.steps.expandPenaltyScoringDropdown()
+            utilities.verifyElementVisibilityState(commonComponents.dropdownList(), 'visible');
+            penaltyScoringTypeArray.forEach((option, count) => {
+                utilities.verifyInnerText(utilities.getNthElement(autoScoredScoringSectionMultiResponseType.penaltyScoringDropdownListOptions(), count), option)
+            });
+        });
+
+        it('CSS of penalty type dropdown in active state', { tags: 'css' }, () => {
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.penaltyScoringDropdownListOptions().eq(0), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+                'background-color': css.color.liTextSelectedBg
+            })
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.penaltyScoringDropdownListOptions().eq(1), {
+                'background-color': css.color.transparent
+            })
+        });
+
+        it('Accessibility of penalty type dropdown in active state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(commonComponents.dropdownList());
+        });
+
+        it(`When the user hovers over the \'${penaltyScoringTypeArray[1]}\', a tooltip \'Penalty points for the entire question\' should be displayed and on moving away the focus, the tooltip should disappear`, () => {
+            utilities.hoverOverElement(autoScoredScoringSectionMultiResponseType.penaltyScoringDropdownListOptions('Penalty points for the entire question'));
+            utilities.verifyTextContent(commonComponents.tooltipText(), 'Penalty points for the entire question');
+            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'visible');
+            utilities.hoverAwayFromElement();
+            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'notExist');
+        });
+
+        it(`When the user hovers over the \'${penaltyScoringTypeArray[2]}\', a tooltip \'${penaltyScoringTypeArray[2]}\' should be displayed and on moving away the focus, the tooltip should disappear`, () => {
+            autoScoredScoringSectionMultiResponseType.steps.expandPenaltyScoringDropdown();
+            utilities.hoverOverElement(autoScoredScoringSectionMultiResponseType.penaltyScoringDropdownListOptions(`${penaltyScoringTypeArray[2]}`));
+            utilities.verifyTextContent(commonComponents.tooltipText(), `${penaltyScoringTypeArray[2]}`);
+            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'visible');
+            utilities.hoverAwayFromElement();
+            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'notExist');
+        });
+
+        it('On selecting an option from the penalty scoring dropdown, the dropdown should close', () => {
+            autoScoredScoringSectionMultiResponseType.steps.expandPenaltyScoringDropdown();
+            autoScoredScoringSectionMultiResponseType.steps.selectOptionFromPenaltyScoringDropdown('Penalty points for the entire question');
+            utilities.verifyElementVisibilityState(commonComponents.dropdownList(), 'notExist');
+        });
+
+        it('CSS of penalty scoring type section', { tags: 'css' }, () => {
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.penaltyScoringLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.penaltyScoringDropdown().find('.dropdown-label-text'), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+    },
+
+    verifyPenaltyPointsLabelAndInputField: () => {
+        it('When the user has selected \'Penalty points for the entire question\' from the penalty scoring dropdown, \'Penalty points\' label and empty input field should be displayed', () => {
+            utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.penaltyPointsLabel(), 'Penalty points');
+            autoScoredScoringSectionMultiResponseType.steps.verifyPenaltyPointsValue('');
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.penaltyPointsInputField(), 'visible');
+        });
+
+        it('User should be able to enter points in \'Penalty points\' input field', () => {
+            autoScoredScoringSectionMultiResponseType.steps.allotPenaltyPoints(2);
+        });
+
+        it('CSS of \'Penalty points\' label and input field', { tags: 'css' }, () => {
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.penaltyPointsLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.penaltyPointsInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('Accessibility of \'Penalty points\' label and input field', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(autoScoredScoringSectionMultiResponseType.penaltyPointsLabel().parents('.points-wrapper'));
+        });
+    },
+
+    verifyPenaltyPointsErrorState: () => {
+        it('When the user focuses in and out of the empty \'Penalty points\' input field, no error message should be displayed', () => {
+            autoScoredScoringSectionMultiResponseType.penaltyPointsInputField()
+                .click()
+                .blur();
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'notExist');
+        });
+
+        it('If the user enters points more than the allocated points in \'Penalty points\' input field, no error message should be displayed', () => {
+            autoScoredScoringSectionMultiResponseType.steps.allotPenaltyPoints(20);
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'notExist');
+        });
+    },
+
+    verifyRoundingDropdown: () => {
+        it(`\'Rounding\' label and dropdown should be displayed and in \'Rounding\' dropdown \'${roundingTypeArray[0]}\' option should be selected by default`, () => {
+            autoScoredScoringSectionMultiResponseType.steps.verifyRoundingLabelAndDropdownDefaultState();
+        });
+
+        it(`Clicking on rounding dropdown should open a list of rounding types - ${roundingTypeArray}`, () => {
+            autoScoredScoringSectionMultiResponseType.steps.expandRoundingDropdown()
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.roundingDropdownListOptions().eq(0), 'visible')
+            roundingTypeArray.forEach((option, count) => {
+                utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.roundingDropdownListOptions().eq(count), option)
+            });
+        });
+
+        it('CSS of rounding type dropdown in active state', { tags: 'css' }, () => {
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.roundingDropdownListOptions().eq(0), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+                'background-color': css.color.liTextSelectedBg
+            })
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.roundingDropdownListOptions().eq(1), {
+                'background-color': css.color.transparent
+            })
+        });
+
+        it('Accessibility of rounding type dropdown in active state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(commonComponents.dropdownList())
+        });
+
+        it(`When the user hovers over the \'${roundingTypeArray[3]}\', a tooltip \'Round down if <= 0.50; Round up if > 0.50\' should be displayed and on moving away the focus, the tooltip should disappear`, () => {
+            utilities.hoverOverElement(autoScoredScoringSectionMultiResponseType.roundingDropdownListOptions('round down if <= 0.50; Round up if > 0.50'));
+            utilities.verifyInnerText(commonComponents.tooltipText(), 'Round down if <= 0.50; Round up if > 0.50');
+            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'visible');
+            utilities.hoverAwayFromElement();
+            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'notExist');
+        });
+
+        it('On selecting an option from the rounding dropdown, the dropdown should close', () => {
+            autoScoredScoringSectionMultiResponseType.steps.expandRoundingDropdown();
+            autoScoredScoringSectionMultiResponseType.steps.selectOptionFromRoundingDropdown('round down if <= 0.99');
+            utilities.verifyElementVisibilityState(commonComponents.dropdownList(), 'notExist');
+        });
+
+        it('CSS of rounding section label and dropdown', { tags: 'css' }, () => {
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.roundingLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.roundingDropdown().find('.dropdown-label-text'), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+    },
+
+    verifyRoundNegativeScoreToZeroLabelAndCheckbox: () => {
+        it('When the user sets penalty scoring, then \'Round negative score to zero\' label and checkbox should be displayed and by default it should be checked', () => {
+            autoScoredScoringSectionMultiResponseType.steps.expandPenaltyScoringDropdown();
+            autoScoredScoringSectionMultiResponseType.steps.selectOptionFromPenaltyScoringDropdown('Penalty points for the entire question');
+            autoScoredScoringSectionMultiResponseType.steps.verifyRoundNegativeScoresToZeroCheckboxAndLabelDefaultState();
+        });
+
+        it('CSS of \'Round negative score to zero\' label and checkbox - checked state', { tags: 'css' }, () => {
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.roundNegativeScoresToZeroCheckbox().parent('.icon-checkbox-selected').find('g g'), {
+                'fill': css.color.activeButtons
+            });
+        });
+
+        it('Accessibility of \'Round negative score to zero\' label and checkbox - checked state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(autoScoredScoringSectionMultiResponseType.roundNegativeScoresToZeroCheckbox().parents('[data-ngie-testid="round-negative-scores-to-zero-checkbox"]'));
+        });
+
+        it('The user should be able to uncheck the \'Round negative score to zero\'', () => {
+            autoScoredScoringSectionMultiResponseType.steps.uncheckRoundNegativeScoresToZeroCheckbox();
+        });
+
+        it('CSS of \'Round negative score to zero\' label and checkbox - unchecked state', { tags: 'css' }, () => {
+            utilities.verifyCSS(autoScoredScoringSectionMultiResponseType.roundNegativeScoresToZeroCheckbox().parent().find('svg'), {
+                'fill': css.color.uncheckedCheckbox
+            });
+        });
+
+        it('Accessibility of \'Round negative score to zero\' label and checkbox - unchecked state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(autoScoredScoringSectionMultiResponseType.roundNegativeScoresToZeroCheckbox().parents('[data-ngie-testid="round-negative-scores-to-zero-checkbox"]'));
+        });
+    },
+
+    verifyScoringSectionContentsForManuallyScoredScoringType: () => {
+        it('When the user has selected \'Manually Scored\' option from the Scoring type dropdown then in the \'Scoring\' section; \'All or Nothing\', \'Partial - equal weights\' and \'Partial - different weights\' radio buttons should not be displayed; \'Points\' label and input field should be visible', () => {
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.allOrNothingRadioButton(), 'notExist');
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.partialEqualWeightsRadioButton(), 'notExist');
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.partialDifferentWeightsRadioButton(), 'notExist');
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.pointsLabel(), 'visible');
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.pointsInputField(), 'visible');
+        });
+    }
+}
+
+export const autoScoredScoringSectionMultiResponseType = {
+    ...selectors,
+    steps,
+    tests
+}