itemengine-cypress-automation 1.0.119 → 1.0.121

package/cypress/pages/singleSelectionGridPage.js

@@ -1,4 +1,4 @@
-import { additionalSettingsPanel, autoScoredAdditionalSettings, autoScoredPreviewBase, autoScoredScoringSection, autoScoredScoringSectionMultipleResponsesType, autoScoredSetCorrectAnswerSection, commonComponents, createQuestionBasePage, mcqScoringComponent, optionsWrapperComponent, previewScoringAndShowCorrectAnswerComponent, questionInstructionsComponent, scoringSectionBase } from "./components";
+import { additionalSettingsPanel, autoScoredAdditionalSettings, autoScoredPreviewBase, autoScoredScoringSection, autoScoredScoringSectionMultipleResponsesType, autoScoredSetCorrectAnswerSection, commonComponents, createQuestionBasePage, optionsWrapperComponent, previewScoringAndShowCorrectAnswerComponent, questionInstructionsComponent, scoringSectionBase } from "./components";
 import { gridCommonComponents } from "./components/gridCommonComponents";
 import { studentResponseAndLayoutComponent } from "./components/studentResponseAreaAndLayoutComponent";
 const css = Cypress.env('css');
@@ -254,7 +254,6 @@ const tests = {
     ...autoScoredSetCorrectAnswerSection.tests,
     ...autoScoredScoringSection.tests,
     ...scoringSectionBase.tests,
-    ...mcqScoringComponent.tests,
     ...commonComponents.tests,
     ...previewScoringAndShowCorrectAnswerComponent.tests,
     ...gridCommonComponents.tests,

package/cypress/pages/singleSelectionPage.js

@@ -1,6 +1,6 @@
 import constants from "../fixtures/constants";
 import utilities from "../support/helpers/utilities";
-import { additionalSettingsPanel, createQuestionBasePage, mcqAdditionalSettingsBase, scoringSectionBaseEditTab, autoScoredSpecifyCorrectAnswerSection, autoScoredScoringSection, optionsWrapperComponent, commonComponents, autoScoredScoringPreviewTab, autoScoredStudentViewSettings, ckEditorToolbar, equationEditorFlyout, randomizeOptionsComponent, lockUnlockOptionComponent, questionInstructionsComponent } from "./components";
+import { additionalSettingsPanel, createQuestionBasePage, mcqAdditionalSettingsBase, scoringSectionBaseEditTab, autoScoredSpecifyCorrectAnswerSection, optionsWrapperComponent, commonComponents, autoScoredScoringPreviewTab, autoScoredStudentViewSettings, ckEditorToolbar, equationEditorFlyout, randomizeOptionsComponent, lockUnlockOptionComponent, questionInstructionsComponent } from "./components";
 const css = Cypress.env('css');
 
 const options = ['Pollution caused by treating chemical waste', 'Pollution caused by cement production', 'Pollution caused by methane production', 'Pollution caused by cement and methane production'];
@@ -37,7 +37,6 @@ const steps = {
     ...additionalSettingsPanel.steps,
     ...scoringSectionBaseEditTab.steps,
     ...autoScoredSpecifyCorrectAnswerSection.steps,
-    ...autoScoredScoringSection.steps,
     ...commonComponents.steps,
     ...optionsWrapperComponent.steps,
     ...autoScoredScoringPreviewTab.steps,
@@ -48,9 +47,9 @@ const steps = {
     ...randomizeOptionsComponent.steps,
     ...lockUnlockOptionComponent.steps,
     /**
-               * Verifies the contents of an option wrapper in the 'Specify correct answer' section for single selection questions.
-               * @param {number} optionIndex - The index of the option wrapper to be verified.
-               */
+    * Verifies the contents of an option wrapper in the 'Specify correct answer' section for single selection questions.
+    * @param {number} optionIndex - The index of the option wrapper to be verified.
+    */
     verifyOptionWrapperContentsSpecifyCorrectAnswerSection: (optionIndex) => {
         singleSelectionPage.optionWrapperSpecifyCorrectAnswerSection()
             .eq(optionIndex)
@@ -452,10 +451,10 @@ const tests = {
     ...additionalSettingsPanel.tests,
     ...scoringSectionBaseEditTab.tests,
     ...autoScoredSpecifyCorrectAnswerSection.tests,
-    ...autoScoredScoringSection.tests,
     ...autoScoredScoringPreviewTab.tests,
     ...optionsWrapperComponent.tests,
     ...commonComponents.tests,
+    ...autoScoredStudentViewSettings.tests,
     verifyContentsOfSpecifyCorrectAnswerSection: () => {
         it('In the \'Correct\' accordion, all options with checkboxes should be displayed', () => {
             utilities.verifyElementCount(singleSelectionPage.optionWrapperSpecifyCorrectAnswerSection(), 4);

package/cypress/pages/textEntryMathPage.js

@@ -118,6 +118,7 @@ const steps = {
     verifyResponseAccordionIsCollapsed: (responseIndex) => {
         utilities.getNthElement(textEntryMathPage.responseAccordion(), responseIndex)
             .find('.ngie-accordion-summary')
+            .eq(0)
             .should('have.attr', 'aria-expanded', 'false');
     },
 
@@ -128,6 +129,7 @@ const steps = {
     verifyResponseAccordionIsExpanded: (responseIndex) => {
         utilities.getNthElement(textEntryMathPage.responseAccordion(), responseIndex)
             .find('.ngie-accordion-summary')
+            .eq(0)
             .should('have.attr', 'aria-expanded', 'true');
     },
 
@@ -159,6 +161,8 @@ const steps = {
      */
     collapseResponseAccordionSpecifyCorrectAnswer: (responseIndex) => {
         utilities.getNthElement(textEntryMathPage.responseAccordion(), responseIndex)
+            .find('[class*= "expandIconWrapper"]')
+            .eq(0)
             .click();
         textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(responseIndex);
     },
@@ -694,23 +698,29 @@ const steps = {
     },
 
     /**
-     * This function verifies the correct icon for the response field
-     * @param {number} index of the response field
-     */
+    * This function verifies the correct icon for the response field
+    * @param {number} index of the response field
+    */
     verifyCorrectResponseIcon: (index) => {
-        textEntryMathPage.tickIcon()
+        textEntryMathPage.responseFieldWrapperPreviewTab()
             .eq(index)
-            .verifyPseudoClassBeforeProperty('color', css.color.correctAnswer);
+            .within(() => {
+                textEntryMathPage.tickIcon()
+                    .verifyPseudoClassBeforeProperty('color', css.color.correctAnswer);
+            });
     },
 
     /**
-     * This function verifies the incorrect icon for the response field
-     * @param {number} index of the response field
-     */
+    * This function verifies the incorrect icon for the response field
+    * @param {number} index of the response field
+    */
     verifyIncorrectResponseIcon: (index) => {
-        textEntryMathPage.tickIcon()
+        textEntryMathPage.responseFieldWrapperPreviewTab()
             .eq(index)
-            .verifyPseudoClassBeforeProperty('color', css.color.incorrectAnswer);
+            .within(() => {
+                textEntryMathPage.tickIcon()
+                    .verifyPseudoClassBeforeProperty('color', css.color.incorrectAnswer);
+            });
     },
 
     /**
@@ -746,6 +756,10 @@ const steps = {
                     utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'visible');
                 }
             });
+    },
+
+    verifyAlternativeAnswerAccordionNotExists: () => {
+        utilities.verifyElementVisibilityState(textEntryMathPage.alternativeAnswerAccordion().contains('Alternative 2'), 'notExist');
     }
 }
 
@@ -764,19 +778,33 @@ const tests = {
      * @example - verifySpecifyCorrectAnswerAccordionContentsAndFunctionality('Correct');
      */
     verifySpecifyCorrectAnswerAccordionContentsAndFunctionality: (accordionName) => {
-        it(`By default, two response accordions \'Response #\' should be displayed in the ${accordionName} accordion in collapsed state`, () => {
-            utilities.verifyElementCount(textEntryMathPage.responseAccordion(), 2);
-            textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(0);
-            textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(1);
-            utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.responseAccordionLabel(), 0), 'Response 1');
-            utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.responseAccordionLabel(), 1), 'Response 2');
-        });
+        if (accordionName === 'Correct') {
+            it(`By default, no response accordions should be displayed in the ${accordionName} accordion`, () => {
+                utilities.verifyElementCount(textEntryMathPage.responseAccordion(), 0);
+            });
+
+            it('When user adds response tokens in the question section they should be displayed in the \'Specify correct answer\' section in collapsed state', () => {
+                textEntryMathPage.steps.addResponseToken();
+                textEntryMathPage.steps.addResponseToken();
+                utilities.verifyElementCount(textEntryMathPage.responseAccordion(), 2);
+                textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(0);
+                textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(1);
+                utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.responseAccordionLabel(), 0), 'Response 1');
+                utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.responseAccordionLabel(), 1), 'Response 2');
+            });
+        }
 
-        it('When the user clicks on the response accordion, then the response accordion should be expanded', () => {
+        it('User should be able to expand and collapse the accordions', () => {
             textEntryMathPage.steps.expandResponseAccordionSpecifyCorrectAnswer(0);
+            textEntryMathPage.steps.verifyResponseAccordionIsExpanded(0);
+            textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(1);
+            textEntryMathPage.steps.collapseResponseAccordionSpecifyCorrectAnswer(0);
+            textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(0);
+            textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(1);
         });
 
         it('When user focuses in and out of the response accordion \'Answer\' input field, \'Error: Answer is required.\' error message should be displayed', () => {
+            textEntryMathPage.steps.expandResponseAccordionSpecifyCorrectAnswer(0);
             textEntryMathPage.steps.focusInAndFocusOutOfResponseAnswerInputFieldSpecifyCorrectAnswer(0, 0);
             utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible');
             utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Answer is required.');
@@ -792,10 +820,6 @@ const tests = {
             textEntryMathPage.steps.verifyResponseAccordionIsExpanded(0);
         });
 
-        it('User should be able to collapse response accordion', () => {
-            textEntryMathPage.steps.collapseResponseAccordionSpecifyCorrectAnswer(1);
-        });
-
         autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(accordionName);
 
         it(`CSS of ${accordionName} accordion contents`, { tags: 'css' }, () => {

package/cypress/pages/textEntryMathWithImagePage.js

@@ -0,0 +1,212 @@
+import { imageCanvasComponent, backgroundImageUploadComponent, questionInstructionsComponent, autoScoredScoringPreviewTab } from "./components"
+import { textEntryMathPage } from "./textEntryMathPage";
+import { dialogBoxBase } from "./dialogBoxBase";
+import utilities from "../support/helpers/utilities";
+const css = Cypress.env('css');
+
+const selectors = {
+    ...backgroundImageUploadComponent,
+    ...imageCanvasComponent,
+    ...textEntryMathPage,
+    ...dialogBoxBase,
+
+    addBackgroundButton: () => cy.get('[data-ngie-testid="add-background-tab"]'),
+    responseFieldPreviewTab: () => cy.get('.image-container .response-input-field'),
+    canvasInPreviewTab: () => cy.get('[class*="PreviewTabstyles__ContentWrapper"] .image-container'),
+    textAreaPreviewTab: () => cy.get('.label-image-with-text-preview [class*="TextBoxContainer"]'),
+    tickIcon: () => cy.get('.tick-icon-wrapper [data-name*="Rectangle"]'),
+    responseFieldWrapperPreviewTab: () => cy.get('.cloze-response-wrapper'),
+    responseFieldNumerationPreviewTab: () => cy.get('.image-container .response-input-adornment')
+}
+
+const steps = {
+    ...backgroundImageUploadComponent.steps,
+    ...imageCanvasComponent.steps,
+    ...questionInstructionsComponent.steps,
+    ...textEntryMathPage.steps,
+
+    addBackground: () => {
+        textEntryMathWithImagePage.addBackgroundButton()
+            .click();
+    },
+
+    verifyResponsePointerStyleInPreviewTab: (style, responseIndex) => {
+        const getPosition = (option) => {
+            switch (option) {
+                case 'Bottom':
+                    return { bottom: '50px', left: '-60px' };
+                case 'Bottom right':
+                    return { top: '-48px', right: '45px' };
+                case 'Right':
+                    return { top: '-24px', right: '53px' };
+                case 'Top right':
+                    return { top: '13px', right: '45px' };
+                case 'Top':
+                    return { top: '28px', left: '-60px' };
+                case 'Top left':
+                    return { top: '12px', left: '23px' };
+                case 'Left':
+                    return { top: '-19px', left: '28px' };
+                case 'Bottom left':
+                    return { top: '-44px', left: '18px' };
+            }
+        }
+        const expectedPosition = getPosition(style);
+        if (style == 'Bottom') {
+            textEntryMathWithImagePage.responseFieldWrapperPreviewTab()
+                .eq(responseIndex)
+                .should('have.css', 'bottom', expectedPosition.bottom)
+                .and('have.css', 'left', expectedPosition.left);
+        }
+        else if (style == 'Bottom right' || style == 'Right' || style == 'Top right') {
+            textEntryMathWithImagePage.responseFieldWrapperPreviewTab()
+                .eq(responseIndex)
+                .should('have.css', 'top', expectedPosition.top)
+                .and('have.css', 'right', expectedPosition.right);
+        }
+        else if (style == 'None') {
+            textEntryMathWithImagePage.responseFieldPreviewTab()
+                .eq(responseIndex)
+                .should('not.have.css', 'bottom')
+                .and('not.have.css', 'left');
+        }
+        else {
+            textEntryMathWithImagePage.responseFieldWrapperPreviewTab()
+                .eq(responseIndex)
+                .should('have.css', 'top', expectedPosition.top)
+                .and('have.css', 'left', expectedPosition.left);
+        }
+    },
+
+    /**
+     * @param {*} width width of canvas
+     * @description this function verifies width of canvas
+     */
+    verifyCanvasWidthInPreviewTab: (width) => {
+        textEntryMathWithImagePage.canvasInPreviewTab()
+            .should('have.attr', 'width', width);
+    },
+
+    /**
+     * @param {*} height height of canvas
+     * @description this function verifies height of canvas
+     */
+    verifyCanvasHeightInPreviewTab: (height) => {
+        textEntryMathWithImagePage.canvasInPreviewTab()
+            .should('have.css', 'height', `${height}px`);
+    },
+
+
+    verifyDropzoneNotExistInPreviewTab: () => {
+        utilities.verifyElementVisibilityState(textEntryMathWithImagePage.dropzonePreviewTab(), 'notExist');
+    },
+
+    verifyDropzoneExistInPreviewTab: () => {
+        textEntryMathWithImagePage.dropzonePreviewTab()
+            .should('be.visible');
+    },
+
+    verifyTextContainerNotExistInPreviewTab: () => {
+        utilities.verifyElementVisibilityState(textEntryMathWithImagePage.responseFieldPreviewTab(), 'notExist');
+    },
+
+    /**
+   * Focus in the answer input fields of the preview tab
+   * @param {number} responseIndex indx of the response to add input
+   */
+    focusInResponseAnswerInputFieldPreviewTab: (responseIndex) => {
+        textEntryMathWithImagePage.responseFieldPreviewTab()
+            .eq(responseIndex)
+            .click();
+    },
+
+    /**
+     * This function verifies the input field text of response area
+     * @param {number} index index of response field
+     * @param {string} inputFieldText input field text in the preview tab 
+     */
+    verifyResponseAreaTextContentPreviewTab: (index, inputFieldText) => {
+        utilities.verifyTextContent(utilities.getNthElement(textEntryMathWithImagePage.responseFieldPreviewTab(), index), inputFieldText);
+    },
+
+    /**
+     * This function verifies the aria label entered in the response field 
+     * @param {string} ariaLabel of the equation entered
+     */
+    verifyResponseFieldEquationAriaLabel: (responseIndex, ariaLabel) => {
+        textEntryMathWithImagePage.responseFieldPreviewTab()
+            .eq(responseIndex)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', ariaLabel);
+    },
+
+    /**
+     * @param {string} text text to be verified in the preview tab text area
+     * @description this function verifies input in the text area
+     */
+    verifyTextInTextAreaPreviewTab: (text) => {
+        textEntryMathWithImagePage.textAreaPreviewTab()
+            .should('have.text', text);
+    },
+
+    /**
+      * This function verifies the correct/incorrect icon does not exist
+      * @param {number} index of the response field
+      */
+    verifyCorrectIncorrectIconNotExist: (index) => {
+        textEntryMathWithImagePage.responseFieldWrapperPreviewTab()
+            .eq(index)
+            .within(() => {
+                utilities.verifyElementVisibilityState(textEntryMathWithImagePage.tickIcon(), 'notExist');
+            });
+    },
+
+    /**
+     * This function verifies the correct icon for the response field
+     * @param {number} index of the response field
+     */
+    verifyCorrectResponseIcon: (index) => {
+        textEntryMathWithImagePage.responseFieldWrapperPreviewTab()
+            .eq(index)
+            .within(() => {
+                utilities.verifyCSS(textEntryMathWithImagePage.tickIcon(), {
+                    'fill': css.color.correctAnswer
+                });
+            });
+    },
+
+    /**
+     * This function verifies the incorrect icon for the response field
+     * @param {number} index of the response field
+     */
+    verifyIncorrectResponseIcon: (index) => {
+        textEntryMathWithImagePage.responseFieldWrapperPreviewTab()
+            .eq(index)
+            .within(() => {
+                utilities.verifyCSS(textEntryMathWithImagePage.tickIcon(), {
+                    'fill': css.color.incorrectAnswer
+                });
+            });
+    },
+
+    verifyResponseFieldNumerationPreviewTab: () => {
+        textEntryMathWithImagePage.responseFieldNumerationPreviewTab()
+            .each(($element, index) => {
+                cy.wrap($element)
+                    .should('have.text', `${index + 1}`)
+            });
+    },
+}
+
+const tests = {
+    ...backgroundImageUploadComponent.tests,
+    ...imageCanvasComponent.tests,
+    ...questionInstructionsComponent.tests,
+    ...autoScoredScoringPreviewTab.tests
+}
+
+export const textEntryMathWithImagePage = {
+    ...selectors,
+    steps,
+    tests
+}

package/cypress/pages/uploadResponsePage.js

@@ -1,4 +1,4 @@
-import { commonComponents, questionInstructionsComponent, scoringSectionBase, createQuestionBasePage, additionalSettingsPanel, previewScoringAndShowCorrectAnswerComponent } from "./components";
+import { commonComponents, questionInstructionsComponent, scoringSectionBaseEditTab, createQuestionBasePage, additionalSettingsPanel, autoScoredScoringPreviewTab } from "./components";
 import { dialogBoxBase } from ".";
 import utilities from "../support/helpers/utilities";
 const css = Cypress.env('css');
@@ -8,12 +8,13 @@ let fileTypeList = ['Access', 'Assembly', 'C', 'C++', 'CSV', 'Excel', 'GIF', 'H'
 
 const selectors = {
     ...dialogBoxBase,
-    ...scoringSectionBase,
+    ...scoringSectionBaseEditTab,
     ...createQuestionBasePage,
     ...additionalSettingsPanel,
-    ...commonComponents.steps,
+    ...commonComponents,
     ...questionInstructionsComponent,
     ...commonComponents,
+    maximumNumberOfFilesInputField: () => cy.get('.input-stepper-wrapper input'),
     //Supported file accordion
     supportedFileTypesAccordion: () => cy.get('.freeresponse-accordian-label'),
     selectedFileTypeCount: () => cy.get('.supported-file-types-count'),
@@ -48,7 +49,7 @@ const selectors = {
     uploadedFilesSectionWrapper: () => cy.get('.uploaded-document-wrapper'),
     uploadedFileWrapper: () => cy.get('.uploaded-document'),
     editDisplayTextIcon: () => cy.get('.icon-pencil'),
-    //Add File description
+    fileName: () => cy.get('.studentResponse'),
     addFileDescriptionInput: () => cy.get('[placeholder="Add file description"]'),
     addFileDescriptionIcon: () => cy.get('.icon-File-description'),
     scanningForVirusPreLoader: () => cy.get('img[alt="loader"]'),
@@ -56,15 +57,36 @@ const selectors = {
     uploadedFileLink: () => cy.get('a[href*="/files/document?key=freeResponse/"]'),
     editDisplayTextPopupInputField: () => cy.get('.inline-text-question-prefix-wrapper .update-display-text-input'),
     deleteButton: () => cy.get('.icon-Delete.upload-response-state'),
-    deletePopupContent: () => cy.get('.delete-document-popup-message-wrapper')
+    deletePopupContent: () => cy.get('.delete-document-popup-message-wrapper'),
+    warningMessageContainer: () => cy.get('.disabled-wrapper-cls'),
+    warningMessage: () => cy.get('.disabled-wrapper-cls [class*="DisabledTextWrapper"]'),
+    deleteFileButton: () => cy.get('.popup-button-wrapper button').eq(1),
+    cancelButton: () => cy.get('.popup-button-wrapper button').eq(0),
+    questionWrapperPreviewTab: () => cy.get('[class*="UploadQuestionPreviewstyle__UploadQuestionPreviewWrapper"]')
 }
 
 const steps = {
     ...createQuestionBasePage.steps,
     ...questionInstructionsComponent.steps,
-    ...scoringSectionBase.steps,
+    ...scoringSectionBaseEditTab.steps,
     ...additionalSettingsPanel.steps,
     ...commonComponents.steps,
+    ...dialogBoxBase.steps,
+    ...autoScoredScoringPreviewTab.steps,
+
+    /**
+     * @param {number} maxValue value of maximum number of files
+     */
+    setMaximumNumberOfFiles: (maxValue) => {
+        uploadResponsePage.maximumNumberOfFilesInputField()
+            .clear()
+            .type('{selectall}')
+            .type(maxValue)
+            .blur();
+        uploadResponsePage.maximumNumberOfFilesInputField()
+            .should('have.value', maxValue);
+    },
+
     checkCapturePhotosCheckbox: () => {
         uploadResponsePage.allowStudentsToCapturePhotosCheckbox()
             .click()
@@ -106,30 +128,36 @@ const steps = {
      * Verifies the displayed uploaded file count against a specified limit.
      */
     verifyUploadedFileLimitCount: (uploadedFileCount, fileLimit) => {
-        utilities.verifyInnerText(uploadResponsePage.uploadedFileCount(), `${uploadedFileCount}/${fileLimit} File Limit`)
+        utilities.verifyInnerText(uploadResponsePage.uploadedFileCount(), `${uploadedFileCount}/${fileLimit} File Limit`);
     },
 
     /**
      * Verifies the visibility state of elements for the preview tab of a specific uploaded file.
      * @param {number} uploadedFileIndex - The index of the uploaded file to check within the list.
     */
-    uploadedFileContentsPreviewTab: (uploadedFileIndex) => {
+    uploadedFileContentsPreviewTab: (uploadedFileIndex, fileName) => {
         uploadResponsePage.uploadedFileWrapper()
             .eq(uploadedFileIndex)
             .within(() => {
                 utilities.verifyElementVisibilityState(uploadResponsePage.editDisplayTextIcon(), 'visible');
                 utilities.verifyElementVisibilityState(uploadResponsePage.addFileDescriptionIcon(), 'visible');
                 utilities.verifyElementVisibilityState(uploadResponsePage.deleteButton(), 'visible');
+                utilities.verifyInnerText(uploadResponsePage.fileName(), fileName);
+                utilities.verifyElementVisibilityState(uploadResponsePage.fileName(), 'visible');
             });
     },
 
+    uploadedFileContentsNotExistPreviewTab: () => {
+        utilities.verifyElementVisibilityState(uploadResponsePage.uploadedFileWrapper(), 'notExist');
+    },
+
     /**
+     * @param {string} fileIndex - Index of file name
      * @param {string} fileName - The expected name of the uploaded file.
-     * @param {number} fileIndex - The index of the uploaded file within the list.
-     * Verifies the displayed name of an uploaded file at a specific index within the list.
+     * Verifies the displayed name of an uploaded file 
     */
-    verifyUploadedFileName: (fileName, fileIndex) => {
-        utilities.verifyInnerText(uploadResponsePage.uploadedFileWrapper().eq(fileIndex), fileName);
+    verifyUploadedFileName: (fileIndex, fileName) => {
+        utilities.verifyInnerText(utilities.getNthElement(uploadResponsePage.fileName(), fileIndex), fileName);
     },
 
     stopUploadingFile: () => {
@@ -144,7 +172,7 @@ const steps = {
      * Verifies that a file with the specified name does not exist in the uploaded files section.
      */
     verifyFileNotExistsInUploadedFileSection: (fileName) => {
-        uploadResponsePage.uploadedFilesSectionWrapper()
+        uploadResponsePage.fileName()
             .should('not.have.text', fileName)
     },
 
@@ -180,9 +208,13 @@ const steps = {
             });
     },
 
-    clickOnEditDisplayTextIcon: () => {
-        uploadResponsePage.editDisplayTextIcon()
-            .click();
+    clickOnEditDisplayTextIcon: (index) => {
+        uploadResponsePage.uploadedFileWrapper()
+            .eq(index)
+            .within(() => {
+                uploadResponsePage.editDisplayTextIcon()
+                    .click({ force: true });
+            });
     },
 
     verifyEditDisplayTextPopupInputFieldAndSelectedText: () => {
@@ -209,6 +241,7 @@ const steps = {
      */
     enterTextInEditDisplayTextPopupInputField: (text) => {
         uploadResponsePage.editDisplayTextPopupInputField()
+            .clear()
             .type(text);
     },
 
@@ -321,12 +354,13 @@ const steps = {
     },
 
     /**
-    * @param {string} file name of the file in fixtures/upload folder
-    * @description this function uploads a file
-    */
+     * @param {string} file name of the file in fixtures/upload folder
+     * @description this function uploads a file
+     */
     uploadFile: (file) => {
         uploadResponsePage.inputTypeFile()
             .attachFile(file);
+            cy.wait(2000);
     },
 
     verifyDefaultSelectedFileTypes: () => {
@@ -363,6 +397,25 @@ const steps = {
                 uploadResponsePage.stopUploadingButton().find('svg')
                     .should('have.css', 'color', css.color.successBtn);
             });
+    },
+
+    /**
+    * @description this function verifies warning text 
+    * @param {string} warningText warning message displayed
+    */
+    verifyWarningMessage: (warningText) => {
+        utilities.verifyElementVisibilityState(uploadResponsePage.warningMessage(), 'visible');
+        utilities.verifyInnerText(uploadResponsePage.warningMessage(), warningText);
+    },
+
+    cancelButtonInDeleteFilePopup: () => {
+        uploadResponsePage.cancelButton()
+            .click();
+    },
+
+    deleteFileButtonInDeleteFilePopup: () => {
+        uploadResponsePage.deleteFileButton()
+            .click();
     }
 }
 
@@ -370,8 +423,8 @@ const tests = {
     ...createQuestionBasePage.tests,
     ...questionInstructionsComponent.tests,
     ...additionalSettingsPanel.tests,
-    ...scoringSectionBase.tests,
-    ...previewScoringAndShowCorrectAnswerComponent.tests,
+    ...scoringSectionBaseEditTab.tests,
+    ...autoScoredScoringPreviewTab.tests,
     ...commonComponents.tests,
     verifyErrorMessageDisappear: () => {
         it('The error message should disappear if the user clicks anywhere in the upload file content wrapper', () => {