itemengine-cypress-automation 1.0.182-repoUpdate22April-92d01da.0 → 1.0.182

package/cypress/pages/listOrderingPage.js

@@ -1,116 +1,373 @@
 import constants from "../fixtures/constants";
 import utilities from "../support/helpers/utilities";
-import { autoScoredScoringPreviewTab, autoScoredScoringSectionMultiResponseType, autoScoredSpecifyCorrectAnswerSection, autoScoredStudentViewSettings, commonComponents, correctIncorrectAnswerLabelComponent, createQuestionBasePage, optionsWrapperComponent, questionInstructionsComponent, scoringSectionBaseEditTab } from "./components"
+import { additionalSettingsPanel, autoScoredAdditionalSettings, autoScoredPreviewBase, autoScoredScoringSection, autoScoredScoringSectionMultipleResponsesType, autoScoredSetCorrectAnswerSection, ckEditorToolbar, commonComponents, createQuestionBasePage, equationEditorFlyout, optionsWrapperComponent, previewScoringAndShowCorrectAnswerComponent, questionInstructionsComponent, scoringSectionBase } from "./components"
+import { answerNumerationComponent } from "./components/answerNumerationComponent";
+import { listSortingAndOrderingBase } from "./components/listSortingAndOrderingBase";
+import { setPointsPopupBase } from "./components/setPointsPopupBase";
+import { studentResponseAndLayoutComponent } from "./components/studentResponseAreaAndLayoutComponent";
+const css = Cypress.env('css');
 
 const selectors = {
+    ...commonComponents,
     ...optionsWrapperComponent,
+    ...scoringSectionBase,
+    ...autoScoredScoringSectionMultipleResponsesType,
+    ...autoScoredSetCorrectAnswerSection,
+    ...autoScoredAdditionalSettings,
+    ...previewScoringAndShowCorrectAnswerComponent,
+    ...autoScoredPreviewBase,
+    ...additionalSettingsPanel,
     ...questionInstructionsComponent,
-    ...commonComponents,
-    //Specify correct answer section
-    optionSpecifyCorrectAnswerSection: () => cy.get('.list-ordering-set-correct-answer .draggable-item-wrapper[role="button"]'),
-    optionWrapperSpecifyCorrectAnswerSection: () => cy.get('[class*="ListOrderingResponsestyles__DroppableWrapper"]'),
+    ...answerNumerationComponent,
+    ...setPointsPopupBase,
+    ...listSortingAndOrderingBase,
+    //Set correct answer section
+    setCorrectAnswerSectionOption: () => cy.get('.list-ordering-set-correct-answer .draggable-item-wrapper[role="button"]'),
+    setCorrectAnswerSectionOptionsWrapper: () => cy.get('[class*="ListOrderingResponsestyles__DroppableWrapper"]'),
     //Preview Tab
-    optionPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .draggable-item-wrapper[role="button"]'),
-    optionWrapperPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .orderlist-option-wrapper'),
-    correctAnswersLabel: () => cy.get('.check-answer-and-status-wrapper [class*="CorrectAnswerLabel"]'),
-    correctAnswerSectionAnswerWrapper: () => cy.get('[class*="CorrectAnswers"] [class*="__OptionsWrapper"]'),
-    correctAnswerSectionAnswerText: () => cy.get('.question-text-wrapper'),
-    //grading view and correct answer view
-    optionGradingView: () => cy.get('[class*="DraggableItemsWrapper"] [class*="OptionTextWrapper"]'),
-    optionWrapperGradingView: () => cy.get('[class*="DraggableItemsWrapper"] [class*="OptionsWrapper"]'),
+    pointsPerResponseLabel: () => cy.get('.list-ordering-points-text'),
+    previewTabOption: () => cy.get('.edit-question-preview-wrapper .draggable-item-wrapper[role="button"]'),
+    previewTabOptionsWrapper: () => cy.get('.edit-question-preview-wrapper [class*="ListOrderingResponsestyles__DroppableWrapper"]'),
+    partialEqualWeightsPointsPerResponseScore: () => cy.get('.orderlist-points-wrapper'),
+    partialDifferentWeightsPointsInputField: () => cy.get('.orderlist-points-wrapper input'),
+    partialDifferentWeightsPointsPerResponseLabel: () => cy.get('.list-ordering-points-wrapper'),
+    //Additional Settings
+    optionNumeration: () => cy.get('[class*="__IndexWrapper"]'),
+    setCorrectAnswerSectionTopLabel: () => cy.get('[class*="TopLabelWrapper"].top-bottom-label'),
+    setCorrectAnswerSectionBottomLabel: () => cy.get('[class*="BottomLabelWrapper"].top-bottom-label'),
+    previewTabTopLabel: () => cy.get('.edit-question-preview-wrapper [class*="TopLabelWrapper"].top-bottom-label'),
+    previewTabBottomLabel: () => cy.get('.edit-question-preview-wrapper  [class*="BottomLabelWrapper"].top-bottom-label'),
+    pointsPerResponseLabelForInlineOption: () => cy.get('[class*="ListOrderingstyles__EqualPointsWrapper"]'),
+    pointsPerResponseScoreForInlineOption: () => cy.get('[class*="ListOrderingstyles__EqualPointsWrapper"] span'),
+    //Set points popup
+    buttonSetPoints: () => cy.get('[class*="SetPointsstyle__Button"]'),
+    setPointsIcon: () => cy.get('[class*="SetPointsstyle__Button"] svg'),
+    //Remove after https://redmine.zeuslearning.com/issues/518498 is fixed
+    dragHandleButton: () => cy.get('[class*="DragIcon"]')
 }
 
 const steps = {
     ...createQuestionBasePage.steps,
     ...questionInstructionsComponent.steps,
-    ...scoringSectionBaseEditTab.steps,
+    ...scoringSectionBase.steps,
+    ...autoScoredSetCorrectAnswerSection.steps,
+    ...commonComponents.steps,
     ...optionsWrapperComponent.steps,
-    ...autoScoredScoringPreviewTab.steps,
-    ...correctIncorrectAnswerLabelComponent.steps,
-    ...autoScoredStudentViewSettings.steps,
-    ...autoScoredScoringSectionMultiResponseType.steps,
-    ...autoScoredSpecifyCorrectAnswerSection.steps,
+    ...ckEditorToolbar.steps,
+    ...equationEditorFlyout.steps,
+    ...autoScoredScoringSectionMultipleResponsesType.steps,
+    ...additionalSettingsPanel.steps,
+    ...previewScoringAndShowCorrectAnswerComponent.steps,
+    ...autoScoredPreviewBase.steps,
+    ...autoScoredAdditionalSettings.steps,
+    ...autoScoredScoringSection.steps,
+    ...answerNumerationComponent.steps,
+    ...setPointsPopupBase.steps,
+    ...listSortingAndOrderingBase.steps,
     /**
-     * @param {string} optionsText text content of the option
-     * @param {number} targetIndex the position at which the options is being dropped
-     * @description click and drop a option into a position in the specify correct answer section
+     * @param {number} index set correct answer option index
+     * @description this function verfies contents of options
      */
-    clickAndReorderOptionInSpecifyCorrectAnswerSection: (optionsText, targetIndex) => {
-        listOrderingPage.optionSpecifyCorrectAnswerSection()
-            .contains(optionsText)
-            .click();
-        listOrderingPage.optionSpecifyCorrectAnswerSection()
-            .eq(targetIndex)
-            .click();
+    verifyDragHandleButtonOfOptionInSetCorrectAnswerSection: (index) => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .within(() => {
+                listOrderingPage.dragHandleButton()
+                    .should('exist');
+            });
     },
 
     /**
+     * @param {string[]} optionsTextArray options array for set correct answer option
+     * @description this function verifies options text content
+     */
+    verifyOptionsTextContentInSetCorrectAnswerSection: (optionsTextArray) => {
+        optionsTextArray.forEach((optionsText, index) => {
+            listOrderingPage.setCorrectAnswerSectionOption()
+                .eq(index)
+                .should('have.text', optionsText);
+        });
+    },
+
+    /**
+     * @param {number} index of option
+     * @description this function verifies image in set correct answer option input field
+     */
+    verifyImageAddedToOptionInSetCorrectAnswerSection: (index) => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    /**
+     * @param {number} index of option
+     * @description this function verifies equation in set correct answer option input field
+     */
+    verifyEquationAddedToOptionInSetCorrectAnswerSection: (index) => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .contains(constants.CKEditorInputFieldEnteredEquationText)
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+    },
+
+    /**
+     * @param {number} index of option
+     * @description this function link in set correct answer option input field
+     */
+    verifyLinkAddedToOptionInSetCorrectAnswerSection: (index) => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .should('have.text', 'lorem')
+            .find('a')
+            .should('have.attr', 'href', `${Cypress.config().baseUrl}`)
+    },
+
+    /**
+     * @param {number} index of option
+     * @description this function bold text in set correct answer option input field
+     */
+    verifyBoldTextAddedToOptionInSetCorrectAnswerSection: (index) => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .find('strong')
+            .eq(0)
+            .should('have.text', 'This is a bold option');
+    },
+
+    verifyDefaultAndActiveStateOfOptionInSetCorrectAnswerSection: () => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(0)
+            .realHover()
+            .should('have.css', 'border', `2px solid ${css.color.activeButtons}`)
+            .find('.question-text-wrapper')
+            .and('have.css', 'color', css.color.activeButtons);
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(0)
+            .realHover({ position: 'topLeft' })
+            .should('have.css', 'border', `1px solid ${css.color.figDefaultComponentBorder}`)
+            .find('.question-text-wrapper')
+            .and('have.css', 'color', css.color.text)
+    },
+
+    /**
+     * 
      * @param {string} optionsText text content of the option
-     * @param {number} targetIndex the position at which the options is being dropped
-     * @description click and drop a option into a position in the preview tab
+     * @param {number} index the position at which the options is being dropped
+     * @description click and drop a option into a position in the set correct answer section
      */
-    clickAndReorderOptionInPreviewTab: (optionsText, targetIndex) => {
-        listOrderingPage.optionPreviewTab()
+    clickAndReorderOptionInSetCorrectAnswerSection: (optionsText, index) => {
+        listOrderingPage.setCorrectAnswerSectionOption()
             .contains(optionsText)
             .click();
-        listOrderingPage.optionPreviewTab()
-            .eq(targetIndex)
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(index)
             .click();
     },
 
+    verifyPointsInputFieldErrorMessage: () => {
+        commonComponents.errorMessage()
+            .eq(0)
+            .should('have.text', 'Error: Please enter points.');
+    },
+
+    //Preview tab
+    /**
+    * @param {number} index set correct answer option index
+    * @description this function verfies contents of options
+    */
+    verifyDragHandleButtonOfOptionInPreviewTab: (index) => {
+        listOrderingPage.previewTabOption()
+            .eq(index)
+            .within(() => {
+                listOrderingPage.dragHandleButton()
+                    .should('exist');
+            });
+    },
+
+    /**
+     * @param {string[]} optionsTextArray options array for set correct answer option
+     * @description this function verifies options text content
+     */
+    verifyTextContentOfOptionsInPreviewTab: (optionsTextArray) => {
+        optionsTextArray.forEach((optionsText, index) => {
+            listOrderingPage.previewTabOption()
+                .eq(index)
+                .should('have.text', optionsText);
+        });
+    },
+
     /**
-    * @description Verifies that the image in the Preview tab has the correct source and alt text.
-    * @param {number} optionIndex - The index of the option in the Preview tab.
+    * @param {number} index of option
+    * @description this function verifies image text in preview tab options
     */
-    verifyOptionWithImageInPreviewTab: (optionIndex) => {
-        listOrderingPage.optionPreviewTab()
-            .eq(optionIndex)
+    verifyImageAddedToOptionInPreviewTab: (index) => {
+        listOrderingPage.previewTabOption()
+            .eq(index)
             .find('img')
             .should('have.attr', 'src', constants.foxImageLink)
             .and('have.attr', 'alt', constants.foxImageAltText);
     },
 
     /**
-     * @description Verifies that the bold text in the Preview tab is correct.
-     * @param {number} optionIndex - The index of the option in the Preview tab.
-     */
-    verifyOptionWithBoldTextInPreviewTab: (optionIndex) => {
-        listOrderingPage.optionPreviewTab()
-            .eq(optionIndex)
+    * @param {number} index of option
+    * @description this function verifies equation text in preview tab options
+    */
+    verifyEquationAddedToOptionInPreviewTab: (index) => {
+        listOrderingPage.previewTabOption()
+            .eq(index)
+            .contains(constants.CKEditorInputFieldEnteredEquationText)
+        listOrderingPage.previewTabOption()
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+    },
+
+    /**
+    * @param {number} index of option
+    * @description this function verifies link in preview tab options
+    */
+    verifyLinkAddedToOptionInPreviewTab: (index) => {
+        listOrderingPage.previewTabOption()
+            .eq(index)
+            .should('have.text', 'lorem')
+            .find('a')
+            .should('have.attr', 'href', `${Cypress.config().baseUrl}`)
+    },
+
+    /**
+    * @param {number} index of option
+    * @description this function verifies bold text in preview tab options
+    */
+    verifyBoldTextAddedToOptionInPreviewTab: (index) => {
+        listOrderingPage.previewTabOption()
+            .eq(index)
             .find('strong')
-            .should('have.text', 'This is a bold option');
+            .should('exist')
+            .should('have.text', 'This is a bold option')
+    },
+
+    verifyDefaultAndActiveStateOfOptionInPreviewTab: () => {
+        listOrderingPage.previewTabOption()
+            .eq(0)
+            .realHover()
+            .should('have.css', 'border', `2px solid ${css.color.activeButtons}`)
+            .find('.question-text-wrapper')
+            .and('have.css', 'color', css.color.activeButtons);
+        listOrderingPage.previewTabOption()
+            .eq(0)
+            .realHover({ position: 'topLeft' })
+            .should('have.css', 'border', `1px solid ${css.color.figDefaultComponentBorder}`)
+            .find('.question-text-wrapper')
+            .and('have.css', 'color', css.color.text)
+    },
+
+    //Scoring
+    /**
+    * @param {number} points the points to be displayed in the partial equal weights points field
+    * @description this function checks the points per response in partial equal weights
+    */
+    verifyPartialEqualWeightsPointsPerResponseScore: (points) => {
+        listOrderingPage.partialEqualWeightsPointsPerResponseScore()
+            .each(($element) => {
+                cy.wrap($element)
+                    .verifyInnerText(points);
+            });
+    },
+
+    /**
+    * @description this function checks if the partial different weights points field is empty and visible
+    */
+    verifyPartialDifferentWeightsPointsInputFieldIsEmptyAndEnabled: () => {
+        listOrderingPage.partialDifferentWeightsPointsInputField()
+            .each(($element) => {
+                cy.wrap($element)
+                    .should('have.value', '')
+                    .and('be.visible')
+                    .and('be.enabled');
+            });
     },
 
     /**
-     * @description Verifies that the equation text in the Preview tab is correct.
-     * @param {number} optionIndex - The index of the option in the Preview tab.
+     * @param {number[]} pointsArray the array of points to be alloted to each option
+     * @description this function allots points to all the options
      */
-    verifyOptionWithEquationTextInPreviewTab: (optionIndex) => {
-        listOrderingPage.optionPreviewTab()
-            .eq(optionIndex)
-            .find('[role="math"]')
-            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
-            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    allotPartialDifferentWeightsToAllPointsFields: (pointsArray) => {
+        pointsArray.forEach((points, columnIndex) => {
+            listOrderingPage.partialDifferentWeightsPointsInputField()
+                .eq(columnIndex)
+                .clear()
+                .type(points, { delay: 0 })
+                .should('have.value', points);
+        });
+    },
+
+    verifyPartialDifferentWeightsPointsPerResponseLabel: () => {
+        listOrderingPage.partialDifferentWeightsPointsPerResponseLabel()
+            .verifyInnerText('Points per response')
+            .should('be.visible');
+    },
+
+    verifyPointsPerResponseLabel: () => {
+        listOrderingPage.pointsPerResponseLabel()
+            .verifyInnerText('Points per response')
+            .should('be.visible');
     },
 
     /**
-     * @param {string[]} optionsTextArray options array for set correct answer option
-     * @description this function verifies options text content
+     * 
+     * @param {string} optionsText text content of the option
+     * @param {number} index the position at which the options is being dropped
+     * @description click and drop a option into a position in the set correct answer section
+     */
+    clickAndReorderOptionInPrevewTab: (optionsText, index) => {
+        listOrderingPage.previewTabOption()
+            .contains(optionsText)
+            .click();
+        listOrderingPage.previewTabOption()
+            .eq(index)
+            .click();
+    },
+
+    /**
+     * 
+     * @param {string[]} optionsArray array of options set in options section
+     * @description this function resets the question preview
      */
-    verifyTextContentOfOptionInPreviewTab: (optionsText, index) => {
-        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionPreviewTab(), index), optionsText);
+    resetQuestionPreview: (optionsArray) => {
+        createQuestionBasePage.steps.switchToEditTab();
+        createQuestionBasePage.steps.switchToPreviewTab();
+        listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(optionsArray);
+    },
+
+    /**
+    * @param {string[]} numerationArray array of numeration numbers, lowercase, uppercase
+    * @description this function verifies the numeration of options
+    */
+    verifyOptionsNumeration: (numerationArray) => {
+        numerationArray.forEach((optionNumeration, index) => {
+            listOrderingPage.previewTabOption()
+                .eq(index)
+                .within(() => {
+                    listOrderingPage.optionNumeration()
+                        .should('have.text', optionNumeration);
+                });
+        });
     },
 
     /**
     * @param {string} optionsText option to be checked for the correct icon
     * @description This function verifies the correct icon in the preview tab
     */
-    verifyCorrectOptionIcon: (optionsText) => {
-        listOrderingPage.optionWrapperPreviewTab()
+    verifyCorrectOptionsCheckmarkIcon: (optionsText) => {
+        listOrderingPage.previewTabOption()
             .contains(optionsText)
             .parents('.orderlist-option-wrapper')
             .within(() => {
-                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'exist');
+                autoScoredPreviewBase.correctIcon()
+                    .and('be.visible');
             });
     },
 
@@ -118,113 +375,381 @@ const steps = {
     * @param {string} optionsText option to be checked for the correct icon
     * @description This function verifies the correct icon in the preview tab
     */
-    verifyIncorrectOptionIcon: (optionsText) => {
-        listOrderingPage.optionWrapperPreviewTab()
+    verifyIncorrectOptionsCrossmarkIcon: (optionsText) => {
+        listOrderingPage.previewTabOption()
             .contains(optionsText)
             .parents('.orderlist-option-wrapper')
             .within(() => {
-                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'exist');
+                autoScoredPreviewBase.incorrectIcon()
+                    .and('be.visible');
             });
     },
 
-    verifyCorrectAnswerSectionNotExists: () => {
-        utilities.verifyElementVisibilityState(listOrderingPage.correctAnswersLabel(), 'notExist');
-        utilities.verifyElementVisibilityState(listOrderingPage.correctAnswerSectionAnswerWrapper(), 'notExist');
+    verifyQuestionPreviewStateWhenShowCorrectAnswerIsUnchecked: () => {
+        cy.log('After deselecting Show correct answer checkbox, the question preview should return to the previous state');
+        previewScoringAndShowCorrectAnswerComponent.steps.uncheckShowCorrectAnswerCheckbox();
+        autoScoredPreviewBase.correctIcon()
+            .should('not.exist');
+        autoScoredPreviewBase.incorrectIcon()
+            .should('not.exist');
+        autoScoredPreviewBase.correctIncorrectAnswerLabel()
+            .should('not.exist');
+        autoScoredPreviewBase.steps.verifyCorrectIncorrectBorderNotVisible()
+    },
+
+    getOptionsArray: () => {
+        const optionsArray = []
+        listOrderingPage.previewTabOption()
+            .each(($el) => {
+                cy.wrap($el)
+                    .invoke('text')
+                    .then((text) => {
+                        optionsArray.push(text);
+                    });
+            });
+        return optionsArray;
     },
 
     /**
-     * @param {string[]} optionsTextArray array of options in the correct answer section
-     * @description this function verifies the correct order of options in correct answer section
+     * @param {string[]} optionsArray array of options set in the options section
+     * @description this function verifies if the options are Randomized in the preview tab
      */
-    verifyOptionsInCorrectAnswerSection: (optionsTextArray) => {
-        optionsTextArray.forEach((optionsText, index) => {
-            utilities.getNthElement(listOrderingPage.correctAnswerSectionAnswerWrapper(), index)
-                .within(() => {
-                    utilities.verifyTextContent(listOrderingPage.correctAnswerSectionAnswerText(), optionsText);
+    verifyRandomizeOptionOrder: (optionsArray) => {
+        let currentOptionsArray = [...optionsArray]
+        for (let index = 0; index < currentOptionsArray.length; index++) {
+            listOrderingPage.previewTabOption()
+                .eq(index)
+                .then(($element) => {
+                    expect($element.text()).to.be.oneOf(currentOptionsArray);
+                    currentOptionsArray = currentOptionsArray.filter((value) => value !== $element.text())
                 });
-        });
+        };
+        listOrderingPage.steps.verifyOptionsAreRerandomized(optionsArray)
+    },
+
+    /**
+    * @param {string[]} previousOrderOfOptionsArray array of previous order of options
+    * @description this function verifies that the order of the options is different from the previous order
+    */
+    verifyOptionsAreRerandomized: (previousOrderOfOptionsArray) => {
+        listOrderingPage.previewTabOption()
+            .should('not.have.text', '')
+            .and('not.have.text', previousOrderOfOptionsArray.join(''));
     },
 
     /**
-    * @description Verifies that the image in the Preview tab has the correct source and alt text.
-    * @param {number} optionIndex - The index of the option in the Preview tab.
+    * @param {number} index set correct answer option index
+    * @description this function verfies drag handle of options does not exist
     */
-    verifyOptionWithImageInGradingView: (optionIndex) => {
-        listOrderingPage.optionGradingView()
-            .eq(optionIndex)
+    verifyDragHandleButtonDoesNotExistInSetCorrectAnswerSection: (index) => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .within(() => {
+                listOrderingPage.dragHandleButton()
+                    .should('not.exist');
+            });
+    },
+
+    /**
+    * @param {number} index set correct answer option index
+    * @description this function verfies drag handle of options does not exist
+    */
+    verifyDragHandleButtonDoesNotExistInPreviewTab: (index) => {
+        listOrderingPage.previewTabOption()
+            .eq(index)
+            .within(() => {
+                listOrderingPage.dragHandleButton()
+                    .should('not.exist');
+            });
+    },
+
+    //Additional settings
+
+    verifyNoBorderForSetCorrectAnswerOption: () => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(0)
+            .should('have.css', 'border')
+            .and('match', /0px none/);
+    },
+
+    verifyNoBorderForPreviewTabOption: () => {
+        listOrderingPage.previewTabOption()
+            .eq(0)
+            .should('have.css', 'border')
+            .and('match', /0px none/);
+    },
+
+    clickOnSetPointsButton: () => {
+        listOrderingPage.buttonSetPoints()
+            .click();
+    },
+
+    verifySetPointsButton: () => {
+        utilities.verifyInnerText(listOrderingPage.buttonSetPoints(), 'Set points');
+        utilities.verifyElementVisibilityState(listOrderingPage.setPointsIcon(), 'visible');
+    },
+
+    /**
+       * @param {number} index of option
+       * @description this function verifies image in set points popup
+       */
+    verifyImageAddedToOptionInSetPointsPopup: (index) => {
+        setPointsPopupBase.setPointsPopupOptions()
+            .eq(index)
             .find('img')
             .should('have.attr', 'src', constants.foxImageLink)
             .and('have.attr', 'alt', constants.foxImageAltText);
     },
 
     /**
-     * @description Verifies that the bold text in the Preview tab is correct.
-     * @param {number} optionIndex - The index of the option in the Preview tab.
+    * @param {number} index of option
+    * @description this function verifies equation text in set points popup
+    */
+    verifyEquationAddedToOptionInSetPointsPopup: (index) => {
+        setPointsPopupBase.setPointsPopupOptions()
+            .eq(index)
+            .contains(constants.CKEditorInputFieldEnteredEquationText)
+        setPointsPopupBase.setPointsPopupOptions()
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+    },
+
+    /**
+     * @param {number} index of option
+     * @description this function link in set points popup
      */
-    verifyOptionWithBoldTextInGradingView: (optionIndex) => {
-        listOrderingPage.optionGradingView()
-            .eq(optionIndex)
+    verifyLinkAddedToOptionInSetPointsPopup: (index) => {
+        setPointsPopupBase.setPointsPopupOptions()
+            .eq(index)
+            .should('have.text', 'lorem')
+            .find('a')
+            .should('have.attr', 'href', `${Cypress.config().baseUrl}`)
+    },
+
+    /**
+    * @param {number} index of option
+    * @description this function bold text in in set points popup
+    */
+    verifyBoldTextAddedToOptionInSetPointsPopup: (index) => {
+        setPointsPopupBase.setPointsPopupOptions()
+            .eq(index)
             .find('strong')
+            .eq(0)
             .should('have.text', 'This is a bold option');
     },
 
     /**
-     * @description Verifies that the equation text in the Preview tab is correct.
-     * @param {number} optionIndex - The index of the option in the Preview tab.
+     * @param {number[]} numerationArray numeration array for the option
+     * @description this function checks the numeration of options in set points popup
      */
-    verifyOptionWithEquationTextInGradingView: (optionIndex) => {
-        listOrderingPage.optionGradingView()
-            .eq(optionIndex)
-            .find('[role="math"]')
-            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
-            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    verifySetPointsPopupOptionNumeration: (numerationArray) => {
+        numerationArray.forEach((optionNumeration, index) => {
+            setPointsPopupBase.dialogBox()
+                .within(() => {
+                    listOrderingPage.optionNumeration()
+                        .eq(index)
+                        .should('have.text', optionNumeration);
+                });
+        });
+    },
+
+    verifyCorrectIncorrectAnswerLabel: (labelText) => {
+        autoScoredPreviewBase.correctIncorrectAnswerLabel()
+            .should('be.visible')
+            .verifyInnerText(`${labelText} answer`)
+            .parents('[class*="__AnswerStatusWrapper"]')
+            .find('[class*="__AnswerStatusIcon"]')
+            .should('be.visible')
+            .should('have.text', `${labelText}-Icon`)
+    }
+}
+
+const tests = {
+    ...createQuestionBasePage.tests,
+    ...commonComponents.tests,
+    ...questionInstructionsComponent.tests,
+    ...autoScoredScoringSection.tests,
+    ...scoringSectionBase.tests,
+    ...autoScoredSetCorrectAnswerSection.tests,
+    ...previewScoringAndShowCorrectAnswerComponent.tests,
+    ...additionalSettingsPanel.tests,
+    ...autoScoredAdditionalSettings.tests,
+    ...answerNumerationComponent.tests,
+    ...studentResponseAndLayoutComponent.tests,
+    ...listSortingAndOrderingBase.tests,
+    verifyAllContentsOfSetCorrectAnswerSectionForScoringType: (scoringType, optionsArray) => {
+        it(`When user has selected ${scoringType} scoring type then added options should be displayed in the set correct answer section`, () => {
+            listOrderingPage.steps.verifyOptionsTextContentInSetCorrectAnswerSection(optionsArray);
+            for (let index = 0; index < 4; index++) {
+                listOrderingPage.steps.verifyDragHandleButtonOfOptionInSetCorrectAnswerSection(index);
+            }
+        });
     },
 
     /**
-     * @param {string[]} optionsTextArray options array for set correct answer option
-     * @description this function verifies options text content
+     * @param {number} totalPoints the maximum points that can be scored by the user
+     * @description this function verifies the functionality of minimum points when penalty points are not set and user attempts incorrect answer
      */
-    verifyTextContentOfOptionInGradingView: (optionsText, index) => {
-        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionGradingView(), index), optionsText);
+    verifyMinimumScoreAwardedIfAttemptedFunctionalityForIncorrectAnswer: (totalPoints) => {
+        it('When user has provided minimum score awarded (if attempted) points, then in Preview tab on entering incorrect answer, minimum score should be provided for the question', () => {
+            cy.log('Switch to edit tab and set minimum score if attempted points')
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.steps.expandMinimumScoringDropdown();
+            scoringSectionBase.steps.selectMinimumScoringTypeListOption('Award minimum score only if attempted');
+            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted('1')
+            createQuestionBasePage.steps.switchToPreviewTab()
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 0);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 1);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('flower', 2);
+            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['plant', 'seed', 'flower', 'sprout']);
+            listOrderingPage.previewScoreText()
+                .verifyInnerText(`1/${totalPoints}`);
+        });
+
+        it('When user removes minimum score awarded (if attempted) points, then in Preview tab on selecting any options other than correct answers, points should not be provided', () => {
+            cy.log('Switch to edit tab and remove minimum score if attempted points')
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.steps.clearMinimumScoreIfAttemptedPointsField();
+            createQuestionBasePage.steps.switchToPreviewTab()
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 0);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 1);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('flower', 2);
+            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['plant', 'seed', 'flower', 'sprout']);
+            listOrderingPage.previewScoreText()
+                .verifyInnerText(`0/${totalPoints}`);
+        });
     },
 
     /**
-     * @param {string} optionsText text content of the option
-     * @param {number} index the position at which the options is being dropped
-     * @description click and drop a option into a position in the set correct answer section
+     * 
+     * @param {number} scoredPoints the points scored by the user when penalty points are reduced
+     * @param {number} totalPoints the maximum points that can be scored by the user
+     * @description this function verifies the functionality of Penalty points when minimum points are not set and user attempts incorrect answer
      */
-    clickAndReorderOptionInGradingView: (optionsText, index) => {
-        listOrderingPage.optionGradingView()
-            .contains(optionsText)
-            .click();
-        listOrderingPage.optionGradingView()
-            .eq(index)
-            .click();
+    verifyPenaltyPointsFunctionalityForIncorrectAnswer: (scoredPoints, totalPoints) => {
+        it('When user has defined penalty points', () => {
+            cy.log('Pre-step: Switch to edit tab and set penalty points');
+            createQuestionBasePage.steps.switchToEditTab();
+            autoScoredScoringSectionMultipleResponsesType.steps.allotPenaltyPoints(3)
+
+            cy.log('After switching to preview tab, when user adds an incorrect answer input, then 0 points should be awarded(no negative points)');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 1);
+            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['sprout', 'plant', 'flower', 'seed']);
+            listOrderingPage.previewScoreText()
+                .verifyInnerText(`0/${totalPoints}`);
+
+            cy.log('When user adds a partially correct answer input, the points should be updated accordingly with deducted penalty points');
+            listOrderingPage.steps.resetQuestionPreview(['sprout', 'plant', 'flower', 'seed'])
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 0);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 1);
+            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['seed', 'plant', 'sprout', 'flower']);
+            listOrderingPage.previewScoreText()
+                .verifyInnerText(`${scoredPoints}/${totalPoints}`);
+
+            cy.log('Post step: Clearing the Penalty points field')
+            createQuestionBasePage.steps.switchToEditTab();
+            autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
+                .clear();
+        });
+    },
+
+    /**
+   * @param {*} totalPointsScored the maximum points that can be achieved by the user
+   * @description this function verifies the functionality of penalty points when penalty points are set and user attempts alternate tab answers
+   */
+    verifyPenaltyPointsFunctionalityForAlternateTabAnswers: (totalPointsScored) => {
+        it('When the user has alloted penalty points and attempts the question according to the alternate tab then user should be awarded with full points of the alternate tab and penalty points should not be deducted', () => {
+            listOrderingPage.steps.switchToEditTab()
+            listOrderingPage.steps.allotPenaltyPoints(3);
+            listOrderingPage.steps.switchToPreviewTab();
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 0);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 3);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('flower', 1);
+            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['seed', 'flower', 'sprout', 'plant']);
+            listOrderingPage.steps.verifyPreviewTabScoreText(`${totalPointsScored}`, `${totalPointsScored}`);
+            cy.log('Post step: Clearing the Penalty points field')
+            createQuestionBasePage.steps.switchToEditTab();
+            autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
+                .clear();
+        });
     },
 
     /**
-     * Verifies the order of options in the "Specify Correct Answer" section.
-     * @param {string[]} optionsTextArray - An array containing the text of options in the expected order.
+     * @param {number[]} scoredPointsArray An array of numbers representing points scored in different cases.
+     *   - The first element represents points scored for incorrect answers.
+     *   - The second element represents points scored for partially correct answers.
+     *   - The third element represents points scored when minimum score awarded (if attempted) points is greater than the points achieved by attempting the question partially correct
+     * @param {number} minimumPointsForPartialCorrectAnswers minimum score awarded (if attempted) points on attempting the question partially correct
+     * @param {number} totalPoints the maximum points that can be achieved by the user
+     * @description this function verifies the functionality of Minimum score if attempted points when penalty points are set and user attempts incorrect answer
+     * - For all incorrect responses
+     * - For partially correct responses, when points scored > minimum score awarded(if attempted) points
+     * - For partially correct responses, when minimum score awarded(if attempted) points > points scored
      */
-    verifyOptionsOrderInSpecifyCorrectAnswerSection: (optionsTextArray) => {
-        optionsTextArray.forEach((option, index) => {
-            utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionSpecifyCorrectAnswerSection(), index), option);
+    verifyMinimumScoreIfAttemptedAndPenaltyPointsFunctionalityForIncorrectAnswer: (scoredPointsArray, minimumPointsForPartialCorrectAnswers, totalPoints) => {
+        it('When user has defined both penalty points and minimum score awarded (if attempted) points', () => {
+            cy.log('Pre-step: Switch to edit tab and set minimum score awarded (if attempted) points and Penalty points');
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted(1);
+            autoScoredScoringSectionMultipleResponsesType.steps.allotPenaltyPoints(3);
+
+            cy.log('Switch to preview tab and give incorrect answer input to check that minimum points are displayed');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('flower', 0);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('sprout', 3);
+            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['flower', 'plant', 'seed', 'sprout']);
+            listOrderingPage.previewScoreText()
+                .verifyInnerText(`${scoredPointsArray[0]}/${totalPoints}`);
+
+            cy.log('When user adds a partially correct answer such that the points of the attempt(with penalty points deducted) is more than the minimum score awarded(if attempted) points');
+            listOrderingPage.steps.resetQuestionPreview(['sprout', 'plant', 'flower', 'seed']);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 0);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 1);
+            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['seed', 'plant', 'sprout', 'flower']);
+            listOrderingPage.previewScoreText()
+                .verifyInnerText(`${scoredPointsArray[1]}/${totalPoints}`);
+
+            cy.log('When user switches to edit tab and increases the minimum score awarded (if attempted) points to check the case for an attempt in which points of the attempt is less than minimum score awarded (if attempted) points, then the minimum score awarded (if attempted) points should be displayed to the user');
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.steps.clearMinimumScoreIfAttemptedPointsField()
+            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted(minimumPointsForPartialCorrectAnswers)
+            cy.log('Switching to preview tab');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 0);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 1);
+            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('flower', 2);
+            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['seed', 'plant', 'flower', 'sprout']);
+            listOrderingPage.previewScoreText()
+                .verifyInnerText(`${scoredPointsArray[2]}/${totalPoints}`);
         });
     },
 
+    //Additional settings
     /**
-     * Verifies the order of options in the preview tab
-     * @param {string[]} optionsTextArray - An array containing the text of options in the expected order.
+     * @param {string[]} numerationArray array of the numeration displayed with options numbers| lowercase| uppercase
+     * @description this function checks the numeration displayed for the options and correct answer container options when Show correct answer is checked
      */
-    verifyOptionsOrderInPreviewTab: (optionsTextArray) => {
-        optionsTextArray.forEach((option, index) => {
-            utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionPreviewTab(), index), option);
+    verifyOptionsAndCorrectAnswerContainerNumerationWhenShowCorrectAnswerCheckboxIsChecked: (numerationArray) => {
+        it('When user clicks on \'Show correct answer\' checkbox then the numeration should be displayed on the options as well as \'Correct answers:\' section', () => {
+            listOrderingPage.steps.checkShowCorrectAnswerCheckbox()
+            steps.verifyOptionsNumeration(numerationArray)
+            steps.verifyCorrectAnswerContainerNumeration(numerationArray)
+            cy.log('Post step: Uncheck \'Show correct answer\' checkbox')
+            listOrderingPage.steps.uncheckShowCorrectAnswerCheckbox()
         });
-    }
-}
+    },
 
-const tests = {
-    ...autoScoredScoringPreviewTab.tests
+    /**
+    * @param {string[]} numerationArray array of the numeration displayed with options numbers| lowercase| uppercase
+    * @description this function checks the numeration displayed for the options and correct answer container options when check answer is selected
+    */
+    verifyOptionsNumerationWhenCheckAnswerIsSelected: (numerationArray) => {
+        it('When user clicks on \'Check answer\' button then the numeration should be displayed in the options', () => {
+            listOrderingPage.steps.checkAnswer()
+            steps.verifyOptionsNumeration(numerationArray)
+        });
+    }
 }
 
 export const listOrderingPage = {