itemengine-cypress-automation 1.0.122-updateILCRepo28Feb-2c3e0e3.0 → 1.0.123

package/cypress/e2e/migration/migration7.js

@@ -0,0 +1,160 @@
+import { autoScoredScoringPreviewTab } from "../../pages/components";
+import utilities from "../../support/helpers/utilities";
+import { extractLrnQuestionData, lrnPage } from "../../support/migrationHelpers/extractLrnQuestionData";
+import lrnQuestionTypesENUM from "../../support/migrationHelpers/lrnQestionTypesENUM";
+import { iePage, verifyIeQuestionData } from "../../support/migrationHelpers/verifyIeQuestionData";
+
+Cypress.Commands.add('learnosityLoaderWait', () => {
+    // cy.get('.lrn-spinner')
+    //     .should('be.visible');
+    lrnPage.questionsLoader()
+        .should('not.be.visible');
+    lrnPage.questionWrapper()
+        .eq(0)
+        .should('be.visible');
+});
+
+Cypress.Commands.add('lazyLoadPreviewQuestions', (count, retries = 5) => {
+    iePage.questionWrapper()
+        .then((elements) => {
+            if (retries <= 0) {
+                throw new Error('Itemengine questions did not lazy load in time');
+            };
+            if (elements.length < count) {
+                iePage.questionWrapper()
+                    .last()
+                    .scrollIntoView()
+                    .wait(1000);
+                cy.lazyLoadPreviewQuestions(count, retries - 1)
+            };
+            cy.log('All question parts loaded');
+        });
+    iePage.barsPreloader()
+        .should('not.exist');
+    cy.learnosityLoaderWait();
+})
+
+const migrationQuestionTypes = Cypress.env('migrationQuestionTypes');//["essayResponse"]
+const migrationQuestionTypesLrn = migrationQuestionTypes.map((questionType) => lrnQuestionTypesENUM[questionType]);
+let lrnMcqTypesRegex = /Multiple choice – standard|Multiple choice – multiple response|True or false|Multiple choice – block layout/;
+let lrnEssayResponseRegex = /Math essay with rich text|Essay with rich text/
+
+
+let lrnQuestionDataArr = [];
+let lrnGradingDataArr = [];
+
+let referenceIds = JSON.parse(Cypress.env('referenceIds')).slice(600, 700);//["0715a48c-4c1f-4eed-8058-793ad9402f89", "c476e9ca-2ac6-4ebc-b548-241ef3cd13bb"]
+
+if (referenceIds.length > 0) {
+    describe('Migration item check for MCQ questions', () => {
+        before(() => {
+            cy.loginAs('technicalTester');
+        });
+
+        referenceIds.forEach((referenceId) => {
+            describe(`Migration item check for item "${referenceId}"`, () => {
+                before(() => {
+                    cy.interceptGraphql('getItemPreview');
+                    cy.setGraphqlWait();
+                    cy.visit(`/items-list/item/${utilities.base64Encoding(referenceId)}`);
+                    cy.pageLoadWait('getItemPreview');
+                    cy.get('@getItemPreview').then((req) => {
+                        let questionCount = req.response.body.data.getItemPreview.item.questionParts.length;
+                        cy.lazyLoadPreviewQuestions(questionCount);
+                    });
+                });
+
+                after(() => {
+                    console.log(lrnQuestionDataArr)
+                    console.log(lrnGradingDataArr)
+                    lrnQuestionDataArr = [];
+                    lrnGradingDataArr = [];
+                });
+
+                it(`Extracting learnosity preview data for item "${referenceId}"`, () => {
+                    lrnPage.questionTypeDiv()
+                        .each(($el, index) => {
+                            let currQuestionType = $el[0].innerText
+                            if (lrnMcqTypesRegex.test(currQuestionType)) {
+                                currQuestionType = lrnQuestionTypesENUM.mcq;
+                            }
+                            if (lrnEssayResponseRegex.test(currQuestionType)) {
+                                ;
+                                currQuestionType = lrnQuestionTypesENUM.essayResponse;
+                            }
+                            if (migrationQuestionTypesLrn.includes(currQuestionType)) {
+                                switch (currQuestionType) {
+                                    case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcq(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMath(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMathImage: return extractLrnQuestionData.textEntryMathImage(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.essayResponse: return extractLrnQuestionData.essayResponse(lrnQuestionDataArr, index);
+                                    default: throw new Error('Invalid lrn question type');
+                                }
+                            }
+                        });
+                });
+
+                it(`Verifying itemengine preview data for item "${referenceId}"`, () => {
+                    migrationQuestionTypes.forEach((questionType) => {
+                        cy.log(`Verifying data for all ${questionType} question type`);
+                        let currQuestionTypeArr = lrnQuestionDataArr.filter((question) => question.questionType === questionType);
+                        currQuestionTypeArr.forEach((questionData, index) => {
+                            cy.log(`Verifying data for ${questionType} ${index}`);
+                            switch (questionType) {
+                                case 'mcq': return verifyIeQuestionData.mcq(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMath(questionData, index);
+                                case 'textEntryMathImage': return verifyIeQuestionData.textEntryMathImage(questionData, index);
+                                case 'essayResponse': return verifyIeQuestionData.essayResponse(questionData, index);
+                                default: throw new Error('Invalid ngie question type');
+                            }
+                        });
+                    });
+                });
+
+                it(`Extracting learnosity grading data for item "${referenceId}"`, () => {
+                    lrnPage.authorItemToolbarControlsWrapper()
+                        .then(($element) => {
+                            if ($element[0].innerHTML.includes('lrn-author-validate-questions-toggle')) {
+                                lrnPage.steps.checkShowAnswersToggle();
+                                lrnPage.questionTypeDiv()
+                                    .each(($el, index) => {
+                                        let currQuestionType = $el[0].innerText
+                                        if (lrnMcqTypesRegex.test(currQuestionType)) {
+                                            currQuestionType = lrnQuestionTypesENUM.mcq
+                                        }
+                                        if (migrationQuestionTypesLrn.includes(currQuestionType)) {
+                                            switch (currQuestionType) {
+                                                case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcqGrading(lrnGradingDataArr, index);
+                                                case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMathGrading(lrnGradingDataArr, index);
+                                                case lrnQuestionTypesENUM.textEntryMathImage: return extractLrnQuestionData.textEntryMathImageGrading(lrnGradingDataArr, index);
+                                                default: throw new Error('Invalid lrn question type');
+                                            }
+                                        }
+                                    });
+                            }
+                        });
+                });
+
+                it(`Verifying itemengine grading data for item "${referenceId}"`, () => {
+                    autoScoredScoringPreviewTab.steps.switchToGradingView();
+                    cy.wait(500);
+                    migrationQuestionTypes.forEach((questionType) => {
+                        cy.log(`Verifying grading data for all ${questionType} question type`);
+                        let currQuestionTypeArr = lrnGradingDataArr.filter((question) => question.questionType === questionType);
+                        currQuestionTypeArr.forEach((questionData, index) => {
+                            cy.log(`Verifying grading data for ${questionType} ${index}`);
+                            switch (questionType) {
+                                case 'mcq': return verifyIeQuestionData.mcqGrading(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMathGrading(questionData, index);
+                                case 'textEntryMathImage': return verifyIeQuestionData.textEntryMathImageGrading(questionData, index);
+                                default: throw new Error('Invalid ngie question type');
+                            }
+                        });
+                    });
+                });
+            });
+        });
+    });
+}
+
+//https://s3.console.aws.amazon.com/s3/object/itemengine-qa-bucket?region=us-west-2&bucketType=general&prefix=cypressAutomation/migrationFixtures.json

package/cypress/e2e/migration/migration8.js

@@ -0,0 +1,160 @@
+import { autoScoredScoringPreviewTab } from "../../pages/components";
+import utilities from "../../support/helpers/utilities";
+import { extractLrnQuestionData, lrnPage } from "../../support/migrationHelpers/extractLrnQuestionData";
+import lrnQuestionTypesENUM from "../../support/migrationHelpers/lrnQestionTypesENUM";
+import { iePage, verifyIeQuestionData } from "../../support/migrationHelpers/verifyIeQuestionData";
+
+Cypress.Commands.add('learnosityLoaderWait', () => {
+    // cy.get('.lrn-spinner')
+    //     .should('be.visible');
+    lrnPage.questionsLoader()
+        .should('not.be.visible');
+    lrnPage.questionWrapper()
+        .eq(0)
+        .should('be.visible');
+});
+
+Cypress.Commands.add('lazyLoadPreviewQuestions', (count, retries = 5) => {
+    iePage.questionWrapper()
+        .then((elements) => {
+            if (retries <= 0) {
+                throw new Error('Itemengine questions did not lazy load in time');
+            };
+            if (elements.length < count) {
+                iePage.questionWrapper()
+                    .last()
+                    .scrollIntoView()
+                    .wait(1000);
+                cy.lazyLoadPreviewQuestions(count, retries - 1)
+            };
+            cy.log('All question parts loaded');
+        });
+    iePage.barsPreloader()
+        .should('not.exist');
+    cy.learnosityLoaderWait();
+})
+
+const migrationQuestionTypes = Cypress.env('migrationQuestionTypes');//["essayResponse"]
+const migrationQuestionTypesLrn = migrationQuestionTypes.map((questionType) => lrnQuestionTypesENUM[questionType]);
+let lrnMcqTypesRegex = /Multiple choice – standard|Multiple choice – multiple response|True or false|Multiple choice – block layout/;
+let lrnEssayResponseRegex = /Math essay with rich text|Essay with rich text/
+
+
+let lrnQuestionDataArr = [];
+let lrnGradingDataArr = [];
+
+let referenceIds = JSON.parse(Cypress.env('referenceIds')).slice(700, 800);//["0715a48c-4c1f-4eed-8058-793ad9402f89", "c476e9ca-2ac6-4ebc-b548-241ef3cd13bb"]
+
+if (referenceIds.length > 0) {
+    describe('Migration item check for MCQ questions', () => {
+        before(() => {
+            cy.loginAs('technicalTester');
+        });
+
+        referenceIds.forEach((referenceId) => {
+            describe(`Migration item check for item "${referenceId}"`, () => {
+                before(() => {
+                    cy.interceptGraphql('getItemPreview');
+                    cy.setGraphqlWait();
+                    cy.visit(`/items-list/item/${utilities.base64Encoding(referenceId)}`);
+                    cy.pageLoadWait('getItemPreview');
+                    cy.get('@getItemPreview').then((req) => {
+                        let questionCount = req.response.body.data.getItemPreview.item.questionParts.length;
+                        cy.lazyLoadPreviewQuestions(questionCount);
+                    });
+                });
+
+                after(() => {
+                    console.log(lrnQuestionDataArr)
+                    console.log(lrnGradingDataArr)
+                    lrnQuestionDataArr = [];
+                    lrnGradingDataArr = [];
+                });
+
+                it(`Extracting learnosity preview data for item "${referenceId}"`, () => {
+                    lrnPage.questionTypeDiv()
+                        .each(($el, index) => {
+                            let currQuestionType = $el[0].innerText
+                            if (lrnMcqTypesRegex.test(currQuestionType)) {
+                                currQuestionType = lrnQuestionTypesENUM.mcq;
+                            }
+                            if (lrnEssayResponseRegex.test(currQuestionType)) {
+                                ;
+                                currQuestionType = lrnQuestionTypesENUM.essayResponse;
+                            }
+                            if (migrationQuestionTypesLrn.includes(currQuestionType)) {
+                                switch (currQuestionType) {
+                                    case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcq(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMath(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMathImage: return extractLrnQuestionData.textEntryMathImage(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.essayResponse: return extractLrnQuestionData.essayResponse(lrnQuestionDataArr, index);
+                                    default: throw new Error('Invalid lrn question type');
+                                }
+                            }
+                        });
+                });
+
+                it(`Verifying itemengine preview data for item "${referenceId}"`, () => {
+                    migrationQuestionTypes.forEach((questionType) => {
+                        cy.log(`Verifying data for all ${questionType} question type`);
+                        let currQuestionTypeArr = lrnQuestionDataArr.filter((question) => question.questionType === questionType);
+                        currQuestionTypeArr.forEach((questionData, index) => {
+                            cy.log(`Verifying data for ${questionType} ${index}`);
+                            switch (questionType) {
+                                case 'mcq': return verifyIeQuestionData.mcq(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMath(questionData, index);
+                                case 'textEntryMathImage': return verifyIeQuestionData.textEntryMathImage(questionData, index);
+                                case 'essayResponse': return verifyIeQuestionData.essayResponse(questionData, index);
+                                default: throw new Error('Invalid ngie question type');
+                            }
+                        });
+                    });
+                });
+
+                it(`Extracting learnosity grading data for item "${referenceId}"`, () => {
+                    lrnPage.authorItemToolbarControlsWrapper()
+                        .then(($element) => {
+                            if ($element[0].innerHTML.includes('lrn-author-validate-questions-toggle')) {
+                                lrnPage.steps.checkShowAnswersToggle();
+                                lrnPage.questionTypeDiv()
+                                    .each(($el, index) => {
+                                        let currQuestionType = $el[0].innerText
+                                        if (lrnMcqTypesRegex.test(currQuestionType)) {
+                                            currQuestionType = lrnQuestionTypesENUM.mcq
+                                        }
+                                        if (migrationQuestionTypesLrn.includes(currQuestionType)) {
+                                            switch (currQuestionType) {
+                                                case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcqGrading(lrnGradingDataArr, index);
+                                                case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMathGrading(lrnGradingDataArr, index);
+                                                case lrnQuestionTypesENUM.textEntryMathImage: return extractLrnQuestionData.textEntryMathImageGrading(lrnGradingDataArr, index);
+                                                default: throw new Error('Invalid lrn question type');
+                                            }
+                                        }
+                                    });
+                            }
+                        });
+                });
+
+                it(`Verifying itemengine grading data for item "${referenceId}"`, () => {
+                    autoScoredScoringPreviewTab.steps.switchToGradingView();
+                    cy.wait(500);
+                    migrationQuestionTypes.forEach((questionType) => {
+                        cy.log(`Verifying grading data for all ${questionType} question type`);
+                        let currQuestionTypeArr = lrnGradingDataArr.filter((question) => question.questionType === questionType);
+                        currQuestionTypeArr.forEach((questionData, index) => {
+                            cy.log(`Verifying grading data for ${questionType} ${index}`);
+                            switch (questionType) {
+                                case 'mcq': return verifyIeQuestionData.mcqGrading(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMathGrading(questionData, index);
+                                case 'textEntryMathImage': return verifyIeQuestionData.textEntryMathImageGrading(questionData, index);
+                                default: throw new Error('Invalid ngie question type');
+                            }
+                        });
+                    });
+                });
+            });
+        });
+    });
+}
+
+//https://s3.console.aws.amazon.com/s3/object/itemengine-qa-bucket?region=us-west-2&bucketType=general&prefix=cypressAutomation/migrationFixtures.json

package/cypress/e2e/migration/migration9.js

@@ -0,0 +1,160 @@
+import { autoScoredScoringPreviewTab } from "../../pages/components";
+import utilities from "../../support/helpers/utilities";
+import { extractLrnQuestionData, lrnPage } from "../../support/migrationHelpers/extractLrnQuestionData";
+import lrnQuestionTypesENUM from "../../support/migrationHelpers/lrnQestionTypesENUM";
+import { iePage, verifyIeQuestionData } from "../../support/migrationHelpers/verifyIeQuestionData";
+
+Cypress.Commands.add('learnosityLoaderWait', () => {
+    // cy.get('.lrn-spinner')
+    //     .should('be.visible');
+    lrnPage.questionsLoader()
+        .should('not.be.visible');
+    lrnPage.questionWrapper()
+        .eq(0)
+        .should('be.visible');
+});
+
+Cypress.Commands.add('lazyLoadPreviewQuestions', (count, retries = 5) => {
+    iePage.questionWrapper()
+        .then((elements) => {
+            if (retries <= 0) {
+                throw new Error('Itemengine questions did not lazy load in time');
+            };
+            if (elements.length < count) {
+                iePage.questionWrapper()
+                    .last()
+                    .scrollIntoView()
+                    .wait(1000);
+                cy.lazyLoadPreviewQuestions(count, retries - 1)
+            };
+            cy.log('All question parts loaded');
+        });
+    iePage.barsPreloader()
+        .should('not.exist');
+    cy.learnosityLoaderWait();
+})
+
+const migrationQuestionTypes = Cypress.env('migrationQuestionTypes');//["essayResponse"]
+const migrationQuestionTypesLrn = migrationQuestionTypes.map((questionType) => lrnQuestionTypesENUM[questionType]);
+let lrnMcqTypesRegex = /Multiple choice – standard|Multiple choice – multiple response|True or false|Multiple choice – block layout/;
+let lrnEssayResponseRegex = /Math essay with rich text|Essay with rich text/
+
+
+let lrnQuestionDataArr = [];
+let lrnGradingDataArr = [];
+
+let referenceIds = JSON.parse(Cypress.env('referenceIds')).slice(800, 900);//["0715a48c-4c1f-4eed-8058-793ad9402f89", "c476e9ca-2ac6-4ebc-b548-241ef3cd13bb"]
+
+if (referenceIds.length > 0) {
+    describe('Migration item check for MCQ questions', () => {
+        before(() => {
+            cy.loginAs('technicalTester');
+        });
+
+        referenceIds.forEach((referenceId) => {
+            describe(`Migration item check for item "${referenceId}"`, () => {
+                before(() => {
+                    cy.interceptGraphql('getItemPreview');
+                    cy.setGraphqlWait();
+                    cy.visit(`/items-list/item/${utilities.base64Encoding(referenceId)}`);
+                    cy.pageLoadWait('getItemPreview');
+                    cy.get('@getItemPreview').then((req) => {
+                        let questionCount = req.response.body.data.getItemPreview.item.questionParts.length;
+                        cy.lazyLoadPreviewQuestions(questionCount);
+                    });
+                });
+
+                after(() => {
+                    console.log(lrnQuestionDataArr)
+                    console.log(lrnGradingDataArr)
+                    lrnQuestionDataArr = [];
+                    lrnGradingDataArr = [];
+                });
+
+                it(`Extracting learnosity preview data for item "${referenceId}"`, () => {
+                    lrnPage.questionTypeDiv()
+                        .each(($el, index) => {
+                            let currQuestionType = $el[0].innerText
+                            if (lrnMcqTypesRegex.test(currQuestionType)) {
+                                currQuestionType = lrnQuestionTypesENUM.mcq;
+                            }
+                            if (lrnEssayResponseRegex.test(currQuestionType)) {
+                                ;
+                                currQuestionType = lrnQuestionTypesENUM.essayResponse;
+                            }
+                            if (migrationQuestionTypesLrn.includes(currQuestionType)) {
+                                switch (currQuestionType) {
+                                    case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcq(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMath(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMathImage: return extractLrnQuestionData.textEntryMathImage(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.essayResponse: return extractLrnQuestionData.essayResponse(lrnQuestionDataArr, index);
+                                    default: throw new Error('Invalid lrn question type');
+                                }
+                            }
+                        });
+                });
+
+                it(`Verifying itemengine preview data for item "${referenceId}"`, () => {
+                    migrationQuestionTypes.forEach((questionType) => {
+                        cy.log(`Verifying data for all ${questionType} question type`);
+                        let currQuestionTypeArr = lrnQuestionDataArr.filter((question) => question.questionType === questionType);
+                        currQuestionTypeArr.forEach((questionData, index) => {
+                            cy.log(`Verifying data for ${questionType} ${index}`);
+                            switch (questionType) {
+                                case 'mcq': return verifyIeQuestionData.mcq(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMath(questionData, index);
+                                case 'textEntryMathImage': return verifyIeQuestionData.textEntryMathImage(questionData, index);
+                                case 'essayResponse': return verifyIeQuestionData.essayResponse(questionData, index);
+                                default: throw new Error('Invalid ngie question type');
+                            }
+                        });
+                    });
+                });
+
+                it(`Extracting learnosity grading data for item "${referenceId}"`, () => {
+                    lrnPage.authorItemToolbarControlsWrapper()
+                        .then(($element) => {
+                            if ($element[0].innerHTML.includes('lrn-author-validate-questions-toggle')) {
+                                lrnPage.steps.checkShowAnswersToggle();
+                                lrnPage.questionTypeDiv()
+                                    .each(($el, index) => {
+                                        let currQuestionType = $el[0].innerText
+                                        if (lrnMcqTypesRegex.test(currQuestionType)) {
+                                            currQuestionType = lrnQuestionTypesENUM.mcq
+                                        }
+                                        if (migrationQuestionTypesLrn.includes(currQuestionType)) {
+                                            switch (currQuestionType) {
+                                                case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcqGrading(lrnGradingDataArr, index);
+                                                case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMathGrading(lrnGradingDataArr, index);
+                                                case lrnQuestionTypesENUM.textEntryMathImage: return extractLrnQuestionData.textEntryMathImageGrading(lrnGradingDataArr, index);
+                                                default: throw new Error('Invalid lrn question type');
+                                            }
+                                        }
+                                    });
+                            }
+                        });
+                });
+
+                it(`Verifying itemengine grading data for item "${referenceId}"`, () => {
+                    autoScoredScoringPreviewTab.steps.switchToGradingView();
+                    cy.wait(500);
+                    migrationQuestionTypes.forEach((questionType) => {
+                        cy.log(`Verifying grading data for all ${questionType} question type`);
+                        let currQuestionTypeArr = lrnGradingDataArr.filter((question) => question.questionType === questionType);
+                        currQuestionTypeArr.forEach((questionData, index) => {
+                            cy.log(`Verifying grading data for ${questionType} ${index}`);
+                            switch (questionType) {
+                                case 'mcq': return verifyIeQuestionData.mcqGrading(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMathGrading(questionData, index);
+                                case 'textEntryMathImage': return verifyIeQuestionData.textEntryMathImageGrading(questionData, index);
+                                default: throw new Error('Invalid ngie question type');
+                            }
+                        });
+                    });
+                });
+            });
+        });
+    });
+}
+
+//https://s3.console.aws.amazon.com/s3/object/itemengine-qa-bucket?region=us-west-2&bucketType=general&prefix=cypressAutomation/migrationFixtures.json

package/cypress/fixtures/drawingToolbarOptionsAdditionalOptionsAndSpecialAndMathCharacters.js

@@ -88,7 +88,7 @@ export const drawingToolbarOptionsAndAdditionalOptions = {
             toolType: 'action'
         },
         {
-            displayName: 'sent to back',
+            displayName: 'Send to back',
             tooltipText: 'Bring backwardSend selected item back a layer',
             toolType: 'action'
         },

package/cypress/pages/drawingResponsePage.js

@@ -649,7 +649,7 @@ const steps = {
         drawingResponsePage.charactersPopupCharactersCategoryWrapper()
             .eq(categoryIndex)
             .within(() => {
-                categorySymbolsArray[index].forEach((symbolARIALabel, index) => {
+                categorySymbolsArray.forEach((symbolARIALabel, index) => {
                     drawingResponsePage.charactersPopupCharacterSymbol()
                         .eq(index)
                         .find('svg')
@@ -676,6 +676,7 @@ const steps = {
         categoryListArray.forEach((category, index) => {
             utilities.verifyInnerText(drawingResponsePage.specialCharactersPopupCategoryTitle().eq(index), `${category.categoryName}`);
             utilities.verifyElementVisibilityState(drawingResponsePage.specialCharactersPopupCategoryTitle().eq(index), 'visible');
+            utilities.scrollIntoView(drawingResponsePage.specialCharactersPopupCategoryAccordionIcon().eq(index));
             utilities.verifyElementVisibilityState(drawingResponsePage.specialCharactersPopupCategoryAccordionIcon().eq(index), 'visible');
         });
     },
@@ -687,8 +688,8 @@ const steps = {
     verifySpecialCharactersPopupCategoryAccordionIsExpanded: (index) => {
         drawingResponsePage.specialCharactersPopupCategoryTitle()
             .eq(index)
-            .within(() => {
-                cy.wrap()
+            .within(($element) => {
+                cy.wrap($element)
                     .find('span[class*="icon-open"]')
                     .should('exist');
             });
@@ -702,8 +703,8 @@ const steps = {
     verifySpecialCharactersPopupCategoryAccordionIsCollapsed: (index) => {
         drawingResponsePage.specialCharactersPopupCategoryTitle()
             .eq(index)
-            .within(() => {
-                cy.wrap()
+            .within(($element) => {
+                cy.wrap($element)
                     .find('span[class*="icon-open"]')
                     .should('not.exist');
             });

package/cypress/pages/fillInTheGapsOverImageDropdownPage.js

@@ -13,7 +13,7 @@ const selectors = {
     ...optionsWrapperComponent,
     ...randomizeOptionsComponent,
     ...backgroundImageUploadComponent,
-    dropdownWrapperPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [class="Canvasstyle__DropzoneWrapper"]'),
+    dropdownWrapperPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [class*="Canvasstyle__DropzoneWrapper"]'),
     correctAnswerSectionWrapper: () => cy.get('.dnd-correct-answer-wrapper'),
     correctAnswerResponseWrapper: () => cy.get('[class*="LabelImageWithDropdownPreviewstyles__AnswerCell"]'),
     correctAnswerResponse: () => cy.get('[class*="LabelImageWithDropdownPreviewstyles__AnswerWrapper"]'),

package/cypress/pages/textEntryMathPage.js

@@ -12,6 +12,7 @@ const selectors = {
     ...autoScoredSpecifyCorrectAnswerSection,
 
     addStructureTab: () => cy.get('[data-ngie-testid="add-structure-tab"]'),
+    responseToken: () => cy.get('.cke_button__addresponse'),
 
     //TODO: Update below selectors after https://redmine.zeuslearning.com/issues/557945 is resolved
     //Response accordion
@@ -84,7 +85,7 @@ const selectors = {
     responseFieldWrapperPreviewTab: () => cy.get('.cloze-response-wrapper'),
     responseFieldNumerationPreviewTab: () => cy.get('.preview-question-text-wrapper .response-input-adornment'),
     questionContainerPreviewTab: () => cy.get('[class*="ClozeWithTextPreviewstyle__QuestionPreviewWrapper"]'),
-    tickIcon: () => cy.get('.cloze-with-text-answer-status-response-preview-wrapper .tick-icon-wrapper'),
+    tickIcon: () => cy.get('.tick-icon-wrapper'),
     correctAnswersContainerResponse: () => cy.get('.cloze-with-text-correct-response-wrapper .response-input-field'),
     correctAnswersContainerResponseNumeration: () => cy.get('.cloze-with-text-correct-response-wrapper .response-input-adornment'),
     correctAnswersLabel: () => cy.get('.cloze-with-text-correct-answer-label'),
@@ -111,6 +112,13 @@ const steps = {
             .should('have.attr', 'aria-selected', 'true');
     },
 
+    addResponseToken: () => {
+        questionInputFieldComponent.questionInputField()
+            .click();
+        textEntryMathPage.responseToken()
+            .click();
+    },
+
     /**
      * @description Verify response accordion is collapsed in specify correct answer section
      * @param {number} responseIndex index of response accordion
@@ -653,8 +661,8 @@ const steps = {
     verifyCorrectAnswerResponsesAriaLabel: (index, correctAnswerAriaLabel) => {
         textEntryMathPage.correctAnswersContainerResponse()
             .eq(index)
-            .find('[role="math"]')
-            .should('have.attr', 'aria-label', correctAnswerAriaLabel);
+            .invoke('attr', 'value')
+            .should('include', correctAnswerAriaLabel);
     },
 
     verifyResponseFieldNumerationPreviewTab: () => {
@@ -784,8 +792,8 @@ const tests = {
             });
 
             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();
+                textEntryMathPage.steps.addResponseAreaInQuestionField();
+                textEntryMathPage.steps.addResponseAreaInQuestionField();
                 utilities.verifyElementCount(textEntryMathPage.responseAccordion(), 2);
                 textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(0);
                 textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(1);
@@ -841,8 +849,8 @@ const tests = {
         });
 
         it('When user adds response tokens in question input field, then response accordions should be displayed in collapsed state in the \'Specify correct answer section\' with appropriate numeration', () => {
-            textEntryMathPage.steps.addResponseToken();
-            textEntryMathPage.steps.addResponseToken();
+            textEntryMathPage.steps.addResponseAreaInQuestionField();
+            textEntryMathPage.steps.addResponseAreaInQuestionField();
             utilities.verifyElementCount(textEntryMathPage.responseAccordion(), 2);
             textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(0);
             textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(1);

package/cypress/pages/uploadResponsePage.js

@@ -160,6 +160,15 @@ const steps = {
         utilities.verifyInnerText(utilities.getNthElement(uploadResponsePage.fileName(), fileIndex), fileName);
     },
 
+     /**
+     * @param {string} fileName - The expected name of the uploaded file.
+     * Verifies the displayed name of an uploaded file 
+    */
+    verifyUploadedFileNameVisible: (fileName) => {
+        uploadResponsePage.uploadedFilesSectionWrapper()
+            .contains(fileName);
+    },
+
     stopUploadingFile: () => {
         uploadResponsePage.stopUploadingButton()
             .click();
@@ -360,7 +369,7 @@ const steps = {
     uploadFile: (file) => {
         uploadResponsePage.inputTypeFile()
             .attachFile(file);
-            cy.wait(2000);
+        cy.wait(2000);
     },
 
     verifyDefaultSelectedFileTypes: () => {