itemengine-cypress-automation 1.0.162-questionInsructionSelectorFix-15973d5.0 → 1.0.162

package/cypress/pages/matchingPage.js

@@ -1,6 +1,7 @@
 import constants from "../fixtures/constants";
 import utilities from "../support/helpers/utilities";
-import { createQuestionBasePage, questionInstructionsComponent, autoScoredScoringPreviewTab, scoringSectionBaseEditTab, draggableOptionContainer, draggableOptionsSectionComponent, correctIncorrectAnswerLabelComponent, maximumCapacityPerDropzoneComponent, optionsWrapperComponent, ckEditorToolbar, equationEditorFlyout, autoScoredStudentViewSettings, autoScoredSpecifyCorrectAnswerSection, commonComponents, autoScoredScoringSectionMultiResponseType } from "./components";
+import { createQuestionBasePage, questionInstructionsComponent, autoScoredScoringPreviewTab, scoringSectionBaseEditTab, draggableOptionContainer, draggableOptionsSectionComponent, correctIncorrectAnswerLabelComponent, maximumCapacityPerDropzoneComponent, optionsWrapperComponent, ckEditorToolbar, equationEditorFlyout, autoScoredStudentViewSettings, autoScoredSpecifyCorrectAnswerSection, commonComponents, randomizeOptionsComponent, autoScoredScoringSectionMultiResponseType, allowMultipleInstancesOfSameDraggableOptionComponent, studentViewSettingsLabelComponent, ariaLabelSectionComponent, additionalSettingsAccessibilitySectionComponent, gradingViewEnumerationComponent, additionalSettingsPanel, } from "./components";
+import { dialogBoxBase } from "./dialogBoxBase";
 const css = Cypress.env('css');
 const options = ['option 1', 'option 2', 'option 3'];
 const fourOptions = ['option 1', 'option 2', 'option 3', 'option 4'];
@@ -14,10 +15,20 @@ const selectors = {
     ...autoScoredScoringSectionMultiResponseType,
     ...autoScoredSpecifyCorrectAnswerSection,
     ...draggableOptionContainer,
+    ...allowMultipleInstancesOfSameDraggableOptionComponent,
+    ...randomizeOptionsComponent,
+    ...gradingViewEnumerationComponent,
+    ...ariaLabelSectionComponent,
+    ...scoringSectionBaseEditTab,
+    ...additionalSettingsPanel,
+...maximumCapacityPerDropzoneComponent,
+
     //Edit tab
     promptInputField: () => cy.get('.edit-mcq-stems-wrapper [role="textbox"]'),
-    promptInputFieldWrapper: () => cy.get('.edit-mcq-stems-wrapper .edit-mcq-option-wrapper'),
+    promptInputFieldWrapper: () => cy.get('.edit-mcq-stems-wrapper [class*="SingleOptionstyle__EditorBlockWrapper"]'),
     optionInputField: () => cy.get('.edit-mcq-options-wrapper [data-rbd-draggable-id*="option-draggable"] [role="textbox"]'),
+    optionWrapper: () => cy.get('.response-options-wrapper [data-rbd-draggable-id*="option-draggable"]'),
+    optionNumeration: () => cy.get('.response-options-wrapper [class*="SingleOptionstyle__AdornmentDiv"]'),
     promptNumeration: () => cy.get('[class*="SingleOptionstyle__AdornmentDiv"]'),
     promptLabel: () => cy.get('.match-list-stem-label'),
     promptHeaderLabel: () => cy.get('.prompt-header-container [class*="InlineTextFieldWithDebouncestyles__PropertyLabel"]'),
@@ -38,6 +49,10 @@ const selectors = {
     optionsLabel: () => cy.get('.cloze-with-drag-and-drop-options-label'),
     optionWrapper: () => cy.get('.response-options-wrapper [data-rbd-draggable-id*="option-draggable"]'),
     optionNumeration: () => cy.get('.response-options-wrapper [class*="SingleOptionstyle__AdornmentDiv"]'),
+    droppedDraggableOptionInDropzoneSpecifyCorrectAnswerSection: () => cy.get('[class*="MultipleDroppedItemstyles__ItemWrapper"]'),
+    optionsContainerSpecifyCorrectAnswerSection: () => cy.get('.draggable-wrapper'),
+    promptSpecifyCorrectAnswerSection: () => cy.get('.stem-container [data-testid="question-instruction-element"]'),
+    draggableOptionInDropzoneInSpecifyCorrectAnswer: () => cy.get('.item-content-wrapper'),
 
     //Penalty points
     penaltyPointsForEachIncorrectDropzoneInputField: () => cy.get('input[aria-label="Penalty points for each incorrect dropzone"]'),
@@ -45,21 +60,27 @@ const selectors = {
     partialEqualWeightsPerResponseScore: () => cy.get('[class*="PointsPerResponseValue"]'),
     partialDifferentWeightsPointsLabel: () => cy.get('.cloze-with-dropdown-partial-points-per-response-label'),
 
-    //Specify correct answer section
-    dropzoneSpecifyCorrectAnswerSection: () => cy.get('.authoring-droppable-hotspot-wrapper'),
-    promptSpecifyCorrectAnswerSection: () => cy.get('.stem-container [data-testid="question-instruction-element"]:visible'),
-    dropzoneSpecifyCorrectAnswerSection: () => cy.get('.authoring-droppable-hotspot-wrapper'),
-    optionContainerOptionsSpecifyCorrectAnswerSection: () => cy.get('.draggable-selected-item'),
+    //Student view settings
+    enableOuterBorderForQuestionLabel: () => cy.get('[data-ngie-testid*="enable-outer-border-for-question-checkbox"] .MuiFormControlLabel-label'),
+    enableOuterBorderForQuestionCheckbox: () => cy.get('[data-ngie-testid*="enable-outer-border-for-question-checkbox"] input'),
+    maxLimitInEachDropzoneHelpText: () => cy.get('.max-answer-dropzone-limit:visible'),
 
     //Preview tab
     promptContainerPreviewTab: () => cy.get('.stem-container:visible'),
     dropzonePreviewTab: () => cy.get('.cloze-with-drag-and-drop-preview [class*="MultipleDroppableHotspotstyle__DroppableHotspotWrapper"]'),
+    dropzoneNumerationPreviewTab: () => cy.get('[class*="MultipleDroppableHotspotstyle__NumerationDiv"]'),
     dropzoneOptionPreviewTab: () => cy.get('[class*="MultipleDroppedItemstyles__FlexWrapper"]'),
     dropzoneNumeration: () => cy.get('[class*="NumerationDiv"]'),
     correctAnswersNumeration: () => cy.get('.answer-numeration-number-box'),
+    correctAnswerResponseWrapper: () => cy.get('[class*="ClozeWithDragAndDropstyles__AnswerCell"]'),
     correctAnswersOptions: () => cy.get('.match-list-drag-and-drop .question-text-wrapper'),
     correctAnswersOptionContainer: () => cy.get('.draggable-selected-option'),
+    questionBorderPreviewTab: () => cy.get('[class*="ClozeWithDragAndDropstyles__WrapperDiv"]'),
+    correctAnswerResponseWrapperWithoutEnumeration: () => cy.get('.answer-status-response-preview-wrapper  .item-wrapper'),
+    correctAnswerTextWithoutEnumeration: () => cy.get('.answer-status-response-preview-wrapper  .item-wrapper'),
     correctIncorrectAnswerLabel: () => cy.get('[class*="AnswerStatusText"]'),
+    previewResponseWrapper: () => cy.get('[class*="ClozeWithDragAndDropstyles__PreviewResponseContainer"]:visible'),
+    droppedDraggableOptionInDropzonePreviewTab: () => cy.get('[class*="MultipleDroppedItemstyles__ItemWrapper"]'),
     dropzoneColumnAndPromptHeaderWrapperPreviewTab: () => cy.get('.edit-question-preview-wrapper [class*="ClozeWithDragAndDropstyles__ResponseHeaderWrapper"]')
 }
 
@@ -75,6 +96,9 @@ const steps = {
     ...equationEditorFlyout.steps,
     ...autoScoredStudentViewSettings.steps,
     ...autoScoredSpecifyCorrectAnswerSection.steps,
+    ...draggableOptionContainer.steps,
+    ...randomizeOptionsComponent.steps,
+    ...draggableOptionsSectionComponent.steps,
     ...autoScoredScoringSectionMultiResponseType.steps,
     ...draggableOptionsSectionComponent.steps,
     ...draggableOptionContainer.steps,
@@ -82,6 +106,13 @@ const steps = {
     ...draggableOptionsSectionComponent.steps,
     ...draggableOptionContainer.steps,
     ...autoScoredScoringSectionMultiResponseType.steps,
+    ...allowMultipleInstancesOfSameDraggableOptionComponent.steps,
+    ...randomizeOptionsComponent.steps,
+    ...additionalSettingsPanel.steps,
+    ...gradingViewEnumerationComponent.steps,
+    ...ariaLabelSectionComponent.steps,
+    ...maximumCapacityPerDropzoneComponent.steps,
+
     //Edit tab
     addPrompt: () => {
         matchingPage.addPromptButton()
@@ -146,7 +177,7 @@ const steps = {
             matchingPage.promptInputField()
                 .eq(index)
                 .clear()
-                .type(promptText, { delay: 500 })
+                .type(promptText, { delay: 50 })
                 .should('have.text', promptText);
         });
     },
@@ -207,9 +238,9 @@ const steps = {
     },
 
     /**
-         * @param {number} index of option
-         * @description this function verifies error message of option input field
-         */
+     * @param {number} index of option
+     * @description this function verifies error message of option input field
+     */
     verifyPromptInputFieldErrorMessage: (index) => {
         matchingPage.promptInputFieldWrapper()
             .eq(index)
@@ -228,7 +259,7 @@ const steps = {
             matchingPage.optionInputField()
                 .eq(index)
                 .clear()
-                .type(options, { delay: 500 })
+                .type(options, { delay: 50 })
                 .blur();
         });
     },
@@ -433,6 +464,41 @@ const steps = {
             .click();
     },
 
+    /**
+    * @param {number} dropzoneIndex index of the dropzone in specify correct answer section
+    * @param {string[]} responseArray array of options set as correct responses in a category cell
+    */
+    verifyDraggableOptionInDropzoneSpecifyCorrectAnswerSection: (dropzoneIndex, response) => {
+        matchingPage.dropzoneSpecifyCorrectAnswerSection()
+            .find('.item-content-container')
+            .eq(dropzoneIndex)
+            .should('have.text', response);
+    },
+
+    /**
+    * @description Verifies the text content of a specific preview tab dropzone element.
+    * @param {number} count - The index of the preview tab dropzone element to verify (zero-based).
+    * @param {string} text - The expected text content to match against the inner text of the specified dropzone element.
+    */
+    verifyDropzoneTextSpecifyCorrectAnswerSection: (count, text) => {
+        utilities.verifyInnerText(utilities.getNthElement(matchingPage.dropzoneSpecifyCorrectAnswerSection(), count), text);
+    },
+
+    /**
+    * @param {string} optionName denotes the text content of the draggable option
+    * @param {number} dropzoneIndex - The index of the dropzone. 
+    * @description click on a draggable option present in the category cell of specify correct answer section
+    */
+    clickOnDraggableOptionInDropzoneOfSpecifyCorrectAnswerSection: (optionName, dropzoneIndex) => {
+        matchingPage.dropzoneSpecifyCorrectAnswerSection()
+            .eq(dropzoneIndex)
+            .within(() => {
+                matchingPage.draggableOptionInDropzoneInSpecifyCorrectAnswer()
+                    .contains(optionName)
+                    .click();
+            });
+    },
+
     /**
     * @param {string} groupTitle group title
     * @param {string[]} optionArray array of options for a particular group
@@ -478,16 +544,58 @@ const steps = {
         });
     },
 
+    /**
+     * Verifies the text of a dropzone in the Specify Correct Answer section.
+     * @param {number} count - The index of the dropzone.
+     * @param {string} text - The expected text of the dropzone.
+     */
     verifyDropzoneTextSpecifyCorrectAnswerSection: (count, text) => {
         utilities.verifyInnerText(utilities.getNthElement(matchingPage.dropzoneSpecifyCorrectAnswerSection(), count), text);
     },
 
+    /**
+     * Verifies the options in the Option Container section of the Specify Correct Answer section.
+     * @param {Object[]} optionsArray - An array of objects containing the index and option text.
+     * @param {number} optionsArray.index - The index of the option.
+     * @param {string} optionsArray.optionText - The expected text of the option.
+     */
     verifyOptionContainerOptionSpecifyCorrectAnswerSection: (optionsArray) => {
         optionsArray.forEach(({ index, optionText }) => {
             utilities.verifyInnerText(utilities.getNthElement(matchingPage.optionContainerOptionsSpecifyCorrectAnswerSection(), index), optionText);
         });
     },
 
+    /**
+     * @description Click on dropzone in specify correct answer section
+     * @param {number} dropzoneIndex 
+     */
+    clickOnDropzoneOfSpecifyCorrectAnswerSection: (dropzoneIndex) => {
+        matchingPage.dropzoneSpecifyCorrectAnswerSection()
+            .eq(dropzoneIndex)
+            .click({ force: true });
+    },
+
+    /**
+      * @param {number} categoryIndex optionIndex of the dropzone in set correct answer section
+      * @param {string[]} responseArray array of options set as correct responses in a dropzone
+      */
+    verifyDraggableOptionInDropzoneSpecifyCorrectAnswerSection: (dropzoneIndex, responseArray) => {
+        matchingPage.dropzoneSpecifyCorrectAnswerSection()
+            .eq(dropzoneIndex)
+            .within(() => {
+                responseArray.forEach((response, count) => {
+                    utilities.verifyTextContent(utilities.getNthElement(matchingPage.droppedDraggableOptionInDropzoneSpecifyCorrectAnswerSection(), count), response);
+                });
+            });
+    },
+
+
+    /**
+     * Verifies the prompt container in the 'Specify correct answer' section.
+     * @param {Object[]} optionsArray - An array of objects containing index and optionText.
+     * @param {number} optionsArray[].index - The index of the prompt container.
+     * @param {string} optionsArray[].optionText - The expected text of the prompt container.
+     */
     verifyPromptContainerSpecifyCorrectAnswerSection: (optionsArray) => {
         optionsArray.forEach(({ index, optionText }) => {
             utilities.verifyInnerText(utilities.getNthElement(matchingPage.promptSpecifyCorrectAnswerSection(), index), optionText);
@@ -520,6 +628,14 @@ const steps = {
         });
     },
 
+    clickAndDropOptionInOptionsContainerInPreviewTab: (optionText) => {
+        matchingPage.dropzonePreviewTab()
+            .contains(optionText)
+            .click();
+        draggableOptionContainer.optionsContainerPreviewTab()
+            .click({ force: true });
+    },
+
     /**
     * Sets options in dropzone in the Preview Tab based on the provided optionsObject.
     * @param {Object[]} responses - An array of objects containing the responseIndex, responseText and dropzone index
@@ -562,6 +678,18 @@ const steps = {
             .contains(text);
     },
 
+    /**
+     * Verifies the correct answer response without enumeration at a specific index.
+     * @param {number} index - The index of the correct answer response to verify.
+     * @param {string} correctAnswer - The correct answer response to verify.
+     */
+    verifyCorrectAnswerResponsesWithoutEnumeration: (index, correctAnswer) => {
+        matchingPage.correctAnswerResponseWrapperWithoutEnumeration()
+            .eq(index)
+            .find('.question-text-wrapper')
+            .should('have.text', correctAnswer);
+    },
+
     /**
      * @description Verifies that the equation text in the Preview tab is correct.
      * @param {number} optionIndex - The index of the option in the Preview tab.
@@ -671,6 +799,18 @@ const steps = {
             .contains(constants.CKEditorInputFieldEnteredEquationText);
     },
 
+    /**
+     * Verifies the prompt container in the 'Specify correct answer' section.
+     * @param {Object[]} optionsArray - An array of objects containing index and optionText.
+     * @param {number} optionsArray[].index - The index of the prompt container.
+     * @param {string} optionsArray[].optionText - The expected text of the prompt container.
+     */
+    verifyPromptContainerPreviewTab: (optionsArray) => {
+        optionsArray.forEach(({ index, optionText }) => {
+            utilities.verifyInnerText(utilities.getNthElement(matchingPage.promptContainerPreviewTab(), index), optionText);
+        });
+    },
+
     verifyDropzoneNumeration: () => {
         matchingPage.dropzonePreviewTab()
             .each(($element, index) => {
@@ -768,10 +908,10 @@ const steps = {
     },
 
     /**
-    * @param {string} groupTitle group title
-    * @param {string[]} optionArray array of options for a particular group
-    * @description add a group with title and options in the response options section 
-    */
+     * @param {string} groupTitle group title
+     * @param {string[]} optionArray array of options for a particular group
+     * @description add a group with title and options in the response options section 
+     */
     addGroupWithTitleAndOptionsInDraggableOptionsSection: (groupTitle, optionArray) => {
         const numOptionsToAdd = Math.max(0, optionArray.length - 2);
         draggableOptionsSectionComponent.steps.addGroup();
@@ -779,7 +919,286 @@ const steps = {
         for (let i = 0; i < numOptionsToAdd; i++) {
             optionsWrapperComponent.steps.addOption();
         }
-        steps.enterTextInOptionInputField(optionArray);
+        matchingPage.steps.enterTextInOptionInputField(optionArray);
+    },
+
+    /**
+    * @param {number} dropzoneIndex index of the dropzone in preview tab
+    * @param {string[]} responseArray array of options set as correct responses in a category cell
+    */
+    verifyDraggableOptionInDropzoneOfPreviewTab: (dropzoneIndex, responseArray) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(dropzoneIndex)
+            .within(() => {
+                responseArray.forEach((response, count) => {
+                    utilities.verifyInnerText(utilities.getNthElement(cy.get('.item-content-container'), count), response);
+                });
+            });
+    },
+
+    verifyEnableOuterBorderForQuestionCheckboxCheckedState: () => {
+        matchingPage.enableOuterBorderForQuestionCheckbox()
+            .should('be.checked');
+    },
+
+    verifyEnableOuterBorderForQuestionCheckboxUncheckedState: () => {
+        matchingPage.enableOuterBorderForQuestionCheckbox()
+            .should('not.be.checked');
+    },
+
+    checkEnableOuterBorderForQuestionCheckbox: () => {
+        matchingPage.enableOuterBorderForQuestionCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    uncheckEnableOuterBorderForQuestionCheckbox: () => {
+        matchingPage.enableOuterBorderForQuestionCheckbox()
+            .click()
+            .should('not.be.checked');
+    },
+
+    verifyQuestionBorderNotExist: () => {
+        matchingPage.questionBorderPreviewTab()
+            .should('have.css', 'border')
+            .and('match', /0px none/);
+    },
+
+    /**
+    * @description Verifies the text content of a specific preview tab dropzone element.
+    * @param {number} count - The index of the preview tab dropzone element to verify (zero-based).
+    * @param {string} text - The expected text content to match against the inner text of the specified dropzone element.
+    */
+    verifyDropzoneTextPreviewTab: (count, text) => {
+        utilities.verifyInnerText(utilities.getNthElement(matchingPage.dropzonePreviewTab(), count), text);
+    },
+
+    verifyInactiveStateOfAllDropzoneInSpecifyCorrectAnswerSection: () => {
+        matchingPage.dropzoneSpecifyCorrectAnswerSection()
+            .should('not.have.class', 'isActiveForDrop');
+    },
+
+    verifyActiveStateOfAllDropzoneInSpecifyCorrectAnswerSection: () => {
+        matchingPage.dropzoneSpecifyCorrectAnswerSection()
+            .should('have.class', 'isActiveForDrop');
+    },
+
+    /**
+    * Verifies the dropzone enumeration in the preview tab.
+    * @param {string[]} enumerationArray - An array of enumeration values to verify.
+    * @returns {void}
+    */
+    verifyDropzoneEnumeration: (enumerationArray) => {
+        utilities.verifyElementCount(matchingPage.dropzonePreviewTab(), enumerationArray.length);
+        enumerationArray.forEach((option, index) => {
+            matchingPage.dropzonePreviewTab()
+                .eq(index)
+                .within(() => {
+                    utilities.verifyTextContent(matchingPage.dropzoneNumerationPreviewTab(), `${option}`);
+                });
+        });
+    },
+
+    /**
+     * Verifies the prompt container content in the preview tab.
+     * @param {Object[]} optionsArray - Array of objects containing index and optionText.
+     * @param {number} optionsArray[].index - The index of the prompt container element.
+     * @param {string} optionsArray[].optionText - The expected text to verify against the prompt container element.
+     */
+    verifyPromptContainerPreviewTab: (optionsArray) => {
+        optionsArray.forEach(({ index, optionText }) => {
+            utilities.verifyInnerText(utilities.getNthElement(matchingPage.promptContainerPreviewTab(), index), optionText);
+        });
+    },
+
+    /**
+     * Verifies the correct answer dropzone enumeration.
+     * @param {string[]} enumerationArray - An array of enumeration values to verify.
+     * @returns {void}
+     */
+    verifyCorrectAnswerDropzoneEnumeration: (enumerationArray) => {
+        utilities.verifyElementCount(matchingPage.correctAnswerResponseWrapper(), enumerationArray.length);
+        enumerationArray.forEach((option, index) => {
+            matchingPage.correctAnswerResponseWrapper()
+                .eq(index)
+                .within(() => {
+                    utilities.verifyInnerText(matchingPage.correctAnswersNumeration(), `${option}`);
+                });
+        });
+    },
+
+    verifyDropzoneNumerationNotExistsPreviewTab: () => {
+        utilities.verifyElementVisibilityState(matchingPage.dropzoneNumerationPreviewTab(), 'notExist');
+    },
+
+    /**
+     * Verifies the ARIA label of a dropzone in the 'Specify correct answer' section.
+     * @param {number} inputFieldIndex - The index of the input field.
+     * @param {string} ariaLabel - The expected ARIA label of the dropzone.
+     */
+    verifyDropzoneAriaLabelSpecifyCorrectAnswerSection: (inputFieldIndex, ariaLabel) => {
+        matchingPage.dropzoneSpecifyCorrectAnswerSection()
+            .eq(inputFieldIndex)
+            .should('have.attr', 'aria-label', ariaLabel);
+    },
+
+    /**
+     * Verifies the ARIA label of a dropzone in the preview tab.
+     * @param {number} inputFieldIndex - The index of the input field.
+     * @param {string} ariaLabel - The expected ARIA label of the dropzone.
+     */
+    verifyDropzoneAriaLabelPreviewTab: (inputFieldIndex, ariaLabel) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(inputFieldIndex)
+            .should('have.attr', 'aria-label', ariaLabel);
+    },
+
+    /**
+     * @param {number} responseAreaIndex Index of the dropzone in specify correct answer section
+     * @description Verify drag handle is not visible in filled category cell in specify correct answer section
+     */
+    verifyDragHandleNotVisibleInFilledDropzoneOfSpecifyCorrectAnswerSection: (responseAreaIndex) => {
+        matchingPage.dropzoneSpecifyCorrectAnswerSection()
+            .eq(responseAreaIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(draggableOptionContainer.draggableOptionDragIcon(), 'notExist')
+            });
+    },
+
+    verifyInactiveStateOfAllDropzoneInPreviewTab: () => {
+        matchingPage.dropzonePreviewTab()
+            .should('not.have.class', 'isActiveForDrop');
+    },
+
+    verifyActiveStateOfAllDropzoneInPreviewTab: () => {
+        matchingPage.dropzonePreviewTab()
+            .should('have.class', 'isActiveForDrop');
+    },
+
+    /**
+      * Verifies the inactive state of unselected draggable options in the preview tab.
+      * @param {number[]} optionIndexArray - An array containing the indices of unselected draggable options.
+      */
+    verifyInactiveStateOfUnselectedDraggableOptionsInPreviewTab: (optionIndexArray) => {
+        draggableOptionContainer.optionsContainerPreviewTab()
+            .within(() => {
+                optionIndexArray.forEach((optionIndex) => {
+                    draggableOptionContainer.draggableOption()
+                        .eq(optionIndex)
+                        .should('not.have.class', 'isSelected');
+                });
+            });
+    },
+
+    /**
+     * @param {number} dropzoneIndex index of the dropzone in preview tab
+     * @param {string[]} responseArray array of options set as correct responses in a category cell
+     */
+    verifyDraggableOptionInDropzoneOfPreviewTab: (dropzoneIndex, responseArray) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(dropzoneIndex)
+            .within(() => {
+                responseArray.forEach((response, count) => {
+                    utilities.verifyInnerText(utilities.getNthElement(cy.get('.item-content-container'), count), response);
+                });
+            });
+    },
+
+    /**
+    * @param {number} responseAreaIndex Index of the dropzone in preview tab
+    * @description Verify drag handle is not visible in filled category cell in preview tab
+    */
+    verifyDragHandleNotVisibleInFilledDropzoneOfPreviewTab: (responseAreaIndex) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(responseAreaIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(draggableOptionContainer.draggableOptionDragIcon(), 'notExist')
+            });
+    },
+
+    /**
+    * @param {string} optionName denotes the text content of the draggable option
+    * @param {number} dropzoneIndex - The index of the dropzone. 
+    * @description click on a draggable option present in the category cell of preview tab
+    */
+    clickOnDraggableOptionInDropzoneOfPreviewTab: (optionName, dropzoneIndex) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(dropzoneIndex)
+            .find('.item-content-wrapper')
+            .contains(optionName)
+            .click();
+    },
+
+    /**
+     * Clicks on a draggable option present in the category cell of the preview tab and drops it into the options container.
+     * @param {string} optionName - The text content of the draggable option.
+     * @param {number} dropzoneIndex - The index of the dropzone.
+     */
+    clickAndDropDraggableOptionFromDropzoneToOptionsContainerPreviewTab: (optionName, dropzoneIndex) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(dropzoneIndex)
+            .find('.item-content-wrapper')
+            .contains(optionName)
+            .click({ force: true });
+        matchingPage.optionsContainerPreviewTab()
+            .click();
+    },
+
+    /**
+    * @description Click on dropzone in preview tab
+    * @param {number} dropzoneIndex 
+    */
+    clickOnDropzoneOfPreviewTab: (dropzoneIndex) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(dropzoneIndex)
+            .click({ force: true });
+    },
+
+    /**
+ * Verifies that the options are randomized in the preview tab.
+ * @param {string[]} promptArray - Array of options set in the correct answer section.
+ */
+    verifyRandomizePromptOrder: (promptArray) => {
+        let currentOptions = [...promptArray];
+        matchingPage.previewResponseWrapper().within(() => {
+            for (let index = 0; index < currentOptions.length; index++) {
+                matchingPage.promptContainerPreviewTab()
+                    .eq(index)
+                    .then(($element) => {
+                        expect($element.text()).to.be.oneOf(currentOptions);
+                        currentOptions = currentOptions.filter((value) => value !== $element.text());
+                    });
+            }
+        });
+        matchingPage.steps.verifyPromptAreRerandomized(promptArray);
+    },
+
+    /**
+     * Verifies that options in the preview tab have been re-randomized compared to the previous order.
+     * @param {string[]} previousOrderOfPrompt - An array representing the previous order of options.
+     */
+    verifyPromptAreRerandomized: (previousOrderOfPrompt) => {
+        matchingPage.previewResponseWrapper().within(() => {
+            matchingPage.promptContainerPreviewTab()
+                .should('not.have.text', '')
+                .and('not.have.text', previousOrderOfPrompt.join(''));
+        });
+    },
+
+    getPromptArray: () => {
+        const promptArray = []
+        commonComponents.previewTabQuestionWrapper()
+            .within(() => {
+                matchingPage.promptContainerPreviewTab()
+                    .each(($el) => {
+                        cy.wrap($el)
+                            .invoke('text')
+                            .then((text) => {
+                                promptArray.push(text);
+                            });
+                    });
+            });
+        return promptArray;
     },
 
     /**
@@ -883,12 +1302,20 @@ const tests = {
     ...autoScoredScoringPreviewTab.tests,
     ...scoringSectionBaseEditTab.tests,
     ...autoScoredScoringSectionMultiResponseType.tests,
+    ...additionalSettingsPanel.tests,
+    ...gradingViewEnumerationComponent.tests,
+    ...additionalSettingsAccessibilitySectionComponent.tests,
+    ...ariaLabelSectionComponent.tests,
     ...optionsWrapperComponent.tests,
     ...draggableOptionContainer.tests,
     ...autoScoredSpecifyCorrectAnswerSection.tests,
     ...createQuestionBasePage.tests,
     ...commonComponents.tests,
     ...draggableOptionsSectionComponent.tests,
+    ...studentViewSettingsLabelComponent.tests,
+    ...randomizeOptionsComponent.tests,
+    ...allowMultipleInstancesOfSameDraggableOptionComponent.tests,
+    ...autoScoredStudentViewSettings.tests,
     ...questionInstructionsComponent.tests,
 
     verifyContentsOfSpecifyCorrectAnswerSection: () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itemengine-cypress-automation",
-  "version": "1.0.162-questionInsructionSelectorFix-15973d5.0",
+  "version": "1.0.162",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -35,4 +35,4 @@
     "node-fetch": "^3.3.2",
     "react-uuid": "^2.0.0"
   }
-}
+}