itemengine-cypress-automation 1.0.2

package/cypress/pages/singleSelectionGridPage.js

@@ -0,0 +1,370 @@
+import { additionalSettingsPanel, autoScoredAdditionalSettings, autoScoredPreviewBase, autoScoredScoringSection, autoScoredScoringSectionMultipleResponsesType, autoScoredSetCorrectAnswerSection, commonComponents, createQuestionBasePage, mcqOptionsComponent, mcqScoringComponent, optionsWrapperComponent, previewScoringAndShowCorrectAnswerComponent, questionInstructionsComponent, scoringSectionBase } from "./components";
+import { gridCommonComponents } from "./components/gridCommonComponents";
+import { studentResponseAndLayoutComponent } from "./components/studentResponseAreaAndLayoutComponent";
+const css = Cypress.env('css');
+
+const selectors = {
+    ...questionInstructionsComponent,
+    ...commonComponents,
+    ...scoringSectionBase,
+    ...autoScoredSetCorrectAnswerSection,
+    ...mcqOptionsComponent,
+    ...autoScoredScoringSectionMultipleResponsesType,
+    ...autoScoredAdditionalSettings,
+    ...previewScoringAndShowCorrectAnswerComponent,
+    ...autoScoredPreviewBase,
+    ...createQuestionBasePage,
+    ...gridCommonComponents,
+    ...additionalSettingsPanel,
+    optionNumeration: () => cy.get('[class*="SingleOptionstyle__AdornmentWrapper"]'),
+    //Options section
+    optionsSectionWrapper: () => cy.get('.edit-mcq-options-wrapper.single-selection-grid'),
+    //Set correct answer section
+    optionsRadioButton: () => cy.get('.choice-option-radio-button [type="radio"]'),
+    pointsWrapper: () => cy.get('.single-selection-grid-points-wrapper'),
+    randomizeOptionsCheckbox: () => cy.get('[data-ngie-testid="randomize-options-checkbox"] input'),
+    randomizeOptionsCheckboxLabel: () => cy.get('[data-ngie-testid="randomize-options-checkbox"] .MuiFormControlLabel-label'),
+    //Preview tab
+    radioButtonWrapper: () => cy.get('.choice-option-radio-button'),
+    previewTabRadioButtonWrapper: () => cy.get('.edit-question-preview-wrapper .choice-option-radio-button'),
+    //Scoring 
+    pointsPerResponseLabel: () => cy.get('[class*="indexstyles__PartialDifferentPointsHeader"]'),
+    partialEqualWeightsPointsPerResponseScore: () => cy.get('.partial-different-points-wrapper [aria-label*="Points per response"]'),
+    partialDifferentWeightsPointsInputField: () => cy.get('.partial-different-points-wrapper .points-input-field input[type="text"]'),
+    correctIncorrectIconWrapper: () => cy.get('.tick-icon-wrapper'),
+    correctIncorrectAnswerBorder: () => cy.get('.edit-question-preview-wrapper [class*="indexstyles__CorrectIncorrectBorderWrapper"]')
+};
+
+const steps = {
+    ...createQuestionBasePage.steps,
+    ...questionInstructionsComponent.steps,
+    ...scoringSectionBase.steps,
+    ...commonComponents.steps,
+    ...autoScoredSetCorrectAnswerSection.steps,
+    ...autoScoredScoringSectionMultipleResponsesType.steps,
+    ...additionalSettingsPanel.steps,
+    ...previewScoringAndShowCorrectAnswerComponent.steps,
+    ...autoScoredPreviewBase.steps,
+    ...autoScoredAdditionalSettings.steps,
+    ...gridCommonComponents.steps,
+    ...autoScoredScoringSection.steps,
+    //Set correct section
+    /**
+     * @param {number} rowIndex index of the row
+     * @param {number} optionIndex index of the option
+     * @description This function selects option from the set correct answer table
+     */
+    selectOptionFromSetCorrectAnswerTable: (rowIndex, optionIndex) => {
+        singleSelectionGridPage.setCorrectAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                singleSelectionGridPage.optionsRadioButton()
+                    .eq(optionIndex)
+                    .click()
+                    .should('be.checked');
+            });
+    },
+
+    /**
+     * @param {array} optionIndexInQuestionStemRow array of options to be selected for all question stems
+     * @description This function checkmarks all the options in the set correct answer table
+     */
+    selectOptionForAllQuestionStemsInSetCorrectAnswerTable: (optionIndexInQuestionStemRow) => {
+        optionIndexInQuestionStemRow.forEach((options, optionIndex) => {
+            singleSelectionGridPage.setCorrectAnswerTableRow()
+                .eq(optionIndex)
+                .within(() => {
+                    singleSelectionGridPage.optionsRadioButton()
+                        .eq(options)
+                        .click()
+                        .should('be.checked');
+                });
+        });
+    },
+
+    /**
+     * @param {number} rowIndex index of the row
+     * @param {number} radioButtonsCount number of radio buttons present in the row
+     * @description This function verifies the count of radio buttons present in a row
+     */
+    verifyTableRowRadioButtonsInSetCorrectAnswerTable: (rowIndex, radioButtonsCount) => {
+        singleSelectionGridPage.setCorrectAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                singleSelectionGridPage.optionsRadioButton()
+                    .should('have.length', radioButtonsCount)
+            });
+    },
+
+    /**
+   * @param {number} rowIndex index of the row
+   * @description this function verifies disabled radio button
+   */
+    verifyDisabledTableRowRadioButtonsInSetCorrectAnswerTable: (rowIndex) => {
+        singleSelectionGridPage.setCorrectAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                singleSelectionGridPage.optionsRadioButton()
+                    .each(($el) => {
+                        cy.wrap($el)
+                            .should('be.disabled');
+                    });
+            });
+    },
+
+    /**
+     * @param {number} rowIndex index of the row
+     * @description this function verifies enabled and unchecked radio button
+     */
+    verifyEnabledUncheckedTableRowRadioButtonsInSetCorrectAnswerTable: (rowIndex) => {
+        singleSelectionGridPage.setCorrectAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                singleSelectionGridPage.optionsRadioButton()
+                    .each(($el) => {
+                        cy.wrap($el)
+                            .should('be.enabled')
+                            .and('not.be.checked');
+                    });
+            });
+    },
+
+    //Preview tab
+    /**
+     * @param {number} rowIndex index of the row
+     * @param {number} radioButtonsCount number of radio buttons present in the row
+     * @description This function verifies the count of radio buttons present in a row
+     */
+    verifyTableRowRadioButtonsInPreviewTabAnswerTable: (rowIndex, radioButtonsCount) => {
+        singleSelectionGridPage.previewTabAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                singleSelectionGridPage.optionsRadioButton()
+                    .should('have.length', radioButtonsCount)
+            });
+    },
+
+    /**
+     * @param {number[]} optionIndexInQuestionStemRow array of options to be selected to each question stem
+     * @description This function selects the options for all the question stems
+     */
+    selectOptionForAllQuestionStemsInPreviewTabAnswerTable: (optionIndexInQuestionStemRow) => {
+        optionIndexInQuestionStemRow.forEach((options, optionIndex) => {
+            singleSelectionGridPage.previewTabAnswerTableRow()
+                .eq(optionIndex)
+                .within(() => {
+                    singleSelectionGridPage.optionsRadioButton()
+                        .eq(options)
+                        .click()
+                        .should('be.checked');
+                });
+        });
+    },
+
+    verifyRadioButtonsUncheckedInPreviewTabAnswerTable: () => {
+        singleSelectionGridPage.previewTabAnswerTable()
+            .within(() => {
+                singleSelectionGridPage.optionsRadioButton()
+                    .each(($el) => {
+                        cy.wrap($el)
+                            .should('not.be.checked')
+                    });
+            });
+    },
+
+    //Scoring
+    /**
+     * @param {number} rowIndex index of the row 
+     * @param {number} optionIndex index of the option to be selected within the row
+     * @description This function verifies the incorrect icon in the preview tab table
+     */
+    verifyIncorrectOptionCrossmarkIcon: (rowIndex, optionIndex) => {
+        singleSelectionGridPage.previewTabAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                singleSelectionGridPage.radioButtonWrapper()
+                    .eq(optionIndex)
+                    .within(() => {
+                        singleSelectionGridPage.correctIncorrectIconWrapper()
+                            .should('have.class', 'icon-incorrect')
+                            .and('be.visible');
+                    });
+            });
+    },
+
+    /**
+    * @param {number} rowIndex index of the row 
+    * @param {number} optionIndex index of the option to be selected within the row
+    * @description This function verifies the correct icon in the preview tab table
+    */
+    verifyCorrectOptionCheckmarkIcon: (rowIndex, optionIndex) => {
+        singleSelectionGridPage.previewTabAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                singleSelectionGridPage.radioButtonWrapper()
+                    .eq(optionIndex)
+                    .within(() => {
+                        singleSelectionGridPage.correctIncorrectIconWrapper()
+                            .should('have.class', 'icon-correct')
+                            .and('be.visible');
+                    });
+            });
+    },
+
+    /**
+     * @param {number[]} incorrectOptionsArray the array of incorrect answer options
+     * @description this function verifies the crossmark icon beside the options for all question stems
+     */
+    verifyIncorrectOptionCrossmarkIconForAllQuestionStems: (incorrectOptionsArray) => {
+        incorrectOptionsArray.forEach((incorrectOptionsIndex, rowIndex) => {
+            steps.verifyIncorrectOptionCrossmarkIcon(rowIndex, incorrectOptionsIndex)
+        });
+    },
+
+    /**
+     * @param {number[]} correctOptionsArray the array of correct answer options 
+     * @description this function verifies the checkmark icon beside the options for all question stems
+     */
+    verifyCorrectOptionCheckmarkIconForAllQuestionStems: (correctOptionsArray) => {
+        correctOptionsArray.forEach((correctOptionsIndex, rowIndex) => {
+            steps.verifyCorrectOptionCheckmarkIcon(rowIndex, correctOptionsIndex)
+        });
+    },
+
+    //TODO: Make all border related changes once https://redmine.zeuslearning.com/issues/518498 is resolved
+    verifyCorrectAttemptBorder: () => {
+        singleSelectionGridPage.correctIncorrectAnswerBorder()
+            .should('have.css', 'border', `1px solid ${css.color.correctAnswer}`);
+    },
+
+    verifyIncorrectAttemptBorder: () => {
+        singleSelectionGridPage.correctIncorrectAnswerBorder()
+            .should('have.css', 'border', `1px solid ${css.color.incorrectAnswer}`);
+    },
+
+    verifyCorrectIncorrectBorderNotVisible: () => {
+        singleSelectionGridPage.correctIncorrectAnswerBorder()
+            .should('have.css', 'border')
+            .and('match', /0px none/);
+    },
+};
+
+const tests = {
+    ...createQuestionBasePage.tests,
+    ...questionInstructionsComponent.tests,
+    ...autoScoredSetCorrectAnswerSection.tests,
+    ...autoScoredScoringSection.tests,
+    ...scoringSectionBase.tests,
+    ...mcqScoringComponent.tests,
+    ...commonComponents.tests,
+    ...previewScoringAndShowCorrectAnswerComponent.tests,
+    ...gridCommonComponents.tests,
+    ...additionalSettingsPanel.tests,
+    ...autoScoredAdditionalSettings.tests,
+    ...studentResponseAndLayoutComponent.tests,
+    /**
+     * @param {string} scoringType the type of scoring selected by the user
+     * @param {string[]} questionStemsArray the array of question stems to be verified in the set correct answer table
+     * @param {string[]} optionsArray the array of options to be verified in the set correct answer table
+     * @description this function is used to verify the contents of the set correct answer table when a scoring type is selected
+     */
+    verifyAllContentsOfSetCorrectAnswerTableForScoringType: (scoringType, questionStemsArray, optionsArray) => {
+        it(`When user has selected ${scoringType} scoring type then added question stems, options and enabled radio buttons should be displayed`, () => {
+            singleSelectionGridPage.steps.verifyQuestionStemsInSetCorrectAnswerTable(questionStemsArray);
+            singleSelectionGridPage.steps.verifyTableHeaderContentsInSetCorrectAnswerTable(optionsArray);
+            for (let index = 0; index < 4; index++) {
+                singleSelectionGridPage.steps.verifyEnabledUncheckedTableRowRadioButtonsInSetCorrectAnswerTable(index);
+            }
+        });
+    },
+
+    /**
+     * @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
+     */
+    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.allotMinimumScoreAwardedIfAttempted('1')
+            createQuestionBasePage.steps.switchToPreviewTab()
+            singleSelectionGridPage.steps.selectOptionForAllQuestionStemsInPreviewTabAnswerTable([1, 0, 1, 0]);
+            singleSelectionGridPage.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();
+            singleSelectionGridPage.steps.clearMinimumScoreIfAttemptedPointsField();
+            createQuestionBasePage.steps.switchToPreviewTab()
+            singleSelectionGridPage.steps.selectOptionForAllQuestionStemsInPreviewTabAnswerTable([1, 0, 1, 0]);
+            singleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`0/${totalPoints}`);
+        });
+    },
+
+    /**
+     * 
+     * @param {number} scoredPoints the points scored by the user
+     * @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
+     */
+    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();
+            singleSelectionGridPage.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();
+            singleSelectionGridPage.steps.selectOptionForAllQuestionStemsInPreviewTabAnswerTable([1, 0, 1, 0]);
+            singleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`0/${totalPoints}`);
+
+            cy.log('When user adds a partially correct answer input, the points should be updated accordingly with deducted penalty points');
+            singleSelectionGridPage.steps.selectOptionForAllQuestionStemsInPreviewTabAnswerTable([0, 1, 1, 1]);
+            singleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`${scoredPoints}/${totalPoints}`);
+        });
+    },
+    /**
+     * @param {number} scoredPoints the points scored by the user
+     * @param {number} totalPoints the maximum points that can be scored 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
+     */
+    verifyMinimumScoreIfAttemptedAndPenaltyPointsFunctionalityForIncorrectAnswer: (scoredPoints, 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');
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted('1');
+
+            cy.log('Switch to preview tab and give incorrect answer input to check that minimum points are displayed');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            singleSelectionGridPage.steps.selectOptionForAllQuestionStemsInPreviewTabAnswerTable([1, 0, 1, 0]);
+            singleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`1/${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');
+            singleSelectionGridPage.steps.selectOptionForAllQuestionStemsInPreviewTabAnswerTable([0, 1, 1, 1]);
+            singleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`${scoredPoints}/${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();
+            singleSelectionGridPage.steps.clearMinimumScoreIfAttemptedPointsField()
+            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted('6')
+            cy.log('Switching to preview tab');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            singleSelectionGridPage.steps.selectOptionForAllQuestionStemsInPreviewTabAnswerTable([0, 0, 1, 0]);
+            singleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`6/${totalPoints}`);
+        });
+    }
+};
+
+export const singleSelectionGridPage = {
+    ...selectors,
+    steps,
+    tests
+};

package/cypress/pages/singleSelectionPage.js

@@ -0,0 +1,65 @@
+import { additionalSettingsPanel, autoScoredPreviewBase, createQuestionBasePage, mcqAdditionalSettingsBase, mcqPreviewComponents, mcqQuestionCommonComponents, mcqSetCorrectAnswerSection, scoringSectionBase, autoScoredAdditionalSettings, autoScoredSetCorrectAnswerSection, autoScoredScoringSection, mcqScoringComponent, previewScoringAndShowCorrectAnswerComponent, optionsWrapperComponent } from "./components";
+import { mcqOptionsComponent } from "./components/mcqOptionsComponent";
+import { questionInstructionsComponent } from "./components/questionInstructionsComponent";
+
+const selectors = {
+    ...createQuestionBasePage,
+    ...questionInstructionsComponent,
+    ...mcqOptionsComponent,
+    ...additionalSettingsPanel,
+    ...mcqQuestionCommonComponents,
+    ...mcqAdditionalSettingsBase,
+    ...autoScoredPreviewBase,
+    ...mcqSetCorrectAnswerSection,
+    ...scoringSectionBase,
+    ...autoScoredSetCorrectAnswerSection,
+    ...autoScoredAdditionalSettings,
+    ...previewScoringAndShowCorrectAnswerComponent,
+    ...optionsWrapperComponent,
+    optionsRadioButton: () => cy.get('input[type="radio"]')
+};
+
+const steps = {
+    ...createQuestionBasePage.steps,
+    ...questionInstructionsComponent.steps,
+    ...mcqOptionsComponent.steps,
+    ...additionalSettingsPanel.steps,
+    ...mcqQuestionCommonComponents.steps,
+    ...autoScoredAdditionalSettings.steps,
+    ...autoScoredPreviewBase.steps,
+    ...scoringSectionBase.steps,
+    ...mcqSetCorrectAnswerSection.steps,
+    ...mcqPreviewComponents.steps,
+    ...autoScoredSetCorrectAnswerSection.steps,
+    ...autoScoredScoringSection.steps,
+    checkCorrectAnswerRadioButton: (option) => {
+        mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(option)
+            .click()
+            .within(() => {
+                singleSelectionPage.optionsRadioButton()
+                    .should('be.checked');
+            });
+    }
+};
+
+const tests = {
+    ...createQuestionBasePage.tests,
+    ...questionInstructionsComponent.tests,
+    ...mcqOptionsComponent.tests,
+    ...additionalSettingsPanel.tests,
+    ...mcqQuestionCommonComponents.tests,
+    ...mcqAdditionalSettingsBase.tests,
+    ...scoringSectionBase.tests,
+    ...mcqSetCorrectAnswerSection.tests,
+    ...autoScoredAdditionalSettings.tests,
+    ...autoScoredSetCorrectAnswerSection.tests,
+    ...autoScoredScoringSection.tests,
+    ...mcqScoringComponent.tests,
+    ...previewScoringAndShowCorrectAnswerComponent.tests,
+};
+
+export const singleSelectionPage = {
+    ...selectors,
+    tests,
+    steps
+};

package/cypress/pages/uploadResponsePage.js

@@ -0,0 +1,110 @@
+import { commonComponents, questionInstructionsComponent, scoringSectionBase, createQuestionBasePage, additionalSettingsPanel, previewScoringAndShowCorrectAnswerComponent } from "./components";
+import { dialogBoxBase } from ".";
+
+const selectors = {
+    ...dialogBoxBase,
+    ...scoringSectionBase,
+    ...createQuestionBasePage,
+    ...additionalSettingsPanel,
+    ...questionInstructionsComponent,
+    //Supported file accordion
+    supportedFileTypesAccordion: () => cy.get('.freeresponse-accordian-label'),
+    selectedFileTypeCount: () => cy.get('.supported-file-types-count'),
+    supportedFileTypeCheckbox: () => cy.get('.ngie-checkbox input'),
+    supportedFileTypesAccordionWrapper: () => cy.get('.edit-question-edit-tab-wrapper .ngie-accordion-summary'),
+    supportedFileTypesCheckboxWrapper: (fileTypeNumber) => cy.get('.edit-question-supported-files-wrapper .ngie-checkbox-control-label').eq(fileTypeNumber),
+    //Max files dropdown
+    maxFilesLabel: () => cy.get('#Maximum-number-of-files-dropdown-label'),
+    maxFilesDropdown: () => cy.get('#Maximum-number-of-files-select'),
+    maxFilesDropdownListOptions: (optionNumber) => cy.get('.dropdown-menu-item ').eq(optionNumber),
+    //Additional settings accordian
+    fileSettingsAndLayoutLabel: () => cy.get('[class*="AdditionalOptionstyles__ScoringLabel"]'),//TODO: need to change post issue for unique class name
+    allowStudentsToCapturePhotosLabel: () => cy.get('[data-ngie-testid="allow-students-to-capture-photos-checkbox"] .MuiFormControlLabel-label'),
+    allowStudentsToCapturePhotosCheckbox: () => cy.get('[data-ngie-testid="allow-students-to-capture-photos-checkbox"] input'),
+    uploadFileContentWrapper: () => cy.get('.upload-file-content'),
+    uploadCloudIcon: () => cy.get('.upload-question-upload-cloud-icon-wrapper'),
+    dragAndDropFilesText: () => cy.get('.drag-and-drop-file-text'),
+    fileUploadOptionsLabel: () => cy.get('.file-input-label'),
+    deviceLink: () => cy.get('.icon-Device'),
+    googleDriveLink: () => cy.get('.icon-Google-Drive'),
+    cameraIcon: () => cy.get('.icon-Capture-an-image'),
+    supportedFileFormatLabel: () => cy.get('.supported-file-text'),
+    supportedFileInfoIcon: () => cy.get('.supported-file-icon-wrapper'),
+    uploadingProgressBar: () => cy.get('.uploading-document-progress-bar'),
+    uploadingFileName: () => cy.get('.upload-filename'),
+    uploadingFileSize: () => cy.get('.upload-file-size-details'),
+    stopUploadingButton: () => cy.get('.document-stop-uploading-icon-wrapper'),
+    uploadedFileCount: () => cy.get('.file-upload-limit'),
+    supportedFilesTooltip: () => cy.get('.upload-question-supported-file-tooltip'),
+    inputTypeFile: () => cy.get('input[type="file"]'),
+    uploadedFilesSectionWrapper: () => cy.get('.uploaded-document-wrapper'),
+    uploadedFileWrapper: () => cy.get('.uploaded-document'),
+    editDisplayTextIcon: () => cy.get('.icon-pencil'),
+    //Add File description
+    addFileDescriptionInput: () => cy.get('[placeholder="Add file description"]'),
+    addFileDescriptionIcon: () => cy.get('.icon-File-description'),
+    scanningForVirusPreLoader: () => cy.get('img[alt="loader"]'),
+    virusErrorMessageWrapper: () => cy.get('.FileUploadStatementLarge'),
+    uploadedFileLink: () => cy.get('a[href*="/files/document?key=freeResponse/"]'),
+    editDisplayTextPopupInputField: () => cy.get('.inline-text-question-prefix-wrapper .update-display-text-input'),
+    rejectButton: () => cy.get('.popup-button-wrapper button').eq(0),//TODO: need to use selector from common components, once common class is implemented
+    acceptButton: () => cy.get('.popup-button-wrapper button').eq(1),//TODO: need to use selector from common components, once common class is implemented
+    deleteButton: () => cy.get('.icon-Delete.upload-response-state')
+}
+
+const steps = {
+    ...createQuestionBasePage.steps,
+    ...questionInstructionsComponent.steps,
+    ...scoringSectionBase.steps,
+    ...additionalSettingsPanel.steps,
+    checkCapturePhotosCheckbox: () => {
+        uploadResponsePage.allowStudentsToCapturePhotosCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    checkUncheckSupportedFileType: (fileTypeIndex, fileType, checkedUnchecked) => {
+        uploadResponsePage.supportedFileTypesCheckboxWrapper(fileTypeIndex)
+            .verifyInnerText(fileType)
+            .within(() => {
+                uploadResponsePage.supportedFileTypeCheckbox()
+                    .click()
+                    .should(checkedUnchecked);
+            });
+    },
+
+    fileUploadAndVerify: (filesToUploadArray) => {
+        filesToUploadArray.forEach((file) => {
+            uploadResponsePage.inputTypeFile()
+                .attachFile(`uploads/${file}`);
+            uploadResponsePage.uploadedFileLink()
+                .last()
+                .should('have.text', file);
+            uploadResponsePage.scanningForVirusPreLoader()
+                .should('not.be.visible');
+        });
+    },
+}
+
+const tests = {
+    ...createQuestionBasePage.tests,
+    ...questionInstructionsComponent.tests,
+    ...additionalSettingsPanel.tests,
+    ...scoringSectionBase.tests,
+    ...previewScoringAndShowCorrectAnswerComponent.tests,
+    verifyErrorMessageDisappear: () => {
+        it('The error message should disappear if the user clicks anywhere in the upload file content wrapper', () => {
+            uploadResponsePage.inputTypeFile()
+                .parent()
+                .click();
+            commonComponents.errorMessage()
+                .should('not.exist');
+        });
+    }
+}
+
+export const uploadResponsePage = {
+    ...selectors,
+    steps,
+    tests
+}