itemengine-cypress-automation 1.0.174 → 1.0.176-figDndMigration-409c782.0

package/cypress/support/migrationHelpers/extractLrnQuestionData.js

@@ -560,7 +560,6 @@ export const extractLrnQuestionData = {
         cy.log(`Extracting the question instructions and answer input field attributes from question ${index}`);
         obj.questionIndex = index;
         obj.questionType = 'shortTextResponse'
-        lrnPage.steps.extractQuestionInstructions(obj, index);
         lrnPage.questionWrapper()
             .eq(index)
             .within(() => {
@@ -577,11 +576,11 @@ export const extractLrnQuestionData = {
                             obj.specialCharactersEnabled = true;
                         }
                     });
-            })
+            });
         lrnQuestionDataArr.push(obj);
     },
 
-    shortTextResponseGrading: (lrnQuestionDataArr, index) => {
+    shortTextResponseGrading: (lrnGradingDataArr, index) => {
         let obj = {};
         cy.log(`Extracting the question instructions and correct answers from question ${index}`);
         obj.questionIndex = index;
@@ -597,7 +596,7 @@ export const extractLrnQuestionData = {
                     });
                 };
             });
-        lrnQuestionDataArr.push(obj);
+        lrnGradingDataArr.push(obj);
     },
 
     uploadResponse: (lrnQuestionDataArr, index) => {
@@ -630,6 +629,150 @@ export const extractLrnQuestionData = {
         lrnQuestionDataArr.push(obj);
     },
 
+    figDragAndDrop: (lrnQuestionDataArr, index) => {
+        let obj = {};
+        cy.log(`Extracting the question instructions, question, response areas count, draggable option container position, drag handle visibility, draggable options from question ${index}`);
+        obj.questionIndex = index;
+        obj.questionType = 'figDragAndDrop';
+        lrnPage.steps.extractQuestionInstructions(obj, index);
+        lrnPage.questionWrapper()
+            .eq(index)
+            .within(() => {
+                lrnPage.questionContainerPreviewTab()
+                    .then(($question) => {
+                        let innerText = $question[0].innerText;
+                        obj.previewQuestion = innerText;
+                    });
+                lrnPage.clozeResponse()
+                    .then(($responseFields) => {
+                        obj.previewResponseCount = $responseFields.length;
+                    });
+                let options = [];
+                let optionImages = [];
+                let optionEquations = [];
+                lrnPage.draggableResponse()
+                    .each(($option, index) => {
+                        let innerText = $option[0].innerText;
+                        options.push(innerText);
+                        let innerHTML = $option[0].innerHTML;
+                        if (innerHTML.includes('<img')) {
+                            lrnPage.draggableResponse()
+                                .eq(index)
+                                .find('img')
+                                .then(($img) => {
+                                    let altText = $img[0].alt;
+                                    optionImages.push(altText);
+                                });
+                        }
+                        if (innerHTML.includes('<math')) {
+                            lrnPage.draggableResponse()
+                                .eq(index)
+                                .find('math')
+                                .then(($element) => {
+                                    let outerHtml = $element[0].outerHTML;
+                                    optionEquations.push(outerHtml);
+                                });
+                        }
+                    });
+                let position;
+                cy.get('.lrn_possibilityList').invoke('attr', 'class').then(classAttribute => {
+                    const classList = classAttribute.split(' ');
+                    if (classList.includes('lrn_list_bottom')) {
+                        position = 'bottom';
+                    } else if (classList.includes('lrn_list_top')) {
+                        position = 'top';
+                    } else if (classList.includes('lrn_list_left')) {
+                        position = 'left'
+                    } else if (classList.includes('lrn_list_right')) {
+                        position = 'right'
+                    } else {
+                        position = null;
+                    }
+                    obj.position = position;
+                });
+                let dragHandleVisibility;
+                lrnPage.draggableResponse().eq(0).invoke('attr', 'class').then(classAttribute => {
+                    const classList = classAttribute.split(' ');
+                    if (classList.includes('lrn_btn_no_handle')) {
+                        dragHandleVisibility = false;
+                    } else {
+                        dragHandleVisibility = true;
+                    }
+                    obj.dragHandleVisibility = dragHandleVisibility;
+                });
+                obj.options = options;
+                obj.optionImages = optionImages;
+                obj.optionEquations = optionEquations;
+            });
+        lrnQuestionDataArr.push(obj);
+    },
+
+    figDragAndDropGrading: (lrnGradingDataArr, index) => {
+        let obj = {};
+        cy.log(`Extracting the question instructions, response area count and correct answers from question ${index}`);
+        obj.questionIndex = index;
+        obj.questionType = 'figDragAndDrop';
+        lrnPage.steps.extractQuestionInstructions(obj, index);
+        lrnPage.questionWrapper()
+            .eq(index)
+            .within(() => {
+                lrnPage.questionContainerPreviewTab()
+                    .then(($question) => {
+                        let innerText = $question[0].innerText;
+                        obj.previewQuestion = innerText;
+                    });
+                lrnPage.clozeResponse()
+                    .then(($responseFields) => {
+                        obj.previewResponseCount = $responseFields.length;
+                    });
+                let correctAnswers = [];
+                //correctAnswer
+                cy.get('.lrn_correctAnswerList li')
+                    .each(($answers) => {
+                        let answerData = {}
+                        cy.wrap($answers)
+                            .within(() => {
+                                cy.get('.lrn_responseIndex')
+                                    .then(($element) => {
+                                        let answerNumeration = $element[0].innerText;
+                                        answerData.answerNumeration = answerNumeration;
+                                    });
+                                let options = []
+                                cy.get('.lrn_responseText')
+                                    .each(($option, index) => {
+                                        let optionData = {}
+                                        let innerText = $option[0].innerText;
+                                        optionData.innerText = innerText;
+                                        let innerHTML = $option[0].innerHTML;
+                                        if (innerHTML.includes('<img')) {
+                                            cy.get('.lrn_responseText')
+                                                .eq(index)
+                                                .find('img')
+                                                .then(($img) => {
+                                                    let altText = $img[0].alt;
+                                                    optionData.altText = altText;
+                                                });
+                                        }
+                                        if (innerHTML.includes('<math')) {
+                                            cy.get('.lrn_responseText')
+                                                .eq(index)
+                                                .find('math')
+                                                .then(($element) => {
+                                                    let outerHtml = $element[0].outerHTML;
+                                                    optionData.equation = outerHtml;
+                                                });
+                                        }
+                                        options.push(optionData);
+                                    });
+                                answerData.options = options
+                            });
+                        correctAnswers.push(answerData);
+                    });
+                obj.correctAnswers = correctAnswers;
+            });
+        lrnGradingDataArr.push(obj);
+    }
+
     /*     singleSelection: (lrnQuestionDataArr, index) => {
             let obj = {};
             cy.log(`Extracting the question instructions and options from question ${index}`);

package/cypress/support/migrationHelpers/lrnQestionTypesENUM.js

@@ -11,7 +11,8 @@ const lrnQuestionTypesENUM = {
     trueOrFalse: 'True or false',
     figText: 'Cloze with text',
     shortTextResponse: 'Short text',
-    uploadResponse: 'File upload'
+    uploadResponse: 'File upload',
+    figDragAndDrop: 'Cloze with drag & drop',
 }
 
 export default lrnQuestionTypesENUM;

package/cypress/support/migrationHelpers/migrationScript.js

@@ -26,6 +26,7 @@ const extractLrnPreviewData = (currQuestionType, lrnQuestionDataArr, index) => {
         case lrnQuestionTypesENUM.figText: return extractLrnQuestionData.figText(lrnQuestionDataArr, index);
         case lrnQuestionTypesENUM.shortTextResponse: return extractLrnQuestionData.shortTextResponse(lrnQuestionDataArr, index);
         case lrnQuestionTypesENUM.uploadResponse: return extractLrnQuestionData.uploadResponse(lrnQuestionDataArr, index);
+        case lrnQuestionTypesENUM.figDragAndDrop: return extractLrnQuestionData.figDragAndDrop(lrnQuestionDataArr, index);
         default: throw new Error('Invalid lrn question type');
     }
 }
@@ -42,6 +43,7 @@ const verifyIePreviewData = (questionType, questionData, index) => {
         case 'figText': return verifyIeQuestionData.figText(questionData, index);
         case 'shortTextResponse': return verifyIeQuestionData.shortTextResponse(questionData, index);
         case 'uploadResponse': return verifyIeQuestionData.uploadResponse(questionData, index);
+        case 'figDragAndDrop': return verifyIeQuestionData.figDragAndDrop(questionData, index);
         default: throw new Error('Invalid ngie question type');
     }
 }
@@ -55,6 +57,7 @@ const extractLrnGradingData = (currQuestionType, lrnGradingDataArr, index) => {
         case lrnQuestionTypesENUM.figText: return extractLrnQuestionData.figTextGrading(lrnGradingDataArr, index);
         case lrnQuestionTypesENUM.shortTextResponse: return extractLrnQuestionData.shortTextResponseGrading(lrnGradingDataArr, index);
         case lrnQuestionTypesENUM.uploadResponse: return cy.log('Manually Graded Question Type');
+        case lrnQuestionTypesENUM.figDragAndDrop: return extractLrnQuestionData.figDragAndDropGrading(lrnGradingDataArr, index);
         default: throw new Error('Invalid lrn question type');
     }
 }
@@ -68,6 +71,7 @@ const verifyIeGradingData = (questionType, questionData, index) => {
         case 'figText': return verifyIeQuestionData.figTextGrading(questionData, index);
         case 'shortTextResponse': return verifyIeQuestionData.shortTextResponseGrading(questionData, index);
         case 'uploadResponse': return cy.log('Manually Graded Question Type');
+        case 'figDragAndDrop': return verifyIeQuestionData.figDragAndDropGrading(questionData, index);
         default: throw new Error('Invalid ngie question type');
     }
 }

package/cypress/support/migrationHelpers/verifyIeQuestionData.js

@@ -1,5 +1,5 @@
-import { essayResponsePage, fillInTheGapsTextPage, multipleSelectionPage, textEntryMathPage, uploadResponsePage } from "../../pages";
-import { draggableOptionContainer } from "../../pages/components";
+import { essayResponsePage, fillInTheGapsDragAndDropPage, fillInTheGapsTextPage, multipleSelectionPage, textEntryMathPage, uploadResponsePage } from "../../pages";
+import { draggableOptionContainer, fillInTheGapsDragAndDropCommonComponents } from "../../pages/components";
 import { singleSelectionPage } from "../../pages/singleSelectionPage"
 import utilities from "../helpers/utilities";
 import drawingToolbarOptionsENUM from "./drawingToolbarOptionsENUM";
@@ -556,7 +556,7 @@ export const verifyIeQuestionData = {
                     });
                 } else {
                     utilities.verifyElementVisibilityState(iePage.shortTextResponseCorrectAnswerText(), 'notExist');
-                }
+                };
             });
     },
 
@@ -593,6 +593,125 @@ export const verifyIeQuestionData = {
                         });
                 }
             });
+    },
+
+    figDragAndDrop: (expectedQuestionData, index) => {
+        cy.get('.ngie-cloze-with-drag-and-drop')
+            .eq(index)
+            .within(() => {
+                iePage.steps.verifyQuestionInstructions(expectedQuestionData);
+                /* fillInTheGapsDragAndDropPage.questionContainerPreviewTab()
+                    .then(($question) => {
+                        let innerText = $question[0].innerText;
+                        expect(expectedQuestionData.previewQuestion).to.be.eq(innerText);
+                    });
+                fillInTheGapsDragAndDropPage.dropzonePreviewTab()
+                    .then(($resposneWrapper) => {
+                        expect($resposneWrapper.length).to.be.eq(expectedQuestionData.previewResponseCount);
+                    }); */
+                let position;
+                cy.get('.preview-container-split-view').invoke('attr', 'class').then(classAttribute => {
+                    const classList = classAttribute.split(' ');
+                    if (classList.includes('placement-bottom')) {
+                        position = 'bottom';
+                    } else if (classList.includes('placement-top')) {
+                        position = 'top';
+                    } else if (classList.includes('placement-left')) {
+                        position = 'left'
+                    } else if (classList.includes('placement-right')) {
+                        position = 'right'
+                    } else {
+                        position = null;
+                    }
+                }).then(() => {
+                    expect(position).to.be.eq(expectedQuestionData.position);
+                });
+                if (expectedQuestionData.dragHandleVisibility) {
+                    draggableOptionContainer.draggableOption()
+                        .eq(0)
+                        .within(() => {
+                            utilities.verifyElementVisibilityState(draggableOptionContainer.draggableOptionDragIcon(), 'exist');
+                        });
+                }
+                let options = [];
+                draggableOptionContainer.draggableOption()
+                    .each(($option) => {
+                        let innerText = $option[0].innerText;
+                        options.push(innerText);
+                    }).then(() => {
+                        expect(options).to.have.deep.members(expectedQuestionData.options);
+                    });
+                if (expectedQuestionData.optionEquations.length > 0) {
+                    let optionEquations = [];
+                    draggableOptionContainer.draggableOption()
+                        .find('math')
+                        .each(($math) => {
+                            optionEquations.push($math.get(0).outerHTML);
+                        }).then(() => {
+                            expect(optionEquations).to.have.deep.members(expectedQuestionData.optionEquations);
+                        });
+                }
+                if (expectedQuestionData.optionImages.length > 0) {
+                    let optionImages = [];
+                    draggableOptionContainer.draggableOption()
+                        .find('img')
+                        .each(($img) => {
+                            optionImages.push($img.get(0).alt);
+                        }).then(() => {
+                            expect(optionImages).to.have.deep.members(expectedQuestionData.optionImages);
+                        });
+                }
+            });
+    },
+
+    figDragAndDropGrading: (expectedQuestionData, index) => {
+        cy.get('.ngie-cloze-with-drag-and-drop')
+            .eq(index)
+            .within(() => {
+                iePage.steps.verifyQuestionInstructions(expectedQuestionData);
+                /* fillInTheGapsTextPage.questionContainerPreviewTab()
+                    .then(($question) => {
+                        let innerText = $question[0].innerText;
+                        expect(expectedQuestionData.previewQuestion).to.be.eq(innerText);
+                    });
+                fillInTheGapsDragAndDropPage.dropzonePreviewTab()
+                    .then(($resposneWrapper) => {
+                        expect($resposneWrapper.length).to.be.eq(expectedQuestionData.previewResponseCount);
+                    }); */
+                fillInTheGapsDragAndDropCommonComponents.correctAnswersOptions()
+                    .then(($answerWrapper) => {
+                        expect($answerWrapper.length).to.be.eq(expectedQuestionData.correctAnswers.length);
+                    });
+                expectedQuestionData.correctAnswers.forEach((correctAnswerData, index) => {
+                    iePage.figCorrectAnswerBlock()
+                        .eq(index)
+                        .within(() => {
+                            cy.get('.answer-numeration-number-box')
+                                .then(($answerNumeration) => {
+                                    expect($answerNumeration[0].innerText).to.be.eq(correctAnswerData.answerNumeration);
+                                });
+                            cy.get('.question-text-wrapper').then(($answerOption) => {
+                                expect($answerOption[0].innerText).to.be.eq(correctAnswerData.options[0].innerText);
+                                if (correctAnswerData.equation) {
+                                    cy.get('.question-text-wrapper')
+                                        .eq(index)
+                                        .find('math')
+                                        .then(($math) => {
+                                            expect($math[0].outerHTML).to.be.eq(correctAnswerData.equation);
+                                        });
+                                }
+                                if (correctAnswerData.altText) {
+                                    cy.get('.question-text-wrapper')
+                                        .eq(index)
+                                        .find('img')
+                                        .then(($img) => {
+                                            expect($img[0].alt).to.be.eq(correctAnswerData.altText);
+                                        });
+                                }
+                            });
+                        });
+                });
+            });
     }
 
     /*     singleSelection: (expectedQuestionData, index) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itemengine-cypress-automation",
-  "version": "1.0.174",
+  "version": "1.0.176-figDndMigration-409c782.0",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -35,4 +35,4 @@
     "node-fetch": "^3.3.2",
     "react-uuid": "^2.0.0"
   }
-}
+}