itemengine-cypress-automation 1.0.121 → 1.0.122

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/support/migrationHelpers/essayResponseToolbarOptionsENUM.js

@@ -0,0 +1,30 @@
+const essayResponseToolbarOptionsENUM = {
+    "Bold": "Bold (Ctrl+B)",
+    "Italic": "Italic (Ctrl+I)",
+    "Underline": "Underline (Ctrl+U)",
+    "Increase indent": "Increase Indent",
+    "Decrease indent": "Decrease Indent",
+    "Formula keypad": "Equation Editor",
+    "Undo": "Undo (Ctrl+Z)",
+    "Redo": "Redo (Ctrl+Y)",
+    "Clear formatting": "Remove Format",
+    "Code Inline": "Code Inline",
+    "Code Editor": "Code Editor",
+    "Align left": "Align Left",
+    "Align center": "Align Center",
+    "Align right": "Align Right",
+    "Align justify": "Align Justify",
+    "Bullet list": "Insert/Remove Bulleted List",
+    "Numbered list": "Insert/Remove Numbered List",
+    "Block quote": "Block Quote",
+    "Superscript": "Superscript",
+    "Subscript": "Subscript",
+    "Text direction left to right": "Text direction left to right",
+    "Text direction right to left": "Text direction right to left",
+    "Insert horizontal rule": "Insert Horizontal Line",
+    "Table": "Insert Table",
+    "Special Characters": "Special characters",
+    "Image (12 image limit)": "Insert Image"
+}
+
+export default essayResponseToolbarOptionsENUM;

package/cypress/support/migrationHelpers/extractLrnQuestionData.js

@@ -1,4 +1,5 @@
 export const lrnPage = {
+    authorItemToolbarControlsWrapper: () => cy.get('.lrn-author-item-toolbar-controls-alt'),
     questionTypeDiv: () => cy.get('.lrn-widget-drag-name'),
     questionInstructions: () => cy.get('.lrn_question'),
     questionWrapper: () => cy.get('.lrn-widget-drag-wrapper'),
@@ -11,6 +12,8 @@ export const lrnPage = {
     clozeMathCorrectAnswerMathMl: () => cy.get('.lrn_correctAnswerList math'),
     correctAnswersResponseText: () => cy.get('.lrn_responseText'),
     backgroundCanvasImage: () => cy.get('.lrn_imagecloze_image'),
+    essayResponseTextArea: () => cy.get('.lrn_texteditor_editable'),
+    essayResponseToolbarButton: () => cy.get('[aria-label="Text controls"] button.lrn_btn'),
     steps: {
         checkShowAnswersToggle: () => {
             lrnPage.showAnswersToggle()
@@ -260,11 +263,17 @@ export const extractLrnQuestionData = {
         lrnGradingDataArr.push(obj);
     },
 
-    essayResponseMath: (lrnQuestionDataArr, index) => {
+    essayResponse: (lrnQuestionDataArr, index) => {
+        //instructions
+        //text in the input field
+        //placeholder
+        //wordlimit and stuff
+        //toolbar icons
+        //check with abhishek if we need to cover the grading view/else we can just check if the questino is not giving any error in grading view, i.e it is visible
         let obj = {};
         cy.log(`Extracting the question instructions and options from question ${index}`);
         obj.questionIndex = index;
-        obj.questionType = 'essayResponseMath'
+        obj.questionType = 'essayResponse'
         lrnPage.questionWrapper()
             .eq(index)
             .within(() => {
@@ -273,6 +282,19 @@ export const extractLrnQuestionData = {
                         let text = $ins[0].innerText;
                         obj.previewQuestionInstructions = text;
                     });
+                lrnPage.essayResponseTextArea()
+                    .then(($element) => {
+                        let textAreaPlaceholder = $element[0].attributes["data-placeholder"]?.nodeValue;
+                        obj.textAreaPlaceholder = textAreaPlaceholder;
+                    });
+                let toolbarButtons = [];
+                lrnPage.essayResponseToolbarButton()
+                    .each(($button) => {
+                        let ariaLabel = $button[0].attributes["aria-label"].nodeValue;
+                        if (!ariaLabel) ariaLabel = $button[0].attributes["title"].nodeValue;
+                        if (ariaLabel != 'Edit table') toolbarButtons.push(ariaLabel);
+                    })
+                obj.toolbarButtons = toolbarButtons;
             });
         lrnQuestionDataArr.push(obj);
     },

package/cypress/support/migrationHelpers/lrnQestionTypesENUM.js

@@ -2,7 +2,7 @@ const lrnQuestionTypesENUM = {
     mcq: 'mcq',
     textEntryMath: 'Cloze math',
     textEntryMathImage: 'Cloze math with image',
-    essayResponseMath: 'Math essay with rich text',
+    essayResponse: 'essayResponse',
     singleSelection: 'Multiple choice – standard',
     multipleSelection: 'Multiple choice – multiple response',
     trueOrFalse: 'True or false',

package/cypress/support/migrationHelpers/verifyIeQuestionData.js

@@ -1,6 +1,7 @@
-import { multipleSelectionPage } from "../../pages";
+import { essayResponsePage, multipleSelectionPage } from "../../pages";
 import { singleSelectionPage } from "../../pages/singleSelectionPage"
 import utilities from "../helpers/utilities";
+import essayResponseToolbarOptionsENUM from "./essayResponseToolbarOptionsENUM";
 
 export const iePage = {
     mcqOption: () => cy.get('.mcq_Label'),
@@ -155,12 +156,27 @@ export const verifyIeQuestionData = {
             });
     },
 
-    essayResponseMath: (expectedQuestionData, index) => {
-        cy.get('.ngie-essay-response-math')
+    essayResponse: (expectedQuestionData, index) => {
+        cy.get('[class*="ngie-essay-response"]')
             .eq(index)
             .within(() => {
-                singleSelectionPage.questionInstructionsText()
-                    .verifyInnerText(expectedQuestionData.previewQuestionInstructions);
+                utilities.verifyInnerText(singleSelectionPage.questionInstructionsText(), expectedQuestionData.previewQuestionInstructions);
+                essayResponsePage.responseField()
+                    .then(($element) => {
+                        let textAreaPlaceholder = $element[0].attributes["data-cke-editorplaceholder"]?.nodeValue;
+                        expect(textAreaPlaceholder).to.be.eq(expectedQuestionData.textAreaPlaceholder);
+                    });
+                let ieButtonsTitle = [];
+                let ieButtonsExpected = expectedQuestionData.toolbarButtons.map((button) => {
+                    return essayResponseToolbarOptionsENUM[button];
+                });
+                essayResponsePage.previewTabToolbarOption()
+                    .each(($button) => {
+                        let title = $button[0].attributes["title"].nodeValue;
+                        ieButtonsTitle.push(title);
+                    }).then(() => {
+                        expect(ieButtonsTitle).to.have.deep.members(ieButtonsExpected);
+                    });
             });
     },
 

package/deploy/migration/deploy.yaml

@@ -9,8 +9,8 @@ variables:
 deployment:
   job:
     activeDeadlineSeconds: 7200
-    parallelism: 5
-    completions: 5
+    parallelism: 10
+    completions: 10
 
   image:
     cmd: /ie-e2e/deploy/migration/run.sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itemengine-cypress-automation",
-  "version": "1.0.121",
+  "version": "1.0.122",
   "description": "",
   "main": "index.js",
   "scripts": {