itemengine-cypress-automation 1.0.119 → 1.0.121

package/cypress/e2e/ILC/TextEntryMathWithImage/previewTabContentsForAllViews.smoke.js

@@ -0,0 +1,166 @@
+import { textEntryMathWithImagePage, itemPreviewPage, studentViewPage } from "../../../pages";
+import { equationEditorFlyout } from "../../../pages/components";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const css = Cypress.env('css');
+let previewContentViews = ['Question preview', 'Item view', 'Item preview', 'Student view', 'Grading view', 'Correct answer view'];
+const views = utilities.getViews(previewContentViews);
+var itemReferenceID = "";
+
+describe('Create item page - Text entry math: Preview contents', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    views.forEach((view) => {
+        describe(`Preview tab contents - ${view}`, { tags: 'smoke' }, () => {
+            abortEarlySetup();
+            before(() => {
+                switch (view) {
+                    case 'Question preview':
+                        textEntryMathWithImagePage.steps.navigateToCreateQuestion('Text Entry Math');
+                        cy.barsPreLoaderWait();
+                        textEntryMathWithImagePage.steps.addBackground();
+                        textEntryMathWithImagePage.steps.addTextInQuestionInstructionsInputField('Enter the correct answer in the response field');
+                        textEntryMathWithImagePage.steps.uploadFile('highlightImage.jpg');
+                        textEntryMathWithImagePage.steps.verifyImageIsUploaded();
+                        textEntryMathWithImagePage.steps.insertResponseArea(10);
+                        textEntryMathWithImagePage.steps.insertResponseArea(40);
+                        textEntryMathWithImagePage.steps.insertTextArea(80, 'This is a text area');
+                        textEntryMathWithImagePage.steps.expandResponseAccordionSpecifyCorrectAnswer(0);
+                        textEntryMathWithImagePage.steps.addInputToResponseAnswerInputFieldSpecifyCorrectAnswer(0, 'Correct answer 1');
+                        textEntryMathWithImagePage.steps.expandResponseAccordionSpecifyCorrectAnswer(1);
+                        textEntryMathWithImagePage.steps.focusInResponseAnswerInputFieldSpecifyCorrectAnswerSection(1);
+                        textEntryMathWithImagePage.steps.selectEquationEditorOptionFromCKEditorToolbar();
+                        equationEditorFlyout.steps.enterQuadraticEquation();
+                        textEntryMathWithImagePage.steps.allotPoints(10);
+                        textEntryMathWithImagePage.steps.switchToPreviewTab();
+                        break;
+                    case 'Item view':
+                        cy.visit(`/item-engine/demo/edit-item/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    case 'Item preview':
+                        cy.visit(`/item-engine/demo/edit-item/${utilities.base64Encoding(itemReferenceID)}`);
+                        textEntryMathWithImagePage.steps.switchToPreviewTab();
+                        break;
+                    case 'Student view':
+                        cy.visit(`/item-engine/demo/render-item/student-view/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    case 'Grading view':
+                        cy.visit(`/item-engine/demo/render-item/grading-view/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    case 'Correct answer view':
+                        cy.visit(`/item-engine/demo/render-item/correct-answer-view/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    default:
+                        throw new Error('Invalid view');
+                }
+            });
+
+            after(() => {
+                if (view === 'Question preview') {
+                    textEntryMathWithImagePage.steps.clickOnSaveQuestionButton();
+                    utilities.verifyElementVisibilityState(itemPreviewPage.referenceID(), 'exist');
+                    itemReferenceID = itemPreviewPage.steps.getItemReferenceID();
+                }
+                if (view === 'Student view') {
+                    studentViewPage.steps.submitResponse();
+                    utilities.verifyElementVisibilityState(studentViewPage.buttonGoToGradingView(), 'visible');
+                }
+            });
+
+            it('Question instructions should be visible', () => {
+                utilities.verifyInnerText(textEntryMathWithImagePage.questionInstructionsText(), 'Enter the correct answer in the response field');
+                utilities.verifyElementVisibilityState(textEntryMathWithImagePage.questionInstructionsText(), 'visible');
+            });
+
+
+            it('The text area should be displayed on the image canvas', () => {
+                textEntryMathWithImagePage.steps.verifyTextInTextAreaPreviewTab('This is a text area');
+            });
+
+            it('The image uploaded in the \'Background image\' section should be displayed', () => {
+                utilities.verifyElementVisibilityState(textEntryMathWithImagePage.canvasImage(), 'visible');
+            });
+
+            if (view !== 'Grading view' && view !== 'Correct answer view') {
+                it(`The two empty response fields should be disabled ${view}`, () => {
+                    utilities.verifyTextContent(textEntryMathWithImagePage.responseFieldPreviewTab(), '')
+                    utilities.verifyElementVisibilityState(textEntryMathWithImagePage.responseFieldPreviewTab(), 'visible');
+                    utilities.verifyElementCount(textEntryMathWithImagePage.responseFieldPreviewTab(), '2');
+                });
+
+                it(`User should able to enter answers in the response fields for ${view}`, () => {
+                    textEntryMathWithImagePage.steps.focusInResponseAnswerInputFieldPreviewTab(0);
+                    equationEditorFlyout.steps.enterTextInPreviewInputField('Correct answer 1');
+                    equationEditorFlyout.steps.clickOnOkButton();
+                    textEntryMathWithImagePage.steps.verifyResponseAreaTextContentPreviewTab(0, 'Correct answer 1');
+                    textEntryMathWithImagePage.steps.focusInResponseAnswerInputFieldPreviewTab(1);
+                    equationEditorFlyout.steps.enterQuadraticEquation();
+                    textEntryMathWithImagePage.steps.verifyResponseAreaTextContentPreviewTab(1, '2x2y2+4xy+4');
+                    textEntryMathWithImagePage.steps.verifyResponseFieldEquationAriaLabel(1, '2 x squared y squared plus 4 x y plus 4');
+                });
+            } else if (view === 'Grading view') {
+                it(`The response fields should be filled with the submitted responses and user should not be able to edit them`, () => {
+                    textEntryMathWithImagePage.steps.verifyResponseAreaTextContentPreviewTab(0, 'Correct answer 1');
+                    textEntryMathWithImagePage.steps.verifyResponseAreaTextContentPreviewTab(1, '2x2y2+4xy+4');
+                    textEntryMathWithImagePage.steps.verifyResponseFieldEquationAriaLabel(1, '2 x squared y squared plus 4 x y plus 4');
+                    textEntryMathWithImagePage.steps.focusInResponseAnswerInputFieldPreviewTab(0);
+                    utilities.verifyElementVisibilityState(equationEditorFlyout.dialogBox(), 'notExist');
+                });
+            } else {
+                it(`The response input fields should be displayed filled with correct answers`, () => {
+                    textEntryMathWithImagePage.steps.verifyResponseAreaTextContentPreviewTab(0, 'Correct answer 1');
+                    textEntryMathWithImagePage.steps.verifyResponseAreaTextContentPreviewTab(1, '2x2y2+4xy+4');
+                    textEntryMathWithImagePage.steps.verifyResponseFieldEquationAriaLabel(1, '2 x squared y squared plus 4 x y plus 4');
+                });
+            }
+
+            it('CSS of preview contents', { tags: 'css' }, () => {
+                switch (view) {
+                    case 'Question preview':
+                    case 'Item preview':
+                    case 'Item view':
+                    case 'Item preview':
+                    case 'Student view':
+                        utilities.verifyCSS(utilities.getNthElement(textEntryMathWithImagePage.responseFieldPreviewTab().parents('.response-input-field'), 0), {
+                            'border-color': css.color.activeButtons,
+                            'border-bottom-style': 'dashed',
+                            'background-color': css.color.optionsBg
+                        });
+                        utilities.verifyCSS(utilities.getNthElement(textEntryMathWithImagePage.responseFieldPreviewTab().find('span'), 0), {
+                            'color': css.color.text,
+                            'font-size': css.fontSize.default,
+                            'font-weight': css.fontWeight.regular
+                        });
+                        break;
+                    case 'Grading view':
+                        utilities.verifyCSS(utilities.getNthElement(textEntryMathWithImagePage.responseFieldPreviewTab().parents('.response-input-field'), 0), {
+                            'border-color': css.color.correctAnswer,
+                            'border-bottom-style': 'dashed',
+                            'background-color': css.color.optionsBg
+                        });
+                        utilities.verifyCSS(utilities.getNthElement(textEntryMathWithImagePage.responseFieldPreviewTab().find('span'), 0), {
+                            'color': css.color.text,
+                            'font-size': css.fontSize.default,
+                            'font-weight': css.fontWeight.regular
+                        });
+                        break;
+                    case 'Correct answer view':
+                        utilities.verifyCSS(utilities.getNthElement(textEntryMathWithImagePage.responseFieldPreviewTab().find('p'), 0), {
+                            'color': css.color.text,
+                            'font-size': css.fontSize.default,
+                            'font-weight': css.fontWeight.regular,
+                        });
+                        break;
+                    default:
+                        throw new Error('Invalid view');
+                }
+            });
+
+            it('Accessibility of preview tab', { tags: 'a11y' }, () => {
+                cy.checkAccessibility(textEntryMathWithImagePage.questionInstructionsText().parents('[class*="__ContentWrapper"]'));
+            });
+        });
+    });
+});

package/cypress/e2e/ILC/UploadResponse/editTabScoringSection.js

@@ -0,0 +1,51 @@
+import {  uploadResponsePage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const css = Cypress.env('css');
+
+describe('Create item page -Upload response: Scoring section', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Scoring section contents', () => {
+        abortEarlySetup();
+        before(() => {
+             uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+            cy.barsPreLoaderWait();
+        });
+
+         uploadResponsePage.tests.verifyScoringTypeLabelAndDropdown('Manually scored');
+    });
+
+    describe('Manually Scored scoring - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+            cy.log('Add question instructions and options');
+             uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+             uploadResponsePage.steps.addQuestionInstructions();
+        });
+
+        it('When the user selects \'Manually scored\' option from the scoring Type dropdown then \'Points\' and \'Minimum scoring\' label and dropdown should be displayed', () => {
+             uploadResponsePage.steps.verifyDefaultPointsLabelAndInputField();
+             uploadResponsePage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+        });
+
+         uploadResponsePage.tests.verifyPointsFieldErrorState(10);
+    });
+
+    describe('Non scored scoring - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+             uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+            cy.barsPreLoaderWait();
+        });
+
+        it('User should be able to select \'Non scored\' scoring type from scoring type dropdown', () => {
+             uploadResponsePage.steps.expandScoringTypeDropdown();
+             uploadResponsePage.steps.selectOptionFromScoringTypeDropdown('Non scored');
+        });
+
+         uploadResponsePage.tests.verifyScoringSectionContentsForNonScoredScoringType();
+    });
+});

package/cypress/e2e/ILC/UploadResponse/gradingViewAndCorrectAnswerViewContents.smoke.js

@@ -0,0 +1,99 @@
+import { correctAnswerViewPage, uploadResponsePage, itemPreviewPage, studentViewPage } from "../../../pages";
+import { gradingViewPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const css = Cypress.env('css');
+let gradingAndCorrectAnsView = ['Grading view', 'Correct answer view']
+const views = utilities.getViews(gradingAndCorrectAnsView);
+var itemReferenceID = "";
+
+describe('Create item page - Upload response: Grading view, Correct answer view contents', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    if (views.includes('Grading view')) {
+        describe('Grading view contents', { tags: 'smoke' }, () => {
+            abortEarlySetup();
+            before(() => {
+                cy.log('Navigating to Upload response question type');
+                uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+                cy.barsPreLoaderWait();
+                uploadResponsePage.steps.addTextInQuestionInstructionsInputField('Question text');
+                uploadResponsePage.steps.allotPoints(10);
+                uploadResponsePage.steps.setMaximumNumberOfFiles(3);
+                uploadResponsePage.steps.clickOnSaveQuestionButton();
+                utilities.verifyElementVisibilityState(itemPreviewPage.referenceID(), 'visible');
+                //Global variable issue, not working inside before
+                itemPreviewPage.referenceID()
+                    .invoke('text')
+                    .then(($refID) => {
+                        itemReferenceID = $refID;
+                        cy.visit(`/item-engine/demo/render-item/student-view/${utilities.base64Encoding(itemReferenceID)}`);
+                        uploadResponsePage.steps.uploadFile('uploads/highlightImage.jpg');
+                        uploadResponsePage.steps.verifyUploadedFileName(0, 'highlightImage.jpg');
+                        uploadResponsePage.steps.verifyUploadedFileLimitCount(1, 3);
+                        studentViewPage.steps.submitResponse();
+                        studentViewPage.steps.clickOnGoToGradingViewButton();
+                    });
+            });
+
+            it('Question instructions should be visible', () => {
+                utilities.verifyInnerText(uploadResponsePage.questionInstructionsText(), 'Question text');
+                utilities.verifyElementVisibilityState(uploadResponsePage.questionInstructionsText(), 'visible');
+            });
+
+            it('The response submitted by the student should be visible in the response field of the grading view', () => {
+                uploadResponsePage.steps.verifyUploadedFileName(0, 'highlightImage.jpg');
+                utilities.verifyElementCount(uploadResponsePage.fileName(), 1);
+            });
+
+            it('Empty score input field and total score should be displayed', () => {
+                gradingViewPage.steps.verifyGradingViewScore('', 10);
+            });
+
+            it('Accessibility of uploaded file', { tags: 'a11y' }, () => {
+                cy.checkAccessibility(uploadResponsePage.fileName());
+            });
+
+            it('On clicking on the file name, user should be able to download the file', () => {
+               cy.verifyUploadFilePreviewDownload('highlightImage.jpg');
+            });
+        });
+    }
+
+    if (views.includes('Correct answer view')) {
+        describe('Correct answer view contents', { tags: 'smoke' }, () => {
+            abortEarlySetup();
+            before(() => {
+                cy.log('Navigating to Upload response question type');
+                uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+                cy.barsPreLoaderWait();
+                uploadResponsePage.steps.addQuestionInstructions();
+                uploadResponsePage.steps.allotPoints(10);
+                uploadResponsePage.steps.clickOnSaveQuestionButton();
+                utilities.verifyElementVisibilityState(itemPreviewPage.referenceID(), 'visible');
+                itemPreviewPage.referenceID()
+                    .invoke('text')
+                    .then(($refID) => {
+                        itemReferenceID = $refID
+                        cy.visit(`/item-engine/demo/render-item/correct-answer-view/${utilities.base64Encoding(itemReferenceID)}`);
+                    });
+            });
+
+            it('Question instructions should be visible', () => {
+                utilities.verifyTextContent(correctAnswerViewPage.correctAnswerViewQuestionInstructions(), 'Which of the following is the major contributor to increased carbon dioxide levels because of urbanization? Select your answer from the options below.');
+                utilities.verifyElementVisibilityState(correctAnswerViewPage.correctAnswerViewQuestionInstructions(), 'visible');
+            });
+
+            it('\'This is a manual scored question\' help text should be displayed in the correct answer view', () => {
+                utilities.verifyTextContent(correctAnswerViewPage.manualScoredQuestionHelpText(), 'This is a manual scored question.');
+                utilities.verifyElementVisibilityState(correctAnswerViewPage.manualScoredQuestionHelpText(), 'visible');
+            });
+
+            it('The points alloted to the question should be displayed', () => {
+                correctAnswerViewPage.steps.verifyAvailablePoints(10);
+            });
+        });
+    }
+});

package/cypress/e2e/ILC/UploadResponse/manuallyAndNonScoredScoring.js

@@ -0,0 +1,71 @@
+import { uploadResponsePage, } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+
+describe('Create question page - Upload Response: Scoring', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Scoring Section contents', () => {
+        abortEarlySetup();
+        before(() => {
+            uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+        });
+
+        uploadResponsePage.tests.verifyScoringTypeLabelAndDropdown('manuallyScored');
+    });
+
+    describe('Manually scored scoring type', () => {
+        abortEarlySetup();
+        before(() => {
+            cy.log('Adding question instructions and correct answer response, select Manually scored scoring type and add points for the question');
+            uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+            uploadResponsePage.steps.addQuestionInstructions();
+            uploadResponsePage.steps.allotPoints(20);
+            uploadResponsePage.steps.expandScoringTypeDropdown();
+            uploadResponsePage.steps.selectOptionFromScoringTypeDropdown('Manually scored');
+            cy.log('Switching to Preview tab')
+            uploadResponsePage.steps.switchToPreviewTab();
+        });
+
+        it('In Preview tab, Question Instructions and file uploader section should be displayed', () => {
+            uploadResponsePage.steps.verifyQuestionInstructionsText();
+            utilities.verifyElementVisibilityState(uploadResponsePage.uploadFileContentWrapper(), 'visible');
+        });
+
+        uploadResponsePage.tests.verifyGradingStudentViewRadioButtonAndScoringTypeInPreviewTab('Manually scored');
+    });
+
+    describe('Question Preview: Non scored', () => {
+        abortEarlySetup();
+        before(() => {
+            uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+            uploadResponsePage.steps.addQuestionInstructions();
+            uploadResponsePage.steps.expandScoringTypeDropdown();
+            uploadResponsePage.steps.selectOptionFromScoringTypeDropdown('Non scored');
+            uploadResponsePage.steps.switchToPreviewTab();
+        });
+
+        uploadResponsePage.tests.verifyGradingStudentViewRadioButtonAndScoringTypeInPreviewTab('Non scored');
+
+        it('When the user selects \'Grading\' view without attempting the question, then file uploader section should be displayed', () => {
+            uploadResponsePage.steps.switchToGradingView();
+            utilities.verifyElementVisibilityState(uploadResponsePage.uploadFileContentWrapper(), 'visible');
+            uploadResponsePage.steps.switchToStudentView();
+        });
+
+        it('When user attempts the question by uploading file, then on switching to \'Grading\' view, file uploader section and file name with edit icon, add description button and delete button should be displayed', () => {
+            uploadResponsePage.steps.resetQuestionPreview();
+            uploadResponsePage.steps.uploadFile('uploads/highlightImage.jpg');
+            uploadResponsePage.steps.switchToGradingView();
+            utilities.verifyElementVisibilityState(uploadResponsePage.uploadFileContentWrapper(), 'visible');
+            uploadResponsePage.steps.uploadedFileContentsPreviewTab(0);
+            uploadResponsePage.steps.verifyUploadedFileName(0, 'highlightImage.jpg');
+            uploadResponsePage.steps.switchToStudentView();
+            utilities.verifyElementVisibilityState(uploadResponsePage.uploadFileContentWrapper(), 'visible');
+            uploadResponsePage.steps.uploadedFileContentsPreviewTab(0);
+            uploadResponsePage.steps.verifyUploadedFileName(0, 'highlightImage.jpg');
+        });
+    });
+});

package/cypress/e2e/ILC/UploadResponse/previewContentsForAllViews.smoke.js

@@ -0,0 +1,155 @@
+import { uploadResponsePage, itemPreviewPage, studentViewPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const css = Cypress.env('css');
+let previewContentViews = ['Question preview', 'Item view', 'Item preview', 'Student view'];
+const views = utilities.getViews(previewContentViews);
+var itemReferenceID = "";
+
+describe('Create item page - Upload response : Preview contents', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    views.forEach((view) => {
+        describe(`Preview tab contents - ${view}`, { tags: 'smoke' }, () => {
+            abortEarlySetup();
+            before(() => {
+                switch (view) {
+                    case 'Question preview':
+                        cy.log('Navigating to Upload response question type');
+                        uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+                        cy.barsPreLoaderWait();
+                        uploadResponsePage.steps.addTextInQuestionInstructionsInputField('Question text');
+                        uploadResponsePage.steps.allotPoints(10);
+                        uploadResponsePage.steps.setMaximumNumberOfFiles(3);
+                        uploadResponsePage.steps.switchToPreviewTab();
+                        break;
+                    case 'Item view':
+                        cy.visit(`/item-engine/demo/edit-item/${utilities.base64Encoding(itemReferenceID[0])}`);
+                        break;
+                    case 'Item preview':
+                        cy.visit(`/item-engine/demo/edit-item/${utilities.base64Encoding(itemReferenceID[0])}`);
+                        uploadResponsePage.steps.switchToPreviewTab();
+                        break;
+                    case 'Student view':
+                        cy.visit(`/item-engine/demo/render-item/student-view/${utilities.base64Encoding(itemReferenceID[0])}`);
+                        break;
+                };
+            });
+
+            if (view === 'Question preview') {
+                after(() => {
+                    uploadResponsePage.steps.clickOnSaveQuestionButton();
+                    utilities.verifyElementVisibilityState(itemPreviewPage.referenceID(), 'visible');
+                    itemReferenceID = itemPreviewPage.steps.getItemReferenceID();
+                });
+            };
+
+            it('Question instructions should be visible', () => {
+                utilities.verifyInnerText(uploadResponsePage.questionInstructionsText(), 'Question text');
+                utilities.verifyElementVisibilityState(uploadResponsePage.questionInstructionsText(), 'visible');
+            });
+
+            it('File limit label be visible', () => {
+                uploadResponsePage.steps.verifyUploadedFileLimitCount(0, 3);
+            });
+
+            it('When user uploads file, then uploaded file name should be displayed and file count should get updated', () => {
+                uploadResponsePage.steps.uploadFile('uploads/highlightImage.jpg');
+                uploadResponsePage.steps.uploadedFileContentsPreviewTab(0, 'highlightImage.jpg');
+                uploadResponsePage.steps.verifyUploadedFileLimitCount(1, 3);
+                utilities.verifyElementCount(uploadResponsePage.fileName(), 1);
+            });
+
+            it('When user deletes the uploaded file then uploaded file name, edit icon and delete button should disappear and file limit should be updated accordingly', () => {
+                uploadResponsePage.steps.deleteFile();
+                uploadResponsePage.steps.deleteFileButtonInDeleteFilePopup();
+                uploadResponsePage.steps.uploadedFileContentsNotExistPreviewTab();
+            });
+
+            it('When user uploads multiple files, then uploaded files should be visible in the uploaded file section and file limit should be updated accordingly', () => {
+                uploadResponsePage.steps.uploadFile(['uploads/sample.pdf', 'uploads/sample.jpg']);
+                uploadResponsePage.steps.uploadedFileContentsPreviewTab(0, 'sample.pdf');
+                uploadResponsePage.steps.uploadedFileContentsPreviewTab(1, 'sample.jpg');
+                uploadResponsePage.steps.verifyUploadedFileLimitCount(2, 3);
+                utilities.verifyElementCount(uploadResponsePage.fileName(), 2);
+            });
+
+            it('When user edits the name of uploaded file, then edited name should be visible', () => {
+                uploadResponsePage.steps.clickOnEditDisplayTextIcon(0);
+                utilities.verifyElementVisibilityState(uploadResponsePage.dialogBox(), 'exist');
+                uploadResponsePage.steps.enterTextInEditDisplayTextPopupInputField('image.csv');
+                uploadResponsePage.steps.verifyTextInEditDisplayTextPopupInputField('image.csv');
+                uploadResponsePage.steps.deleteFileButtonInDeleteFilePopup();
+                uploadResponsePage.steps.verifyUploadedFileName(0, 'image.csv');
+            });
+
+            it('CSS of Preview tab', { tags: 'css' }, () => {
+                utilities.verifyCSS(uploadResponsePage.uploadCloudIcon().find('path'), {
+                    'fill': css.color.cloudIconFill
+                });
+                utilities.verifyCSS(uploadResponsePage.dragAndDropFilesText(), {
+                    'color': css.color.text,
+                    'font-size': css.fontSize.huge,
+                    'font-weight': css.fontWeight.bold
+                });
+                utilities.verifyCSS(uploadResponsePage.fileUploadOptionsLabel(), {
+                    'color': css.color.text,
+                    'font-size': css.fontSize.heading,
+                    'font-weight': css.fontWeight.semibold
+                });
+                utilities.verifyCSS(uploadResponsePage.supportedFileFormatLabel(), {
+                    'color': css.color.text,
+                    'font-size': css.fontSize.normal,
+                    'font-weight': css.fontWeight.regular
+                });
+                utilities.verifyCSS(uploadResponsePage.supportedFileInfoIcon().find('path'), {
+                    'stroke': css.color.activeButtons
+                });
+                utilities.triggerMouseover(utilities.getNthElement(uploadResponsePage.supportedFileInfoIcon(), 0));
+                utilities.verifyCSS(uploadResponsePage.supportedFilesTooltip(), {
+                    'color': css.color.whiteText,
+                    'font-size': css.fontSize.extraSmall,
+                    'font-weight': css.fontWeight.light,
+                    'background-color': css.color.tooltipBg
+                });
+                utilities.triggerMouseout(utilities.getNthElement(uploadResponsePage.supportedFileInfoIcon(), 0));
+                utilities.verifyCSS(uploadResponsePage.uploadedFileCount(), {
+                    'color': css.color.labels,
+                    'font-size': css.fontSize.small,
+                    'font-weight': css.fontWeight.regular,
+                    'background-color': css.color.fileLimitBg
+                });
+                uploadResponsePage.deviceLink()
+                    .verifyPseudoClassBeforeProperty('color', css.color.text);
+                uploadResponsePage.googleDriveLink()
+                    .verifyPseudoClassBeforeProperty('color', css.color.text);
+            });
+
+            //Failed due to https://redmine.zeuslearning.com/issues/562203
+            it('Accessibility of Preview tab', { tags: 'a11y' }, () => {
+                cy.checkAccessibility(uploadResponsePage.questionWrapperPreviewTab());
+            });
+
+            it('When user uploads file type which is not selected from the \'Supported file types\' accordion menu, then file upload error message - \'The file type is not supported. Please upload files with the following supported formats: *file format separated by commas*\' should be displayed', () => {
+                uploadResponsePage.steps.uploadFile('uploads/sample.heif');
+                uploadResponsePage.steps.verifyWarningMessage('The file type is not supported. Please upload files with the following supported formats: CSV, Excel, GIF, JPG, Open Office, PDF, PNG, Powerpoint, Publisher, RTF, TXT, Word, XPS, ZIP.');
+            });
+
+            it('When user tries to upload files more than the limit, then warning message \'You have reached the maximum number of files that can be uploaded.\' should be displayed', () => {
+                uploadResponsePage.steps.uploadFile('uploads/highlightImage.jpg');
+                uploadResponsePage.steps.uploadFile('uploads/image.png');
+                uploadResponsePage.steps.verifyWarningMessage('You have reached the maximum number of files that can be uploaded.');
+            });
+
+            if (view != 'Question preview') {
+                it('On clicking on the file name, user should be able to download the file', () => {
+                    cy.verifyUploadFilePreviewDownload('sample.pdf');
+                    cy.log('Added wait here to pause till the file download is complete');
+                    cy.wait(5000);
+                });
+            }
+        });
+    });
+});

package/cypress/e2e/ILC/UploadResponse/uploadResponseHeaderSection.js

@@ -0,0 +1,66 @@
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import { uploadResponsePage, dialogBoxBase } from "../../../pages";
+import utilities from "../../../support/helpers/utilities";
+
+describe('Create question page - Upload Response: Header section and Saving question', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Header section contents', () => {
+        abortEarlySetup();
+        before(() => {
+            uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+        });
+
+        uploadResponsePage.tests.verifyCreateQuestionPageQuestionTypeHeader('Upload response');
+    });
+
+    describe('Tabs section', () => {
+        abortEarlySetup();
+        before(() => {
+            uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+        });
+
+        uploadResponsePage.tests.verifyTabsSection();
+    });
+
+    describe('Cancel button', () => {
+        abortEarlySetup();
+        before(() => {
+            uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+        });
+
+        uploadResponsePage.tests.verifyCancelButton('upload response');
+    });
+
+    describe('Save Question button', () => {
+        abortEarlySetup();
+        before(() => {
+            uploadResponsePage.steps.navigateToCreateQuestion('upload response');
+            cy.barsPreLoaderWait();
+        });
+
+        describe('Validation error messages', () => {
+            dialogBoxBase.tests.verifyRequiredFieldsWarningPopupOnClickingSaveButton();
+
+            it('Validation error messages should be displayed below required input fields', () => {
+                uploadResponsePage.steps.verifyQuestionInstructionsErrorMessage();
+                utilities.verifyInnerText(uploadResponsePage.pleaseEnterPointsErrorMessage(), 'Error: Please enter points.');
+            });
+
+            it('Validation error messages should disappear when required input fields are filled', () => {
+                uploadResponsePage.steps.addQuestionInstructions();
+                uploadResponsePage.steps.allotPoints(20);
+                uploadResponsePage.steps.verifyErrorMessageIsNotDisplayed();
+            });
+        });
+
+        describe('Saving a question', () => {
+            it('When user has filled all the mandatory fields then on clicking on Save Question button the question should get saved and a snackbar with text \'Saved successfully!\' should be displayed', () => {
+                uploadResponsePage.steps.saveAQuestionAndVerifySnackbar();
+            });
+            uploadResponsePage.tests.verifySavedSuccessfullySnackbarCSSAndA11y();
+        });
+    });
+});