itemengine-cypress-automation 1.0.78 → 1.0.80

package/cypress/e2e/ILC/DragAndDropIntoCategories/editTabScoring.js

@@ -0,0 +1,304 @@
+import { dragAndDropIntoCategoriesPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const css = Cypress.env('css');
+
+const perDropzonePenaltyPointsDropdownOption = ['No penalty points', 'Penalty points for the entire question', 'Penalty points for each incorrect dropzone'];
+const perCorrectOptionPenaltyPointsDropdownOption = ['No penalty points', 'Penalty points for the entire question', 'Penalty points for each incorrect option'];
+
+describe('Create item page - Drag and drop into categories: Scoring section', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Scoring section contents', () => {
+        abortEarlySetup();
+        before(() => {
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+        });
+
+        dragAndDropIntoCategoriesPage.tests.verifyScoringTypeLabelAndDropdown('Auto scored');
+
+        it('\'All or nothing\', \'Per dropzone\' and \'Per correct option\' labels and radio buttons should be displayed and by default \'All or nothing\' radio button should be selected', () => {
+            utilities.verifyInnerText(dragAndDropIntoCategoriesPage.allOrNothingRadioButtonLabel(), 'All or nothing');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.allOrNothingRadioButtonLabel(), 'visible');
+            dragAndDropIntoCategoriesPage.steps.verifyAllOrNothingRadioButtonIsChecked();
+            utilities.verifyInnerText(dragAndDropIntoCategoriesPage.perDropzoneRadioButtonLabel(), 'Per dropzone');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.perDropzoneRadioButtonLabel(), 'visible');
+            dragAndDropIntoCategoriesPage.steps.verifyPerDropzoneRadioButtonIsUnchecked();
+            utilities.verifyInnerText(dragAndDropIntoCategoriesPage.perCorrectOptionRadioButtonLabel(), 'Per correct option');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.perCorrectOptionRadioButtonLabel(), 'visible');
+            dragAndDropIntoCategoriesPage.steps.verifyPerCorrectOptionRadioButtonIsUnchecked();
+        });
+
+        it('CSS of Scoring section', { tags: 'css' }, () => {
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.allOrNothingRadioButtonLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.perDropzoneRadioButtonLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.perCorrectOptionRadioButtonLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+    });
+
+    describe('Auto scored: All or nothing scoring - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+            dragAndDropIntoCategoriesPage.steps.allotPoints(10);
+        });
+
+        it('When the user has selected \'All or nothing\' scoring subtype, \'Minimum scoring\' dropdown and \'Penalty scoring\' dropdown and label should be displayed in the scoring section', () => {
+            dragAndDropIntoCategoriesPage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+            dragAndDropIntoCategoriesPage.steps.verifyPenaltyPointsLabelAndDropdownDefaultState();
+        });
+
+        it('When user expands the \'Penalty scoring\' dropdown then the \'Penalty points for each incorrect dropzone\' should be displayed in the disabled state', () => {
+            dragAndDropIntoCategoriesPage.steps.expandPenaltyScoringDropdown();
+            dragAndDropIntoCategoriesPage.steps.verifyPenaltyScoringDropdownOptionIsDisabled('Penalty points for each incorrect dropzone');
+        });
+    });
+
+    describe('Edit tab \'Specify correct answer\' section for All or nothing scoring', () => {
+        abortEarlySetup();
+        before(() => {
+            cy.log('Navigate to fill in the gaps - dropdown question type');
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+            dragAndDropIntoCategoriesPage.steps.setRowsAndColumnsForQuestion();
+            dragAndDropIntoCategoriesPage.steps.addMultipleOptionFields(2);
+            dragAndDropIntoCategoriesPage.steps.addInputToOptionsInputField(['Bat', 'Eagle', 'Parrot', 'Whale']);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection({ 'Bat': 0, 'Eagle': 1, 'Parrot': 1, 'Whale': 4 });
+        });
+
+        dragAndDropIntoCategoriesPage.tests.verifyContentsOfSpecifyCorrectAnswerSection('All or nothing');
+
+        dragAndDropIntoCategoriesPage.tests.verifyPointsLabelAndInputField();
+    });
+
+    describe('Auto scored: Per dropzone - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+        });
+
+
+        it('User should be able to select \'Per dropzone\' scoring type', () => {
+            dragAndDropIntoCategoriesPage.steps.selectAutoScoredScoringSubtype('per dropzone');
+        });
+
+        it('When the user selects \'Per dropzone\' scoring subtype, \'Minimum scoring\', \'Penalty scoring\', \'Rounding\' dropdowns and labels should be displayed in the scoring section', () => {
+            dragAndDropIntoCategoriesPage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+            dragAndDropIntoCategoriesPage.steps.verifyPenaltyPointsLabelAndDropdownDefaultState();
+            dragAndDropIntoCategoriesPage.steps.verifyRoundingLabelAndDropdownDefaultState();
+        });
+
+        it('When the user expands \'Penalty scoring\' dropdown then appropriate list options should be displayed', () => {
+            dragAndDropIntoCategoriesPage.steps.expandPenaltyScoringDropdown();
+            perDropzonePenaltyPointsDropdownOption.forEach((option, index) => {
+                utilities.verifyInnerText(utilities.getNthElement(dragAndDropIntoCategoriesPage.penaltyScoringDropdownListOptions(), index), option);
+            });
+        });
+    });
+
+    describe('Edit tab \'Specify correct answer\' section for Per dropzone', () => {
+        abortEarlySetup();
+        before(() => {
+            cy.log('Navigate to fill in the gaps - dropdown question type');
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+            dragAndDropIntoCategoriesPage.steps.setRowsAndColumnsForQuestion();
+            dragAndDropIntoCategoriesPage.steps.addMultipleOptionFields(2);
+            dragAndDropIntoCategoriesPage.steps.addInputToOptionsInputField(['Bat', 'Eagle', 'Parrot', 'Whale']);
+            dragAndDropIntoCategoriesPage.steps.selectAutoScoredScoringSubtype('Per dropzone');
+        });
+
+        dragAndDropIntoCategoriesPage.tests.verifyContentsOfSpecifyCorrectAnswerSection('All or nothing');
+
+        it('When the user selects \'Per dropzone\' scoring type then in the specify correct answer section \'Point per dropzone\' label and empty input field along with \'Total points\' label should be displayed', () => {
+            utilities.verifyInnerText(dragAndDropIntoCategoriesPage.pointsLabel(), 'Point per dropzone');
+            dragAndDropIntoCategoriesPage.steps.verifyPointsFieldValue('');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.pointsInputField(), 'visible');
+            utilities.verifyInnerText(dragAndDropIntoCategoriesPage.totalPointsLabel(), 'Total points:');
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('-');
+        });
+
+        it('When the user enters points in the \'Point per dropzone\' input field then the \'Total points\' should be updated according to the number of dropzone present', () => {
+            dragAndDropIntoCategoriesPage.steps.allotPoints(10);
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('60');
+        });
+
+        it('When the user adds \'Columns\' or \'Rows\' then the total points should be updated according to the dropzone available', () => {
+            dragAndDropIntoCategoriesPage.steps.addColumn();
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('90');
+            dragAndDropIntoCategoriesPage.steps.addRow();
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('130');
+        });
+
+        it('When the user deletes the \'Columns\' or \'Rows\' then the total points should be updated according to the dropzone available', () => {
+            dragAndDropIntoCategoriesPage.steps.deleteRow();
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('90');
+            dragAndDropIntoCategoriesPage.steps.deleteColumn();
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('60');
+        });
+
+        it('When the user switches to \'All or nothing\' scoring, the \'Points per dropdown\' and \'Total points\' label should not be displayed and the points displayed in \'Points\' input field should remain unchanged', () => {
+            dragAndDropIntoCategoriesPage.steps.selectAutoScoredScoringSubtype('All or nothing');
+            utilities.verifyInnerText(dragAndDropIntoCategoriesPage.pointsLabel(), 'Points');
+            dragAndDropIntoCategoriesPage.steps.verifyPointsFieldValue('10');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.totalPointsLabel(), 'notExist');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.totalPointsValue(), 'notExist');
+        });
+
+        it('When the user updates the entered points in \'All or nothing\' scoring type and switches to \'Per dropzone\' scoring type, then the points should be equally divided and displayed besides each correct option', () => {
+            dragAndDropIntoCategoriesPage.steps.allotPoints(12);
+            dragAndDropIntoCategoriesPage.steps.selectAutoScoredScoringSubtype('Per dropzone');
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('72');
+        });
+
+        it('CSS of \'Points\' label and input field', { tags: 'css' }, () => {
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.pointsLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.pointsInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.totalPointsLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.totalPointsValue(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.bold
+            });
+        });
+    });
+
+    describe('Auto scored: Per correct option - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+        });
+
+        it('User should be able to select \'Per correct option\' scoring type', () => {
+            dragAndDropIntoCategoriesPage.steps.selectAutoScoredScoringSubtype('Per correct option');
+        });
+
+        it('When the user selects \'Per correct option\' scoring subtype, \'Minimum scoring\', \'Penalty scoring\', \'Rounding\' dropdowns and labels should be displayed in the scoring section', () => {
+            dragAndDropIntoCategoriesPage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+            dragAndDropIntoCategoriesPage.steps.verifyPenaltyPointsLabelAndDropdownDefaultState();
+            dragAndDropIntoCategoriesPage.steps.verifyRoundingLabelAndDropdownDefaultState();
+        });
+
+        it('When the user expands \'Penalty scoring\' dropdown then appropriate list options should be displayed', () => {
+            dragAndDropIntoCategoriesPage.steps.expandPenaltyScoringDropdown();
+            perCorrectOptionPenaltyPointsDropdownOption.forEach((option, index) => {
+                utilities.verifyInnerText(utilities.getNthElement(dragAndDropIntoCategoriesPage.penaltyScoringDropdownListOptions(), index), option);
+            });
+        });
+    });
+
+    describe('Edit tab \'Specify correct answer\' section for Per correct option', () => {
+        abortEarlySetup();
+        before(() => {
+            cy.log('Navigate to fill in the gaps - dropdown question type');
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+            dragAndDropIntoCategoriesPage.steps.setRowsAndColumnsForQuestion();
+            dragAndDropIntoCategoriesPage.steps.addMultipleOptionFields(2);
+            dragAndDropIntoCategoriesPage.steps.addInputToOptionsInputField(['Bat', 'Eagle', 'Parrot', 'Whale']);
+            dragAndDropIntoCategoriesPage.steps.selectAutoScoredScoringSubtype('Per correct option');
+        });
+
+        dragAndDropIntoCategoriesPage.tests.verifyContentsOfSpecifyCorrectAnswerSection('All or nothing');
+
+        it('When the user selects \'Per correct option\' scoring type then in the specify correct answer section \'Points per correct option\' label and empty input field along with \'Total points\' label should be displayed', () => {
+            utilities.verifyInnerText(dragAndDropIntoCategoriesPage.pointsLabel(), 'Points per correct option');
+            dragAndDropIntoCategoriesPage.steps.verifyPointsFieldValue('');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.pointsInputField(), 'visible');
+            utilities.verifyInnerText(dragAndDropIntoCategoriesPage.totalPointsLabel(), 'Total points:');
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('-');
+        });
+
+        it('When the user specifies the correct answer and allots points in the \'Points per correct option\' input field then the \'Total points\' should be updated according to the number of correct options present', () => {
+            dragAndDropIntoCategoriesPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection({ 'Bat': 0, 'Eagle': 1, 'Parrot': 2 });
+            dragAndDropIntoCategoriesPage.steps.allotPoints(12);
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('36');
+        });
+
+        it('When the user drops one more option in the specify correct answer section then the \'Total points\' should be updated according to the number of dropzone present', () => {
+            dragAndDropIntoCategoriesPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection({ 'Whale': 4 });
+            dragAndDropIntoCategoriesPage.steps.verifyPointsFieldValue(12);
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('48');
+        });
+
+        it('When the user deletes an option then the \'Total points\' should be updated according to the number of dropzone present', () => {
+            dragAndDropIntoCategoriesPage.steps.deleteOption(0);
+            dragAndDropIntoCategoriesPage.steps.verifyPointsFieldValue(12);
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('36');
+        });
+
+        it('When the user adds an option then the \'Total points\' should not be updated', () => {
+            dragAndDropIntoCategoriesPage.steps.addOption();
+            dragAndDropIntoCategoriesPage.steps.enterTextInOptionInputField(3, 'Ostrich');
+            dragAndDropIntoCategoriesPage.steps.verifyPointsFieldValue(12);
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('36');
+        });
+
+        it('When the user switches to \'All or nothing\' scoring, the \'Points per correct option\' and \'Total points\' label should not be displayed and the points displayed in \'Points\' input field should remain unchanged', () => {
+            dragAndDropIntoCategoriesPage.steps.selectAutoScoredScoringSubtype('All or nothing');
+            utilities.verifyInnerText(dragAndDropIntoCategoriesPage.pointsLabel(), 'Points');
+            dragAndDropIntoCategoriesPage.steps.verifyPointsFieldValue('12');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.totalPointsLabel(), 'notExist');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.totalPointsValue(), 'notExist');
+        });
+
+        it('When the user updates the entered points in \'All or nothing\' scoring type and switches to \'Points per correct option\' scoring type, then the points should be equally divided and displayed besides each correct option', () => {
+            dragAndDropIntoCategoriesPage.steps.allotPoints(15);
+            dragAndDropIntoCategoriesPage.steps.selectAutoScoredScoringSubtype('Per correct option');
+            dragAndDropIntoCategoriesPage.steps.verifyTotalPointsValue('45');
+        });
+
+        it('CSS of \'Points\' label and input field', { tags: 'css' }, () => {
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.pointsLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.pointsInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.totalPointsLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.totalPointsValue(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.bold
+            });
+        });
+    });
+});

package/cypress/e2e/ILC/DragAndDropIntoCategories/{dragAndDropIntoCategoriesHeaderSection.js → headerSection.js}

@@ -1,8 +1,8 @@
-import { dialogBoxBase, dragAndDropIntoCategoriesPage } from "../../../pages";
 import abortEarlySetup from "../../../support/helpers/abortEarly";
-const options = ['Bat', 'Cat'];
+import { dialogBoxBase, dragAndDropIntoCategoriesPage } from "../../../pages";
+const options = ['Bat', 'Eagle'];
 
-describe('Create question page - drag and drop into categories: Header section and Saving question', () => {
+describe('Create item page - Drag and drop into categories: Header section and Saving question', () => {
     before(() => {
         cy.loginAs('admin');
     });
@@ -10,8 +10,7 @@ describe('Create question page - drag and drop into categories: Header section a
     describe('Header section contents', () => {
         abortEarlySetup();
         before(() => {
-            cy.log('Navigating to drag and drop into categories question type');
-            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories')
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
         });
 
         dragAndDropIntoCategoriesPage.tests.verifyCreateQuestionPageQuestionTypeHeader('Drag and drop into categories');
@@ -20,8 +19,7 @@ describe('Create question page - drag and drop into categories: Header section a
     describe('Tabs section', () => {
         abortEarlySetup();
         before(() => {
-            cy.log('Navigating to drag and drop into categories question type');
-            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories')
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
         });
 
         dragAndDropIntoCategoriesPage.tests.verifyTabsSection();
@@ -30,18 +28,16 @@ describe('Create question page - drag and drop into categories: Header section a
     describe('Cancel button', () => {
         abortEarlySetup();
         before(() => {
-            cy.log('Navigating to drag and drop into categories question type');
-            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories')
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
         });
 
-        dragAndDropIntoCategoriesPage.tests.verifyCancelButton('drag and drop into categories');
+        dragAndDropIntoCategoriesPage.tests.verifyCancelButton('drag and drop into categories')
     });
 
     describe('Save Question button', () => {
         abortEarlySetup();
         before(() => {
-            cy.log('Navigating to drag and drop into categories question type');
-            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories')
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
             cy.barsPreLoaderWait();
         });
 
@@ -49,35 +45,30 @@ describe('Create question page - drag and drop into categories: Header section a
             dialogBoxBase.tests.verifyRequiredFieldsWarningPopupOnClickingSaveButton();
 
             it('Validation error messages should be displayed below required input fields', () => {
-                dragAndDropIntoCategoriesPage.steps.verifyQuestionInstructionsErrorMessage()
-                for (let index = 0; index < 2; index++) {
-                    dragAndDropIntoCategoriesPage.steps.verifyOptionsErrorMessageIsDisplayed(index)
-                }
+                dragAndDropIntoCategoriesPage.steps.verifyQuestionInstructionsErrorMessage();
                 dragAndDropIntoCategoriesPage.steps.verifyPointsFieldErrorMessage();
-                dragAndDropIntoCategoriesPage.steps.verifySetCorrectAnswerErrorIconIsDisplayed();
-                dragAndDropIntoCategoriesPage.steps.verifySetCorrectAnswerSectionErrorMessage();
+                dragAndDropIntoCategoriesPage.steps.verifyOptionsInputFieldErrorMessage(0);
+                dragAndDropIntoCategoriesPage.steps.verifySpecifyCorrectAnswerErrorIconIsVisible();
+                dragAndDropIntoCategoriesPage.steps.verifySpecifyCorrectAnswerErrorMessage();
             });
 
             it('Validation error messages should disappear when required input fields are filled', () => {
-                dragAndDropIntoCategoriesPage.steps.addQuestionInstructions();
-                dragAndDropIntoCategoriesPage.steps.verifyQuestionInstructionsErrorMessageIsNotDisplayed();
-                dragAndDropIntoCategoriesPage.steps.allotPoints(20);
-                dragAndDropIntoCategoriesPage.steps.verifyPointsFieldErrorMessageIsNotDisplayed();
-                dragAndDropIntoCategoriesPage.steps.addInputToOptionsForDragAndDropFields(options);
-                dragAndDropIntoCategoriesPage.steps.verifyOptionsErrorMessageIsNotDisplayed(1);
-                dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfSetCorrectAnswerSection('Bat', 0);
+                dragAndDropIntoCategoriesPage.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.');
+                dragAndDropIntoCategoriesPage.steps.addInputToOptionsInputField(options);
+                dragAndDropIntoCategoriesPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection({'Bat': 0});
+                dragAndDropIntoCategoriesPage.steps.allotPoints(10);
                 dragAndDropIntoCategoriesPage.steps.verifyErrorMessageIsNotDisplayed();
-                dragAndDropIntoCategoriesPage.steps.verifySetCorrectAnswerErrorIconIsNotDisplayed();
+                dragAndDropIntoCategoriesPage.steps.verifySpecifyCorrectAnswerErrorIconNotExists();
             });
 
-            dragAndDropIntoCategoriesPage.tests.verifya11yOfCreateItemWrapperContents();
+            dragAndDropIntoCategoriesPage.tests.verifyCreateItemWrapperContentsA11y();
         });
 
         describe('Saving a question', () => {
-            it('When user has filled all the mandatory fields then on clicking on Save Question button the question should get saved and a snackbar with text \'Saved successfully!\' should be displayed', () => {
+            it('Clicking on Save Question button the question should get saved and a snackbar with text \'Saved successfully!\' should be displayed', () => {
                 dragAndDropIntoCategoriesPage.steps.saveAQuestionAndVerifySnackbar();
             });
-            dragAndDropIntoCategoriesPage.tests.verifySavedSuccessfullySnackbarCSSanda11y();
+            dragAndDropIntoCategoriesPage.tests.verifySavedSuccessfullySnackbarCSSAndA11y();
         });
     });
 });

package/cypress/e2e/ILC/DragAndDropIntoCategories/manuallyAndNonScoredScoringEditTab.js

@@ -0,0 +1,78 @@
+import { dragAndDropIntoCategoriesPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const css = Cypress.env('css');
+
+describe('Create Item Page: drag and drop into categories: Edit tab scoring types and specify correct answer section', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Edit tab \'Scoring\' section for Manually Scored scoring type', () => {
+        abortEarlySetup();
+        before(() => {
+            cy.log('Navigate to fill in the gaps - dropdown question type');
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+        });
+
+        it('User should be able to select \'Manually scored\' scoring type from scoring type dropdown', () => {
+            dragAndDropIntoCategoriesPage.steps.expandScoringTypeDropdown();
+            dragAndDropIntoCategoriesPage.steps.selectOptionFromScoringTypeDropdown('Manually scored');
+        });
+
+        it('When the user has selected \'Manually scored\' scoring type, then the specify correct answer section should not be displayed', () => {
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.specifyCorrectAnswerLabel(), 'notExist');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.dropzoneCellSpecifyCorrectAnswerSection(), 'notExist');
+        });
+
+        it('When the user has selected \'Manually Scored\' option from the Scoring Type dropdown then the \'Specify Correct Answer\' section should not be displayed; \'Scoring subtype\' dropdown should not be displayed; \'Points\' labels and input field and \'Minimum scoring\' label and dropdown should be displayed', () => {
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.allOrNothingRadioButton(), 'notExist');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.perDropzoneRadioButton(), 'notExist');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.perCorrectOptionRadioButton(), 'notExist');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.penaltyScoringLabel(), 'notExist');
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.penaltyScoringDropdown(), 'notExist');
+        });
+
+        dragAndDropIntoCategoriesPage.tests.verifyPointsFieldErrorState();
+    });
+
+    describe('Edit tab \'Scoring\' section for Non Scored scoring type', () => {
+        abortEarlySetup();
+        before(() => {
+            cy.log('Navigate to fill in the gaps - dropdown question type');
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+        });
+
+        it('User should be able to select \'Non scored\' scoring type from scoring type dropdown', () => {
+            dragAndDropIntoCategoriesPage.steps.expandScoringTypeDropdown();
+            dragAndDropIntoCategoriesPage.steps.selectOptionFromScoringTypeDropdown('Non scored');
+        });
+
+        dragAndDropIntoCategoriesPage.tests.verifyScoringSectionContentsForNonScoredScoringType();
+
+        dragAndDropIntoCategoriesPage.tests.verifyPointsLabelAndInputFieldForNonScoredScoringType();
+    });
+
+    describe('Edit tab \'Scoring\' section for Non Scored scoring type', () => {
+        abortEarlySetup();
+        before(() => {
+            cy.log('Navigate to fill in the gaps - dropdown question type');
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+            dragAndDropIntoCategoriesPage.steps.setRowsAndColumnsForQuestion();
+            dragAndDropIntoCategoriesPage.steps.addMultipleOptionFields(2);
+            dragAndDropIntoCategoriesPage.steps.addInputToOptionsInputField(['Bat', 'Eagle', 'Parrot', 'Whale']);
+            dragAndDropIntoCategoriesPage.steps.expandMaxCapacityPerDropzoneDropdown();
+            dragAndDropIntoCategoriesPage.steps.selectOptionFromMaxCapacityPerDropzoneDropdown('2');
+            dragAndDropIntoCategoriesPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection({ 'Bat': 0, 'Eagle': 1, 'Parrot': 1, 'Whale': 4 });
+            dragAndDropIntoCategoriesPage.steps.expandScoringTypeDropdown();
+            dragAndDropIntoCategoriesPage.steps.selectOptionFromScoringTypeDropdown('Non scored');
+        });
+
+        dragAndDropIntoCategoriesPage.tests.verifyContentsOfSpecifyCorrectAnswerSection('Non scored');
+
+        dragAndDropIntoCategoriesPage.tests.verifyPointsLabelAndInputFieldForNonScoredScoringType();
+    });
+});

package/cypress/e2e/ILC/DragAndDropIntoCategories/minimumScoringPenaltyPointsAndRoundingDropdown.js

@@ -0,0 +1,139 @@
+import { dragAndDropIntoCategoriesPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const css = Cypress.env('css');
+const penaltyPerDropzoneScoringTypeArray = ['No penalty points', 'Penalty points for the entire question', 'Penalty points for each incorrect dropzone'];
+const penaltyPerCorrectOptionScoringTypeArray = ['No penalty points', 'Penalty points for the entire question', 'Penalty points for each incorrect option'];
+
+describe('Create item page - Drag and drop into categories: Minimum scoring, Penalty scoring, Rounding - Edit tab', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Scoring section: Minimum scoring - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+            dragAndDropIntoCategoriesPage.steps.allotPoints(10);
+        });
+
+        dragAndDropIntoCategoriesPage.tests.verifyMinimumScoringDropdown();
+
+        dragAndDropIntoCategoriesPage.tests.verifyMinimumPointsLabelAndInputField();
+
+        dragAndDropIntoCategoriesPage.tests.verifyMinimumPointsFieldErrorState();
+    });
+
+    describe('Scoring section: Penalty scoring - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+        });
+
+        //Per dropzone
+        it('When auto-scored scoring is set to \'Per dropzone\' scoring type, then in penalty points dropdown the \'Penalty points for each incorrect dropzone\' list option should be enabled', () => {
+            dragAndDropIntoCategoriesPage.steps.selectAutoScoredScoringSubtype('Per dropzone');
+            dragAndDropIntoCategoriesPage.steps.expandPenaltyScoringDropdown();
+            dragAndDropIntoCategoriesPage.steps.verifyPenaltyScoringDropdownOptionIsEnabled(penaltyPerDropzoneScoringTypeArray[2]);
+            cy.log('Closing penalty points dropdown');
+            dragAndDropIntoCategoriesPage.steps.selectOptionFromPenaltyScoringDropdown(penaltyPerDropzoneScoringTypeArray[0]);
+        });
+
+        dragAndDropIntoCategoriesPage.tests.verifyPenaltyScoringDropdown(penaltyPerDropzoneScoringTypeArray);
+
+        dragAndDropIntoCategoriesPage.tests.verifyPenaltyPointsLabelAndInputField();
+
+        dragAndDropIntoCategoriesPage.tests.verifyPenaltyPointsErrorState();
+
+        it('When the user selects \'Penalty points for each incorrect dropzone\' from the penalty scoring dropdown, a penalty points detail section with an empty input field and \'Penalty points for each incorrect dropzone\' label should be displayed', () => {
+            dragAndDropIntoCategoriesPage.steps.expandPenaltyScoringDropdown();
+            dragAndDropIntoCategoriesPage.steps.selectOptionFromPenaltyScoringDropdown(penaltyPerDropzoneScoringTypeArray[2]);
+            dragAndDropIntoCategoriesPage.steps.verifyPenaltyPointsForEachIncorrectDropzone('');
+            utilities.verifyInnerText(dragAndDropIntoCategoriesPage.penaltyPointsForEachIncorrectOptionOrDropzoneLabel(), 'Penalty points for each incorrect dropzone');
+        });
+
+        it('User should be able to allot \'Penalty points for each incorrect dropzone\'', () => {
+            dragAndDropIntoCategoriesPage.steps.allotPenaltyPointsForEachIncorrectDropzone(5);
+        });
+
+        it('CSS of the penalty points section - \'Penalty points for each incorrect dropzone\'', { tags: 'css' }, () => {
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.penaltyPointsForEachIncorrectOptionOrDropzoneLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.medium
+            });
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.penaltyPointsForIncorrectDropzoneInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('Accessibility of the penalty points section - Total penalty points', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(dragAndDropIntoCategoriesPage.penaltyPointsForEachIncorrectOptionOrDropzoneLabel().parents('.penalty-score-for-each-incorrect-wrapper'));
+        });
+
+        //Per correct option
+        it('When auto-scored scoring is set to \'Per correct option\' scoring type, then in penalty points dropdown the \'Penalty points for each incorrect option\' list option should be displayed and it should be enabled', () => {
+            dragAndDropIntoCategoriesPage.steps.selectAutoScoredScoringSubtype('Per correct option');
+            dragAndDropIntoCategoriesPage.steps.expandPenaltyScoringDropdown();
+            dragAndDropIntoCategoriesPage.steps.verifyPenaltyScoringDropdownOptionIsEnabled(penaltyPerCorrectOptionScoringTypeArray[2]);
+            cy.log('Closing penalty points dropdown');
+            dragAndDropIntoCategoriesPage.steps.selectOptionFromPenaltyScoringDropdown(penaltyPerCorrectOptionScoringTypeArray[0]);
+        });
+
+        it(`Clicking on penalty scoring dropdown should open a list of penalty scoring types - ${penaltyPerCorrectOptionScoringTypeArray}`, () => {
+            dragAndDropIntoCategoriesPage.steps.expandPenaltyScoringDropdown()
+            utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.dropdownList(), 'visible');
+            penaltyPerCorrectOptionScoringTypeArray.forEach((option, count) => {
+                utilities.verifyInnerText(utilities.getNthElement(dragAndDropIntoCategoriesPage.penaltyScoringDropdownListOptions(), count), option)
+            });
+            cy.log('Closing penalty points dropdown');
+            dragAndDropIntoCategoriesPage.steps.selectOptionFromPenaltyScoringDropdown(penaltyPerCorrectOptionScoringTypeArray[0]);
+        });
+
+        it('When the user selects \'Penalty points for each incorrect option\' from the penalty scoring dropdown, then a penalty points detail section with an input field and \'Penalty points for each incorrect option\' label should be displayed and the input field should be pre-filled with the previously provided penalty points', () => {
+            dragAndDropIntoCategoriesPage.steps.expandPenaltyScoringDropdown();
+            dragAndDropIntoCategoriesPage.steps.selectOptionFromPenaltyScoringDropdown(penaltyPerCorrectOptionScoringTypeArray[2]);
+            dragAndDropIntoCategoriesPage.steps.verifyPenaltyPointsForEachIncorrectOption(5);
+            utilities.verifyInnerText(dragAndDropIntoCategoriesPage.penaltyPointsForEachIncorrectOptionOrDropzoneLabel(), 'Penalty points for each incorrect option');
+        });
+
+        it('User should be able to allot \'Penalty points for each incorrect dropzone\'', () => {
+            dragAndDropIntoCategoriesPage.steps.allotPenaltyPointsForEachIncorrectOption(5);
+        });
+
+        it('CSS of the penalty points section - \'Penalty points for each incorrect dropzone\'', { tags: 'css' }, () => {
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.penaltyPointsForEachIncorrectOptionOrDropzoneLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.medium
+            });
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.penaltyPointsForIncorrectOptionInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('Accessibility of the penalty points section - Total penalty points', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(dragAndDropIntoCategoriesPage.penaltyPointsForEachIncorrectOptionOrDropzoneLabel().parents('.penalty-score-for-each-incorrect-wrapper'));
+        });
+    });
+
+    describe('Scoring section: Rounding - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+            dragAndDropIntoCategoriesPage.steps.navigateToCreateQuestion('drag and drop into categories');
+            cy.barsPreLoaderWait();
+            dragAndDropIntoCategoriesPage.steps.selectAutoScoredScoringSubtype('Per correct option');
+            dragAndDropIntoCategoriesPage.steps.allotPoints(10);
+        });
+
+        dragAndDropIntoCategoriesPage.tests.verifyRoundingDropdown();
+
+        dragAndDropIntoCategoriesPage.tests.verifyRoundNegativeScoreToZeroLabelAndCheckbox();
+    });
+});