itemengine-cypress-automation 1.0.117 → 1.0.119

package/cypress/config-files/ilprod.json

@@ -10,6 +10,8 @@
         "scriptSrc": "https://assets.itemengine-prod.il-apps.com/Author.loader.js",
         "admin_username": "demouser-ilc",
         "admin_password": "GzL1Ezjou4wVFL8o",
-        "organisation_id": "eb7d4a20-c96c-4852-9b34-7e3231016315"
+        "organisation_id": "eb7d4a20-c96c-4852-9b34-7e3231016315",
+        "migration_usernme": "ilc-prod-content-user",
+        "migration_password": "Oj2kTWQM7ZRmegmS"
     }
 }

package/cypress/config-files/ilqa.json

@@ -10,6 +10,8 @@
         "scriptSrc": "https://assets.itemengine-qa.il-apps.com/Author.loader.js",
         "admin_username": "demouser-ilc",
         "admin_password": "GtOrLiig9surpeW1",
-        "organisation_id": "eb7d4a20-c96c-4852-9b34-7e3231016315"
+        "organisation_id": "eb7d4a20-c96c-4852-9b34-7e3231016315",
+        "migration_usernme": "demo-technical-tester",
+        "migration_password": "SXYeokWOoTuwEg2w"
     }
 }

package/cypress/e2e/migration/migration.js

@@ -34,14 +34,14 @@ Cypress.Commands.add('lazyLoadPreviewQuestions', (count, retries = 5) => {
     cy.learnosityLoaderWait();
 })
 
-const migrationQuestionTypes = Cypress.env('migrationQuestionTypes');
+const migrationQuestionTypes = Cypress.env('migrationQuestionTypes');//["textEntryMath"]
 const migrationQuestionTypesLrn = migrationQuestionTypes.map((questionType) => lrnQuestionTypesENUM[questionType]);
 let lrnMcqTypesRegex = /Multiple choice – standard|Multiple choice – multiple response|True or false|Multiple choice – block layout/;
 
 let lrnQuestionDataArr = [];
 let lrnGradingDataArr = [];
 
-let referenceIds = JSON.parse(Cypress.env('referenceIds')).slice(0, 100);
+let referenceIds = JSON.parse(Cypress.env('referenceIds')).slice(0, 100);//["eae30254-8637-4b59-a124-1b0caa68bc6e", "5acb0056-3d16-46d7-abbb-7a1ce08686ef", "6bd0f709-86c5-4e52-9510-9af3cd73e224"]
 
 if (referenceIds.length > 0) {
     describe('Migration item check for MCQ questions', () => {
@@ -76,9 +76,13 @@ if (referenceIds.length > 0) {
                             if (lrnMcqTypesRegex.test(currQuestionType)) {
                                 currQuestionType = lrnQuestionTypesENUM.mcq
                             }
+                            if (currQuestionType.includes(lrnQuestionTypesENUM.textEntryMath)) {
+                                currQuestionType = lrnQuestionTypesENUM.textEntryMath
+                            }
                             if (migrationQuestionTypesLrn.includes(currQuestionType)) {
                                 switch (currQuestionType) {
                                     case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcq(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMath(lrnQuestionDataArr, index);
                                     default: throw new Error('Invalid lrn question type');
                                 }
                             }
@@ -93,6 +97,7 @@ if (referenceIds.length > 0) {
                             cy.log(`Verifying data for ${questionType} ${index}`);
                             switch (questionType) {
                                 case 'mcq': return verifyIeQuestionData.mcq(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMath(questionData, index);
                                 default: throw new Error('Invalid ngie question type');
                             }
                         });
@@ -110,6 +115,7 @@ if (referenceIds.length > 0) {
                             if (migrationQuestionTypesLrn.includes(currQuestionType)) {
                                 switch (currQuestionType) {
                                     case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcqGrading(lrnGradingDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMathGrading(lrnGradingDataArr, index);
                                     default: throw new Error('Invalid lrn question type');
                                 }
                             }
@@ -126,6 +132,7 @@ if (referenceIds.length > 0) {
                             cy.log(`Verifying grading data for ${questionType} ${index}`);
                             switch (questionType) {
                                 case 'mcq': return verifyIeQuestionData.mcqGrading(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMathGrading(questionData, index);
                                 default: throw new Error('Invalid ngie question type');
                             }
                         });

package/cypress/e2e/migration/migration2.js

@@ -76,9 +76,13 @@ if (referenceIds.length > 0) {
                             if (lrnMcqTypesRegex.test(currQuestionType)) {
                                 currQuestionType = lrnQuestionTypesENUM.mcq
                             }
+                            if (currQuestionType.includes(lrnQuestionTypesENUM.textEntryMath)) {
+                                currQuestionType = lrnQuestionTypesENUM.textEntryMath
+                            }
                             if (migrationQuestionTypesLrn.includes(currQuestionType)) {
                                 switch (currQuestionType) {
                                     case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcq(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMath(lrnQuestionDataArr, index);
                                     default: throw new Error('Invalid lrn question type');
                                 }
                             }
@@ -93,6 +97,7 @@ if (referenceIds.length > 0) {
                             cy.log(`Verifying data for ${questionType} ${index}`);
                             switch (questionType) {
                                 case 'mcq': return verifyIeQuestionData.mcq(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMath(questionData, index);
                                 default: throw new Error('Invalid ngie question type');
                             }
                         });
@@ -110,6 +115,7 @@ if (referenceIds.length > 0) {
                             if (migrationQuestionTypesLrn.includes(currQuestionType)) {
                                 switch (currQuestionType) {
                                     case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcqGrading(lrnGradingDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMathGrading(lrnGradingDataArr, index);
                                     default: throw new Error('Invalid lrn question type');
                                 }
                             }
@@ -126,6 +132,7 @@ if (referenceIds.length > 0) {
                             cy.log(`Verifying grading data for ${questionType} ${index}`);
                             switch (questionType) {
                                 case 'mcq': return verifyIeQuestionData.mcqGrading(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMathGrading(questionData, index);
                                 default: throw new Error('Invalid ngie question type');
                             }
                         });

package/cypress/e2e/migration/migration3.js

@@ -76,9 +76,13 @@ if (referenceIds.length > 0) {
                             if (lrnMcqTypesRegex.test(currQuestionType)) {
                                 currQuestionType = lrnQuestionTypesENUM.mcq
                             }
+                            if (currQuestionType.includes(lrnQuestionTypesENUM.textEntryMath)) {
+                                currQuestionType = lrnQuestionTypesENUM.textEntryMath
+                            }
                             if (migrationQuestionTypesLrn.includes(currQuestionType)) {
                                 switch (currQuestionType) {
                                     case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcq(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMath(lrnQuestionDataArr, index);
                                     default: throw new Error('Invalid lrn question type');
                                 }
                             }
@@ -93,6 +97,7 @@ if (referenceIds.length > 0) {
                             cy.log(`Verifying data for ${questionType} ${index}`);
                             switch (questionType) {
                                 case 'mcq': return verifyIeQuestionData.mcq(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMath(questionData, index);
                                 default: throw new Error('Invalid ngie question type');
                             }
                         });
@@ -110,6 +115,7 @@ if (referenceIds.length > 0) {
                             if (migrationQuestionTypesLrn.includes(currQuestionType)) {
                                 switch (currQuestionType) {
                                     case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcqGrading(lrnGradingDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMathGrading(lrnGradingDataArr, index);
                                     default: throw new Error('Invalid lrn question type');
                                 }
                             }
@@ -126,6 +132,7 @@ if (referenceIds.length > 0) {
                             cy.log(`Verifying grading data for ${questionType} ${index}`);
                             switch (questionType) {
                                 case 'mcq': return verifyIeQuestionData.mcqGrading(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMathGrading(questionData, index);
                                 default: throw new Error('Invalid ngie question type');
                             }
                         });

package/cypress/e2e/migration/migration4.js

@@ -76,9 +76,13 @@ if (referenceIds.length > 0) {
                             if (lrnMcqTypesRegex.test(currQuestionType)) {
                                 currQuestionType = lrnQuestionTypesENUM.mcq
                             }
+                            if (currQuestionType.includes(lrnQuestionTypesENUM.textEntryMath)) {
+                                currQuestionType = lrnQuestionTypesENUM.textEntryMath
+                            }
                             if (migrationQuestionTypesLrn.includes(currQuestionType)) {
                                 switch (currQuestionType) {
                                     case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcq(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMath(lrnQuestionDataArr, index);
                                     default: throw new Error('Invalid lrn question type');
                                 }
                             }
@@ -93,6 +97,7 @@ if (referenceIds.length > 0) {
                             cy.log(`Verifying data for ${questionType} ${index}`);
                             switch (questionType) {
                                 case 'mcq': return verifyIeQuestionData.mcq(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMath(questionData, index);
                                 default: throw new Error('Invalid ngie question type');
                             }
                         });
@@ -110,6 +115,7 @@ if (referenceIds.length > 0) {
                             if (migrationQuestionTypesLrn.includes(currQuestionType)) {
                                 switch (currQuestionType) {
                                     case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcqGrading(lrnGradingDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMathGrading(lrnGradingDataArr, index);
                                     default: throw new Error('Invalid lrn question type');
                                 }
                             }
@@ -126,6 +132,7 @@ if (referenceIds.length > 0) {
                             cy.log(`Verifying grading data for ${questionType} ${index}`);
                             switch (questionType) {
                                 case 'mcq': return verifyIeQuestionData.mcqGrading(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMathGrading(questionData, index);
                                 default: throw new Error('Invalid ngie question type');
                             }
                         });

package/cypress/e2e/migration/migration5.js

@@ -76,9 +76,13 @@ if (referenceIds.length > 0) {
                             if (lrnMcqTypesRegex.test(currQuestionType)) {
                                 currQuestionType = lrnQuestionTypesENUM.mcq
                             }
+                            if (currQuestionType.includes(lrnQuestionTypesENUM.textEntryMath)) {
+                                currQuestionType = lrnQuestionTypesENUM.textEntryMath
+                            }
                             if (migrationQuestionTypesLrn.includes(currQuestionType)) {
                                 switch (currQuestionType) {
                                     case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcq(lrnQuestionDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMath(lrnQuestionDataArr, index);
                                     default: throw new Error('Invalid lrn question type');
                                 }
                             }
@@ -93,6 +97,7 @@ if (referenceIds.length > 0) {
                             cy.log(`Verifying data for ${questionType} ${index}`);
                             switch (questionType) {
                                 case 'mcq': return verifyIeQuestionData.mcq(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMath(questionData, index);
                                 default: throw new Error('Invalid ngie question type');
                             }
                         });
@@ -110,6 +115,7 @@ if (referenceIds.length > 0) {
                             if (migrationQuestionTypesLrn.includes(currQuestionType)) {
                                 switch (currQuestionType) {
                                     case lrnQuestionTypesENUM.mcq: return extractLrnQuestionData.mcqGrading(lrnGradingDataArr, index);
+                                    case lrnQuestionTypesENUM.textEntryMath: return extractLrnQuestionData.textEntryMathGrading(lrnGradingDataArr, index);
                                     default: throw new Error('Invalid lrn question type');
                                 }
                             }
@@ -126,6 +132,7 @@ if (referenceIds.length > 0) {
                             cy.log(`Verifying grading data for ${questionType} ${index}`);
                             switch (questionType) {
                                 case 'mcq': return verifyIeQuestionData.mcqGrading(questionData, index);
+                                case 'textEntryMath': return verifyIeQuestionData.textEntryMathGrading(questionData, index);
                                 default: throw new Error('Invalid ngie question type');
                             }
                         });

package/cypress/support/commands.js

@@ -33,8 +33,8 @@ Cypress.Commands.add('loginAs', (roleName = 'admin') => {
         var username = `${Cypress.env('admin_username')}`;
         var password = `${Cypress.env('admin_password')}`
     } else if (roleName === 'technicalTester') {
-        var username = `demo-technical-tester`;
-        var password = `SXYeokWOoTuwEg2w`
+        var username = `${Cypress.env('migration_usernme')}`;
+        var password = `${Cypress.env('migration_password')}`
     }
     cy.logout();
     cy.request({
@@ -115,7 +115,7 @@ Cypress.Commands.add('pageLoadWait', (operationName = null) => {
     } else {
         cy.wait(`@${operationName}`);
     }
-    cy.get('.MuiCircularProgress-svg', { timeout: 60000 })
+    cy.get('.MuiCircularProgress-svg')
         .should('not.be.visible');
 });
 

package/cypress/support/migrationHelpers/extractLrnQuestionData.js

@@ -6,6 +6,10 @@ export const lrnPage = {
     mcqOptionContent: () => cy.get('.lrn_contentWrapper'),
     questionsLoader: () => cy.get('.lrn-spinner'),
     showAnswersToggle: () => cy.get('.lrn-author-validate-questions-toggle'),
+    clozeMathResponseWrapper: () => cy.get('.lrn_cloze_response_container'),
+    clozeMathResponse: () => cy.get('.lrn_cloze_response'),
+    clozeMathCorrectAnswerMathMl: () => cy.get('.lrn_correctAnswerList math'),
+    correctAnswersResponseText: () => cy.get('.lrn_responseText'),
     steps: {
         checkShowAnswersToggle: () => {
             lrnPage.showAnswersToggle()
@@ -82,6 +86,109 @@ export const extractLrnQuestionData = {
         lrnGradingDataArr.push(obj);
     },
 
+    singleSelectionGrading: (lrnGradingDataArr, index) => {
+        let obj = {};
+        cy.log(`Extracting the question instructions, options and correct answers from question ${index}`);
+        obj.questionIndex = index;
+        obj.questionType = 'singleSelection'
+        lrnPage.questionWrapper()
+            .eq(index)
+            .within(() => {
+                lrnPage.questionInstructions()
+                    .then(($ins) => {
+                        let text = $ins[0].innerText;
+                        obj.gradingQuestionInstructions = text;
+                    });
+
+                let optionsText = [];
+                let correctAnswersIndex = [];
+                lrnPage.mcqOptionWrapper()
+                    .each(($optionWrapper, index) => {
+                        if ($optionWrapper[0].className.includes('lrn_valid')) {
+                            correctAnswersIndex.push(index)
+                        }
+                        cy.wrap($optionWrapper)
+                            .within(() => {
+                                lrnPage.mcqOptionContent()
+                                    .then(($el) => {
+                                        optionsText.push($el[0].innerText);
+                                    });
+                            });
+                    });
+                obj.gradingOptionsText = optionsText;
+                obj.correctAnswersIndex = correctAnswersIndex;
+            });
+        lrnGradingDataArr.push(obj);
+    },
+
+    textEntryMath: (lrnQuestionDataArr, index) => {
+        let obj = {};
+        cy.log(`Extracting the question instructions, question and response count from question ${index}`);
+        obj.questionIndex = index;
+        obj.questionType = 'textEntryMath';
+        lrnPage.questionWrapper()
+            .eq(index)
+            .within(() => {
+                lrnPage.questionInstructions()
+                    .then(($ins) => {
+                        let text = $ins[0].innerText;
+                        obj.previewQuestionInstructions = text;
+                    });
+                lrnPage.clozeMathResponseWrapper()
+                    .then(($question) => {
+                        let innerText = $question[0].innerText;
+                        obj.previewQuestion = innerText;
+                    });
+                lrnPage.clozeMathResponse()
+                    .then(($responseFields) => {
+                        obj.previewResponseCount = $responseFields.length;
+                    });
+            });
+        lrnQuestionDataArr.push(obj);
+    },
+
+    textEntryMathGrading: (lrnGradingDataArr, index) => {
+        let obj = {};
+        cy.log(`Extracting the question instructions, question, response count and correct responses from question ${index}`);
+        obj.questionIndex = index;
+        obj.questionType = 'textEntryMath';
+        lrnPage.questionWrapper()
+            .eq(index)
+            .within(() => {
+                lrnPage.questionInstructions()
+                    .then(($ins) => {
+                        let text = $ins[0].innerText;
+                        obj.gradingQuestionInstructions = text;
+                    });
+                lrnPage.clozeMathResponseWrapper()
+                    .then(($question) => {
+                        let innerText = $question[0].innerText;
+                        obj.gradingQuestion = innerText;
+                    });
+                lrnPage.clozeMathResponse()
+                    .then(($responseFields) => {
+                        obj.gradingResponseCount = $responseFields.length;
+                    });
+                const correctAnswersMathMl = [];
+                const correctAnswersText = [];
+                lrnPage.clozeMathCorrectAnswerMathMl()
+                    .each(($element) => {
+                        let outerHtml = $element[0].outerHTML;
+                        correctAnswersMathMl.push(outerHtml);
+                    });
+                lrnPage.correctAnswersResponseText()
+                    .each(($element) => {
+                        let innerText = $element[0].innerText;
+                        correctAnswersText.push(innerText);
+                    });
+                obj.correctAnswersMathMl = correctAnswersMathMl;
+                obj.correctAnswersText = correctAnswersText;
+                //extract math outerhtml
+                //extract response text and outer html, verify it with the other one
+            });
+        lrnGradingDataArr.push(obj);
+    },
+
     essayResponseMath: (lrnQuestionDataArr, index) => {
         let obj = {};
         cy.log(`Extracting the question instructions and options from question ${index}`);
@@ -95,7 +202,7 @@ export const extractLrnQuestionData = {
                         let text = $ins[0].innerText;
                         obj.previewQuestionInstructions = text;
                     });
-            })
+            });
         lrnQuestionDataArr.push(obj);
     },
 

package/cypress/support/migrationHelpers/lrnQestionTypesENUM.js

@@ -1,9 +1,10 @@
 const lrnQuestionTypesENUM = {
     mcq: 'mcq',
+    textEntryMath: 'Cloze math',
+    essayResponseMath: 'Math essay with rich text',
     singleSelection: 'Multiple choice – standard',
     multipleSelection: 'Multiple choice – multiple response',
     trueOrFalse: 'True or false',
-    essayResponseMath: 'Math essay with rich text',
 }
 
 export default lrnQuestionTypesENUM;

package/cypress/support/migrationHelpers/verifyIeQuestionData.js

@@ -7,6 +7,10 @@ export const iePage = {
     mcqOptionWrapper: () => cy.get('div[class*="option-wrapper"]'),
     questionWrapper: () => cy.get('.ngie-question-wrapper'),
     barsPreloader: () => cy.get('[id="question-item-instruction-loader"]'),
+    previewQuestionTextWrapper: () => cy.get('.preview-question-text-wrapper'),
+    textEntryMathResponseWrapper: () => cy.get('.preview-question-text-wrapper .cloze-response-wrapper '),
+    textEntryMathCorrectAnswerMathMl: () => cy.get('.ngie_latex math'),
+    textEntryMathCorrectAnswersResponseText: () => cy.get('.ngie_latex'),
 };
 
 export const verifyIeQuestionData = {
@@ -68,7 +72,40 @@ export const verifyIeQuestionData = {
 
 
     textEntryMath: (expectedQuestionData, index) => {
+        cy.get('.cloze-math-preview-wrapper')
+            .eq(index)
+            .within(() => {
+                utilities.verifyInnerText(singleSelectionPage.questionInstructionsText(), expectedQuestionData.previewQuestionInstructions);
+                utilities.verifyInnerText(iePage.previewQuestionTextWrapper(), expectedQuestionData.previewQuestion);
+                iePage.textEntryMathResponseWrapper()
+                    .then(($resposneWrapper) => {
+                        expect($resposneWrapper.length).to.be.eq(expectedQuestionData.previewResponseCount);
+                    });
+            });
+    },
 
+    textEntryMathGrading: (expectedQuestionData, index) => {
+        cy.get('.cloze-math-preview-wrapper')
+            .eq(index)
+            .parents('.ngie-question-wrapper')
+            .within(() => {
+                utilities.verifyInnerText(singleSelectionPage.questionInstructionsText(), expectedQuestionData.gradingQuestionInstructions);
+                iePage.previewQuestionTextWrapper()
+                    .should('exist');
+                // utilities.verifyInnerText(iePage.previewQuestionTextWrapper(), expectedQuestionData.gradingQuestion);
+                iePage.textEntryMathResponseWrapper()
+                    .then(($resposneWrapper) => {
+                        expect($resposneWrapper.length).to.be.eq(expectedQuestionData.gradingResponseCount);
+                    });
+                iePage.textEntryMathCorrectAnswerMathMl()
+                    .each(($element, index) => {
+                        expect($element.get(0).outerHTML).to.deep.eq(expectedQuestionData.correctAnswersMathMl[index]);
+                    });
+                iePage.textEntryMathCorrectAnswersResponseText()
+                    .each(($element, index) => {
+                        utilities.verifyInnerText(cy.wrap($element), expectedQuestionData.correctAnswersText[index]);
+                    });
+            });
     },
 
     essayResponseMath: (expectedQuestionData, index) => {

package/package.json

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