itemengine-cypress-automation 1.0.78 → 1.0.80

package/cypress/pages/components/questionInstructionsComponent.js

@@ -1,3 +1,4 @@
+import utilities from "../../support/helpers/utilities";
 import { commonComponents } from "./commonComponents";
 import { createQuestionBasePage } from "./createQuestionBasePage";
 const css = Cypress.env('css');
@@ -6,6 +7,7 @@ const selectors = {
     questionInstructionsLabelEditTab: () => cy.get('.edit-question-instruction-label'),
     questionInstructionsInputField: () => cy.get('[title="Question Instructions"]'),
     questionInstructionsText: () => cy.get('.question-instruction'),
+    questionInstructionsWrapper: () => cy.get('.edit-question-instruction-wrapper')
 }
 
 const steps = {
@@ -16,8 +18,7 @@ const steps = {
     },
 
     verifyQuestionInstructionsErrorMessageIsNotDisplayed: () => {
-        questionInstructionsComponent.questionInstructionsLabelEditTab()
-            .parents('.edit-question-instruction-wrapper')
+        questionInstructionsComponent.questionInstructionsWrapper()
             .within(() => {
                 commonComponents.errorMessage()
                     .should('not.exist');
@@ -25,8 +26,7 @@ const steps = {
     },
 
     verifyQuestionInstructionsErrorMessage: () => {
-        questionInstructionsComponent.questionInstructionsLabelEditTab()
-            .parents('.edit-question-instruction-wrapper')
+        questionInstructionsComponent.questionInstructionsWrapper()
             .within(() => {
                 commonComponents.errorMessage()
                     .verifyInnerText('Error: Question instructions are required.');
@@ -36,25 +36,34 @@ const steps = {
     verifyQuestionInstructionsText: () => {
         questionInstructionsComponent.questionInstructionsText()
             .should('have.text', 'Which of the following is the major contributor to increased carbon dioxide levels because of urbanization? Select your answer from the options below.');
-    }
+    },
+
+    /**
+     * @param {string} text - The text to be entered into the question instructions input field.
+     * @description - This function types the provided text into the question instructions input field and verifies the entered text,
+     */
+    addTextInQuestionInstructionsInputField: (text) => {
+        questionInstructionsComponent.questionInstructionsInputField()
+            .type(text)
+            .should('have.text', text)
+            .blur();
+    },
+
+    /**
+     * @param {string} questionText - The text to be verified in the question instructions input field.
+     * @description - This function types the verifies the question instructions in preview tab
+     */
+    verifyQuestionInstructionsTextPreviewTab: (questionText) => {
+        utilities.verifyInnerText(questionInstructionsComponent.questionInstructionsText(), questionText);
+    },
 }
 
 const tests = {
     verifyQuestionInstructionsInputFieldEditTab: () => {
-        it('CSS of Question Instructions in Edit tab', { tags: 'css' }, () => {
-            questionInstructionsComponent.questionInstructionsLabelEditTab()
-                .verifyCSS(css.color.sectionHeading, css.fontSize.normal, css.fontWeight.semibold);
-            questionInstructionsComponent.questionInstructionsInputField()
-                .verifyCSS(css.color.text, css.fontSize.default, css.fontWeight.regular);
-        });
-
-        //Note: a11y covered in header section 
-
         it('\'Question Instructions\' label and input field should be displayed and \'Enter Question Instructions\' placeholder text should be displayed on input field', () => {
-            questionInstructionsComponent.questionInstructionsLabelEditTab()
-                .verifyInnerText('Question instructions');
+            utilities.verifyInnerText(questionInstructionsComponent.questionInstructionsLabelEditTab(), 'Question instructions');
             questionInstructionsComponent.questionInstructionsInputField()
-                .and('have.attr', 'data-cke-editorplaceholder', 'Enter question instructions');
+                .should('have.attr', 'data-cke-editorplaceholder', 'Enter question instructions');
         });
 
         it('When user focus in and out of the \'Question Instructions\' input field without typing anything, an error message should be thrown', () => {
@@ -65,46 +74,56 @@ const tests = {
         });
 
         it('CSS of question instructions error message', { tags: 'css' }, () => {
-            questionInstructionsComponent.questionInstructionsLabelEditTab()
-                .parents('.edit-question-instruction-wrapper')
+            questionInstructionsComponent.questionInstructionsWrapper()
                 .within(() => {
-                    commonComponents.errorMessage()
-                        .verifyCSS(css.color.errorText, css.fontSize.small, css.fontWeight.regular);
+                    utilities.verifyCSS(commonComponents.errorMessage(), {
+                        'color': css.color.errorText,
+                        'font-size': css.fontSize.small,
+                        'font-weight': css.fontWeight.regular
+                    });
                 });
         });
 
         it('Accessibility of question instructions error message', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(questionInstructionsComponent.questionInstructionsLabelEditTab().parents('.edit-question-instruction-wrapper'));
+            cy.checkAccessibility(questionInstructionsComponent.questionInstructionsWrapper());
         });
 
         it('The user should be able to add the Question Instructions and \'Error :Question Instructions are required.\' error message should disappear', () => {
-            questionInstructionsComponent.steps.addQuestionInstructions()
-            questionInstructionsComponent.steps.verifyQuestionInstructionsErrorMessageIsNotDisplayed()
+            questionInstructionsComponent.steps.addTextInQuestionInstructionsInputField('Which of the following is the major contributor to increased carbon dioxide levels because of urbanization? Select your answer from the options below.');
+            questionInstructionsComponent.steps.verifyQuestionInstructionsErrorMessageIsNotDisplayed();
         });
 
         it('When user adds Question instruction the placeholder text should not be displayed', () => {
             questionInstructionsComponent.questionInstructionsInputField()
                 .should('not.have.attr', 'data-cke-editorplaceholder');
         });
+
+        it('CSS of Question Instructions in Edit tab', { tags: 'css' }, () => {
+            utilities.verifyCSS(questionInstructionsComponent.questionInstructionsLabelEditTab(), {
+                'color': css.color.sectionHeading,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(questionInstructionsComponent.questionInstructionsInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
     },
 
     verifyQuestionInstructionsInputFieldPreviewTab: () => {
-        //TODO: Need to decide approach for the below case as Question instruction is a compulsory field and it's empty state cannot be checked in the other views like grading, student, correct answer.
         it('When user has not entered any text in the Question instructions input field in the \'Edit\' tab then nothing should be displayed in the \'Preview\' tab', () => {
-            cy.barsPreLoaderWait();
-            cy.log('Switching to Preview Tab')
             createQuestionBasePage.steps.switchToPreviewTab();
-            questionInstructionsComponent.questionInstructionsText()
-                .should('not.exist');
+            //Failing due to https://redmine.zeuslearning.com/issues/553382
+            utilities.verifyElementVisibilityState(questionInstructionsComponent.questionInstructionsText(), 'notExist')
         });
 
-        it('The added Question Instructions should be displayed on \'Preview\' tab', () => {
-            cy.log('Switching to Edit Tab')
+        it('When the user specifies question instructions, then the added question instructions should be displayed in the \'Preview\' tab', () => {
             createQuestionBasePage.steps.switchToEditTab();
-            questionInstructionsComponent.steps.addQuestionInstructions()
-            cy.log('Switching to Preview Tab')
+            questionInstructionsComponent.steps.addTextInQuestionInstructionsInputField('Which of the following is the major contributor to increased carbon dioxide levels because of urbanization? Select your answer from the options below.');
             createQuestionBasePage.steps.switchToPreviewTab();
-            steps.verifyQuestionInstructionsText();
+            utilities.verifyTextContent(questionInstructionsComponent.questionInstructionsText(), 'Which of the following is the major contributor to increased carbon dioxide levels because of urbanization? Select your answer from the options below.');
         });
     }
 };

package/cypress/pages/components/randomizeOptionsComponent.js

@@ -0,0 +1,59 @@
+import utilities from "../../support/helpers/utilities";
+const css = Cypress.env('css');
+
+const selectors = {
+    randomizeOptionsLabel: () => cy.get('[data-ngie-testid="randomize-options-checkbox"] .MuiFormControlLabel-label'),
+    randomizeOptionsCheckbox: () => cy.get('[data-ngie-testid="randomize-options-checkbox"] input')
+}
+
+const steps = {
+    verifyRandomizeOptionsCheckboxUnchecked: () => {
+        randomizeOptionsComponent.randomizeOptionsCheckbox()
+            .should('not.be.checked');
+    },
+
+    checkRandomizeOptionsCheckbox: () => {
+        randomizeOptionsComponent.randomizeOptionsCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    uncheckRandomizeOptionsCheckbox: () => {
+        randomizeOptionsComponent.randomizeOptionsCheckbox()
+            .click();
+        steps.verifyRandomizeOptionsCheckboxUnchecked();
+    }
+}
+
+const tests = {
+    verifyRandomizeOptionsCheckboxAndLabelUncheckedCSS: () => {
+        it('CSS of \'Randomize options\' checkbox and label - unchecked state', { tags: 'css' }, () => {
+            utilities.verifyCSS(randomizeOptionsComponent.randomizeOptionsLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(randomizeOptionsComponent.randomizeOptionsCheckbox().parent().find('svg'), {
+                'fill': css.color.uncheckedCheckbox
+            });
+        });
+    },
+
+    verifyRandomizeOptionsCheckboxCheckedCSSAndA11y: () => {
+        it('CSS of \'Randomize options\' functionality - checked state', { tags: 'css' }, () => {
+            utilities.verifyCSS(randomizeOptionsComponent.randomizeOptionsCheckbox().parent().find('g').eq(1), {
+                'fill': css.color.activeButtons
+            });
+        });
+
+        it('Accessibility of \'Randomize options\' functionality - checked state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(randomizeOptionsComponent.randomizeOptionsCheckbox().parents('[data-ngie-testid="randomize-options-checkbox"]'))
+        });
+    }
+}
+
+export const randomizeOptionsComponent = {
+    ...selectors,
+    steps,
+    tests
+}

package/cypress/pages/components/scoringSectionBase.js

@@ -8,6 +8,7 @@ const selectors = {
     scoringTypeDropdown: () => cy.get('#Scoring-Type-select'),
     scoringTypeDropdownList: () => cy.get('.dropdown-list-ul[aria-labelledby*="Scoring-Type-dropdown-label"]'),
     scoringTypeDropdownListOptions: () => cy.get('[aria-labelledby*="Scoring-Type-dropdown-label"] li'),
+    //Enhancement: Remove the below two selectors copy of minimumScoreInputField, minimumScoreInputFieldLabel
     minimumScoreIfAttemptedLabel: () => cy.get('[class*="min-score-points-label"]'),
     minimumScoreIfAttemptedInputField: () => cy.get('.min-score-points-input-field input[type="text"]'),
     pointsLabel: () => cy.get('.points-label'),
@@ -16,14 +17,16 @@ const selectors = {
     pleaseEnterPointsErrorMessage: () => cy.get('[class*="ErrorBlockstyles__ErrorText"]:visible'),
     pointsWrapper: () => cy.get('.set-correct-answer-points-wrapper'),
     minimumScoringLabel: () => cy.get('#minimum-scoring-dropdown-label'),
+    minimumScoreInputField: () => cy.get('.min-score-points-input-field input[type="text"]'),
+    minimumScoreInputFieldLabel: () => cy.get('[class*="min-score-points-label"]'),
     minimumScoringDropdown: () => cy.get('#minimum-scoring-select'),
     minimumScoringDropdownListOptions: (ariaLabel = null) => {
         if (ariaLabel) {
-            return cy.get(`[aria-labelledby*="minimum-scoring-dropdown-label"] [role="option"][aria-label*="${ariaLabel}"]`)
+            return cy.get(`[aria-labelledby*="minimum-scoring-dropdown-label"] [role="option"][aria-label="${ariaLabel}"]`)
         } else {
             return cy.get('[aria-labelledby*="minimum-scoring-dropdown-label"] [role="option"]')
         }
-    },
+    }
 }
 
 const steps = {
@@ -74,6 +77,7 @@ const steps = {
     },
 
     //V3 - This function should be updated in all files
+    //Enhancement: Deprecated method
     allotMinimumScoreAwardedIfAttempted: (points) => {
         scoringSectionBase.minimumScoreIfAttemptedInputField()
             .type(points)
@@ -142,6 +146,18 @@ const steps = {
     selectMinimumScoringTypeListOption: (listOption) => {
         scoringSectionBase.minimumScoringDropdownListOptions(listOption)
             .click();
+    },
+
+    /**
+     * Sets the minimum score for a question in the scoring section.
+     * @param {number} points - The minimum score to be set for the question.
+     */
+    allotMinimumScore: (points) => {
+        scoringSectionBase.minimumScoreInputField()
+            .clear()
+            .type(points)
+            .should('have.value', points)
+            .blur();
     }
 }
 

package/cypress/pages/components/scoringSectionBaseEditTab.js

@@ -0,0 +1,401 @@
+import utilities from "../../support/helpers/utilities"
+import { commonComponents } from "./commonComponents"
+const css = Cypress.env('css');
+const minimumScoringTypeArray = ['No minimum score', 'Award minimum score', 'Award minimum score only if attempted'];
+
+const selectors = {
+    scoringLabel: () => cy.get('.edit-scoring-label'),
+    scoringTypeLabel: () => cy.get('#Scoring-Type-dropdown-label'),
+    scoringTypeDropdown: () => cy.get('#Scoring-Type-select'),
+    scoringTypeDropdownListOptions: (ariaLabel = null) => {
+        if (ariaLabel) {
+            return cy.get(`[aria-labelledby*="Scoring-Type-dropdown-label"] [role="option"][aria-label*="${ariaLabel}"]`)
+        } else {
+            return cy.get('[aria-labelledby*="Scoring-Type-dropdown-label"] [role="option"]')
+        }
+    },
+    pointsLabel: () => cy.get('.points-label'),
+    //TODO: Need to update below selectors, once https://redmine.zeuslearning.com/issues/553983 gets resolved
+    pointsInputField: () => cy.get('[class*="points-input-field"]:visible input[type="text"]'),
+    pleaseEnterPointsErrorMessage: () => cy.get('[class*="ErrorBlockstyles__ErrorText"]:visible'),
+    pointsWrapper: () => cy.get('.set-correct-answer-points-wrapper'),
+    minimumScoringLabel: () => cy.get('#minimum-scoring-dropdown-label'),
+    minimumScoringDropdown: () => cy.get('#minimum-scoring-select'),
+    minimumScoringDropdownListOptions: (ariaLabel = null) => {
+        if (ariaLabel) {
+            return cy.get(`[aria-labelledby*="minimum-scoring-dropdown-label"] [role="option"][aria-label="${ariaLabel}"]`)
+        } else {
+            return cy.get('[aria-labelledby*="minimum-scoring-dropdown-label"] [role="option"]')
+        }
+    },
+    minimumPointsLabel: () => cy.get('.min-score-points-label'),
+    minimumPointsInputField: () => cy.get('.min-score-points-input-field input'),
+}
+
+const steps = {
+    /**
+     * @param {number} points - The points to be allotted.
+     * @description - Allots points in the scoring section.
+     */
+    allotPoints: (points) => {
+        scoringSectionBaseEditTab.pointsInputField()
+            .clear()
+            .type(`${points}`)
+            .should('have.value', points)
+            .blur();
+    },
+
+    verifyDefaultPointsLabelAndInputField: () => {
+        utilities.verifyInnerText(scoringSectionBaseEditTab.pointsLabel(), 'Points');
+        scoringSectionBaseEditTab.steps.verifyPointsFieldValue('');
+        utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.pointsInputField(), 'visible');
+    },
+
+    verifyNonScoredPointsField: () => {
+        scoringSectionBaseEditTab.steps.verifyPointsFieldValue(0);
+        scoringSectionBaseEditTab.pointsInputField()
+            .and('be.disabled');
+        utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.minimumScoringDropdown(), 'notExist');
+    },
+
+    expandScoringTypeDropdown: () => {
+        scoringSectionBaseEditTab.scoringTypeDropdown()
+            .click();
+    },
+
+    /**
+     * @param {('Auto scored'| 'Manually scored'| 'Non scored')} scoringType 
+     * @description this function selects an option from expanded scoring type dropdown
+     */
+    selectOptionFromScoringTypeDropdown: (scoringType) => {
+        const convertedString = scoringType.replace(/\b\w/g, (match) => match.toUpperCase());
+        scoringSectionBaseEditTab.scoringTypeDropdownListOptions(convertedString)
+            .click();
+    },
+
+    /**
+     * Sets the minimum score for a question in the scoring section.
+     * @param {number} points - The minimum score to be set for the question.
+     */
+    allotMinimumPoints: (points) => {
+        scoringSectionBaseEditTab.minimumPointsInputField()
+            .clear()
+            .type(`${points}`)
+            .should('have.value', points)
+            .blur();
+    },
+
+    /**
+     * @param {number} points - The expected points value to be verified for the minimum points input field.
+     * @description Verifies the value of the minimum points input field in the scoring section.
+     */
+    verifyMinimumPointsFieldValue: (points) => {
+        scoringSectionBaseEditTab.minimumPointsInputField()
+            .should('have.value', points);
+    },
+
+    /**
+     * @param {number} points - The expected value of the points input field.
+     * @description - Verifies that the points input field in the scoring section has the expected value.
+     */
+    verifyPointsFieldValue: (points) => {
+        scoringSectionBaseEditTab.pointsInputField()
+            .should('have.value', points);
+    },
+
+    clearPointsField: () => {
+        scoringSectionBaseEditTab.pointsInputField()
+            .clear()
+            .should('have.value', '')
+            .blur();
+    },
+
+    clearMinimumPointsField: () => {
+        scoringSectionBaseEditTab.minimumPointsInputField()
+            .clear()
+            .should('have.value', '')
+            .blur();
+    },
+
+    verifyPointsFieldErrorMessage: () => {
+        utilities.verifyInnerText(scoringSectionBaseEditTab.pleaseEnterPointsErrorMessage(), 'Error: Please enter points.');
+        utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.pleaseEnterPointsErrorMessage(), 'visible');
+    },
+
+    verifyPointsFieldErrorMessageIsNotDisplayed: () => {
+        utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.pleaseEnterPointsErrorMessage(), 'notExist');
+    },
+
+    /**
+     * @param {number} index index of points field
+     * @description this function focuses in and out of points field
+     */
+    focusInAndFocusOutOfPointsInputField: (index) => {
+        scoringSectionBaseEditTab.pointsInputField()
+            .eq(index)
+            .focus()
+            .blur();
+    },
+
+    expandMinimumScoringDropdown: () => {
+        scoringSectionBaseEditTab.minimumScoringDropdown()
+            .click();
+    },
+
+    /**
+     * @param {('No minimum score'| 'Award minimum score'|'Award minimum score only if attempted')} listOption 
+     * @description this function selects an option from expanded minimum scoring dropdown
+     */
+    selectOptionFromMinimumScoringDropdown: (listOption) => {
+        scoringSectionBaseEditTab.minimumScoringDropdownListOptions(listOption)
+            .click();
+    },
+
+    verifyMinimumScoringLabelAndDropdownDefaultState: () => {
+        utilities.verifyInnerText(scoringSectionBaseEditTab.minimumScoringLabel(), 'Minimum scoring');
+        utilities.verifyInnerText(scoringSectionBaseEditTab.minimumScoringDropdown(), minimumScoringTypeArray[0]);
+        utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.minimumScoringDropdown(), 'visible');
+    }
+}
+
+const tests = {
+    /**
+     * @param {('Auto scored' | 'Manually scored')} scoringType of the question
+     * @description Auto scored should be passed for TEI with ['Auto scored', 'Manually scored', 'Non scored'] scoring types, Manually scored should be passed for manually scored TEI with ['Manually scored', 'Non scored']
+     */
+    verifyScoringTypeLabelAndDropdown: (scoringType) => {
+        const scoringTypeArray = scoringType === 'Auto scored' ? ['Auto scored', 'Manually scored', 'Non scored'] : ['Manually scored', 'Non scored'];
+        it(`\'Scoring\' label should be displayed and \'Scoring type\' label and dropdown should be displayed and in \'Scoring type\' dropdown \'${scoringTypeArray[0]}\' option should be selected by default`, () => {
+            utilities.verifyInnerText(scoringSectionBaseEditTab.scoringLabel(), 'Scoring');
+            utilities.verifyInnerText(scoringSectionBaseEditTab.scoringTypeLabel(), 'Scoring type');
+            utilities.verifyInnerText(scoringSectionBaseEditTab.scoringTypeDropdown(), scoringTypeArray[0]);
+            utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.scoringTypeDropdown(), 'visible');
+        });
+
+        it(`Clicking on Scoring Type dropdown should open a list of scoring types - ${scoringTypeArray}`, () => {
+            scoringSectionBaseEditTab.scoringTypeDropdown()
+                .click();
+            utilities.verifyElementVisibilityState(commonComponents.dropdownList(), 'visible');
+            scoringTypeArray.forEach((option, count) => {
+                utilities.verifyInnerText(utilities.getNthElement(scoringSectionBaseEditTab.scoringTypeDropdownListOptions(), count), option);
+            });
+        });
+
+        it('CSS of Scoring type dropdown in active state', { tags: 'css' }, () => {
+            utilities.verifyCSS(utilities.getNthElement(scoringSectionBaseEditTab.scoringTypeDropdownListOptions(), 0), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+                'background-color': css.color.liTextSelectedBg
+            });
+            utilities.verifyCSS(utilities.getNthElement(scoringSectionBaseEditTab.scoringTypeDropdownListOptions(), 1), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+                'background-color': css.color.transparent
+            });
+        });
+
+        it('Accessibility of Scoring type dropdown in active state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(commonComponents.dropdownList())
+        });
+
+        it('On selecting an option from the scoring type dropdown, the dropdown should close', () => {
+            scoringSectionBaseEditTab.steps.selectOptionFromScoringTypeDropdown(scoringTypeArray[0]);
+            utilities.verifyElementVisibilityState(commonComponents.dropdownList(), 'notExist');
+        });
+
+        it('CSS of Scoring section label and dropdown', { tags: 'css' }, () => {
+            utilities.verifyCSS(scoringSectionBaseEditTab.scoringLabel(), {
+                'color': css.color.sectionHeading,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(scoringSectionBaseEditTab.scoringTypeLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(scoringSectionBaseEditTab.scoringTypeDropdown().find('.dropdown-label-text'), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+    },
+
+    verifyPointsLabelAndInputField: () => {
+        it('\'Points\' label and input field should be displayed', () => {
+            scoringSectionBaseEditTab.steps.verifyDefaultPointsLabelAndInputField();
+        });
+
+        it('CSS of \'Points\' label and input field', { tags: 'css' }, () => {
+            utilities.verifyCSS(scoringSectionBaseEditTab.pointsLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(scoringSectionBaseEditTab.pointsInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+    },
+
+    verifyPointsFieldErrorState: () => {
+        it('When the user focuses in and out of the empty points input field, \'Please enter points.\' validation text should be displayed below the Points input field', () => {
+            scoringSectionBaseEditTab.pointsInputField()
+                .focus()
+                .blur();
+            utilities.verifyInnerText(scoringSectionBaseEditTab.pleaseEnterPointsErrorMessage(), 'Error: Please enter points.');
+            utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.pleaseEnterPointsErrorMessage(), 'visible');
+        });
+
+        it('CSS of points field error message', { tags: 'css' }, () => {
+            utilities.verifyCSS(scoringSectionBaseEditTab.pleaseEnterPointsErrorMessage(), {
+                'color': css.color.errorText,
+                'font-size': css.fontSize.small,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('Accessibility of points field error message', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(commonComponents.errorMessage());
+        });
+
+        it('When the user enters point in Points input field then the \'Please enter points.\' validation text should disappear', () => {
+            scoringSectionBaseEditTab.steps.allotPoints(10);
+            utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.pleaseEnterPointsErrorMessage(), 'notExist');
+        });
+    },
+
+    verifyMinimumScoringDropdown: () => {
+        it(`\'Minimum scoring\' label and dropdown should be displayed and in \'Minimum scoring\' dropdown \'${minimumScoringTypeArray[0]}\' option should be selected by default`, () => {
+            scoringSectionBaseEditTab.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+        });
+
+        it(`Clicking on minimum scoring dropdown should open a list of minimum scoring types - ${minimumScoringTypeArray}`, () => {
+            scoringSectionBaseEditTab.steps.expandMinimumScoringDropdown()
+            utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.minimumScoringDropdownListOptions().eq(0), 'visible')
+            minimumScoringTypeArray.forEach((option, count) => {
+                utilities.verifyInnerText(scoringSectionBaseEditTab.minimumScoringDropdownListOptions().eq(count), option)
+            });
+        });
+
+        it('CSS of minimum scoring type dropdown in active state', { tags: 'css' }, () => {
+            utilities.verifyCSS(scoringSectionBaseEditTab.minimumScoringDropdownListOptions().eq(0), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+                'background-color': css.color.liTextSelectedBg
+            })
+            utilities.verifyCSS(scoringSectionBaseEditTab.minimumScoringDropdownListOptions().eq(1), {
+                'background-color': css.color.transparent
+            })
+        });
+
+        it('Accessibility of  minimum scoring type dropdown in active state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(commonComponents.dropdownList())
+        });
+
+        it(`When the user hovers over the \'${minimumScoringTypeArray[2]}\', a tooltip \'Award minimum score only if attempted\' should be displayed and on moving away the focus, the tooltip should disappear`, () => {
+            utilities.hoverOverElement(scoringSectionBaseEditTab.minimumScoringDropdownListOptions('Award minimum score only if attempted'));
+            utilities.verifyTextContent(commonComponents.tooltipText(), 'Award minimum score only if attempted');
+            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'visible');
+            utilities.hoverAwayFromElement();
+            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'notExist');
+        });
+
+        it('On selecting an option from the minimum scoring dropdown, the dropdown should close', () => {
+            scoringSectionBaseEditTab.steps.expandMinimumScoringDropdown();
+            scoringSectionBaseEditTab.steps.selectOptionFromMinimumScoringDropdown('Award minimum score only if attempted');
+            utilities.verifyElementVisibilityState(commonComponents.dropdownList(), 'notExist');
+        });
+
+        it('CSS of minimum scoring section', { tags: 'css' }, () => {
+            utilities.verifyCSS(scoringSectionBaseEditTab.minimumScoringLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(scoringSectionBaseEditTab.minimumScoringDropdown().find('.dropdown-label-text'), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+    },
+
+    verifyMinimumPointsLabelAndInputField: () => {
+        it('When the user selects \'Award minimum score\' or \'Award minimum score only if attempted from the minimum scoring dropdown, \'Minimum points\' label and empty input field should be displayed', () => {
+            scoringSectionBaseEditTab.steps.expandMinimumScoringDropdown();
+            scoringSectionBaseEditTab.steps.selectOptionFromMinimumScoringDropdown('Award minimum score');
+            utilities.verifyInnerText(scoringSectionBaseEditTab.minimumPointsLabel(), 'Minimum points');
+            scoringSectionBaseEditTab.steps.verifyMinimumPointsFieldValue('');
+            utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.minimumPointsInputField(), 'visible');
+        });
+
+        it('User should be able to enter points in \'Minimum points\' input field', () => {
+            scoringSectionBaseEditTab.steps.allotMinimumPoints(2);
+        });
+
+        it('CSS of \'Minimum points\' label and input field', { tags: 'css' }, () => {
+            utilities.verifyCSS(scoringSectionBaseEditTab.minimumPointsLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(scoringSectionBaseEditTab.minimumPointsInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('Accessibility of \'Minimum points\' label and input field', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(scoringSectionBaseEditTab.minimumPointsLabel().parents('.points-wrapper'));
+        });
+    },
+
+    verifyMinimumPointsFieldErrorState: () => {
+        it('When the user focuses in and out of the empty Minimum points input field, no error message should be displayed', () => {
+            scoringSectionBaseEditTab.minimumPointsInputField()
+                .focus()
+                .blur();
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'notExist');
+        });
+
+        it('If the user enters points more than the allocated points in Minimum points input field, an error message \'Error: Minimum score cannot be greater than allocated points.: *points in points field*\' should be displayed', () => {
+            scoringSectionBaseEditTab.steps.allotMinimumPoints(20);
+            utilities.verifyInnerText(commonComponents.errorMessage().last(), 'Error: Minimum score cannot be greater than allocated points.: 10');
+        });
+
+        it('The error message should disappear once the user removes the entered points from the Minimum score awarded (if attempted) input field', () => {
+            scoringSectionBaseEditTab.steps.clearMinimumPointsField();
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'notExist');
+        });
+    },
+
+    verifyPointsLabelAndInputFieldForNonScoredScoringType: () => {
+        it('When the user has selected \'Non scored\' option from the \'Scoring type\' dropdown, then \'Points\' input field should be displayed in disabled state with prefilled \'0\' points in the \'Specify correct answer\' section', () => {
+            utilities.verifyInnerText(scoringSectionBaseEditTab.pointsLabel(), 'Points');
+            utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.pointsLabel(), 'visible');
+            scoringSectionBaseEditTab.pointsInputField()
+                .should('have.value', '0')
+                .should('be.disabled');
+        });
+    },
+
+    verifyScoringSectionContentsForNonScoredScoringType: () => {
+        it('When the user has selected \'Non scored\' option from the \'Scoring type\' dropdown, \'Minimum scoring\' dropdown should not be displayed', () => {
+            utilities.verifyElementVisibilityState(scoringSectionBaseEditTab.minimumScoringDropdown(), 'notExist');
+        });
+    }
+}
+
+export const scoringSectionBaseEditTab = {
+    ...selectors,
+    steps,
+    tests
+}