itemengine-cypress-automation 1.0.145-equationAndCheckAnswerSeelctorUpdate-b61f46e.0 → 1.0.145

package/cypress/pages/matchingPage.js

@@ -0,0 +1,433 @@
+import constants from "../fixtures/constants";
+import utilities from "../support/helpers/utilities";
+import { createQuestionBasePage, questionInstructionsComponent, autoScoredScoringPreviewTab, scoringSectionBaseEditTab, draggableOptionContainer, draggableOptionsSectionComponent, correctIncorrectAnswerLabelComponent, maximumCapacityPerDropzoneComponent, optionsWrapperComponent, ckEditorToolbar, equationEditorFlyout, autoScoredStudentViewSettings, autoScoredSpecifyCorrectAnswerSection, commonComponents } from "./components";
+import { dialogBoxBase } from "./dialogBoxBase";
+const css = Cypress.env('css');
+
+const selectors = {
+    ...correctIncorrectAnswerLabelComponent,
+    ...questionInstructionsComponent,
+    ...commonComponents,
+    ...autoScoredScoringPreviewTab,
+    //Edit tab
+    promptInputField: () => cy.get('.edit-mcq-stems-wrapper [role="textbox"]'),
+    optionInputField: () => cy.get('.edit-mcq-options-wrapper').eq(1).find('[data-rbd-draggable-id*="option-draggable"] [role="textbox"]'),
+    //Specify correct answer section
+    dropzoneSpecifyCorrectAnswerSection: () => cy.get('.authoring-droppable-hotspot-wrapper'),
+
+    //Preview tab
+    promptContainerPreviewTab: () => cy.get('.stem-container'),
+    dropzonePreviewTab: () => cy.get('[class*="MultipleDroppableHotspotstyle__DroppableHotspotWrapper"]'),
+    dropzoneOptionPreviewTab: () => cy.get('[class*="MultipleDroppedItemstyles__FlexWrapper"]'),
+    dropzoneNumeration: () => cy.get('[class*="NumerationDiv"]'),
+    correctAnswersNumeration: () => cy.get('.answer-numeration-number-box'),
+    correctAnswersOptions: () => cy.get('.match-list-drag-and-drop .question-text-wrapper'),
+    correctAnswersOptionContainer: () => cy.get('.draggable-selected-option'),
+    correctIncorrectAnswerLabel: () => cy.get('[class*="AnswerStatusText"]')
+}
+
+const steps = {
+    ...createQuestionBasePage.steps,
+    ...scoringSectionBaseEditTab.steps,
+    ...autoScoredScoringPreviewTab.steps,
+    ...questionInstructionsComponent.steps,
+    ...maximumCapacityPerDropzoneComponent.steps,
+    ...optionsWrapperComponent.steps,
+    ...correctIncorrectAnswerLabelComponent.steps,
+    ...ckEditorToolbar.steps,
+    ...equationEditorFlyout.steps,
+    ...autoScoredStudentViewSettings.steps,
+    ...autoScoredSpecifyCorrectAnswerSection.steps,
+    //Edit tab
+    /**
+    * Enters text into multiple prompt input fields.
+    * @param {string[]} promptTextArray - Array of text to enter into the prompt input fields.
+    */
+    enterTextInPromptInputField: (promptTextArray) => {
+        promptTextArray.forEach((promptText, index) => {
+            matchingPage.promptInputField()
+                .eq(index)
+                .clear()
+                .type(promptText)
+                .should('have.text', promptText);
+        });
+    },
+
+    /**
+     * This function enters text in an option
+     * @param {number} index of prompt
+     * @param {text} options to be entered in prompt field
+     */
+    enterTextInOnePromptInputField: (index, promptText) => {
+        matchingPage.promptInputField()
+            .eq(index)
+            .type(promptText);
+    },
+
+    /**
+     * @param {number} index of the option input field
+     * @description this function focuses in and out of prompt input fields
+     */
+    focusInPromptInputField: (index) => {
+        matchingPage.promptInputField()
+            .eq(index)
+            .click();
+    },
+
+    /**
+     * @param {number} index of the option input field
+     * @param {string} option input text
+     * @description this function add input to prompt input fields
+     */
+    addBoldTextInputToPromptInputField: (index) => {
+        matchingPage.promptInputField()
+            .eq(index)
+            .type('This is a bold option')
+            .should('have.text', '​​​​​​​This is a bold option');
+    },
+
+    /**
+     * @param {number} index of option
+     * @description this function verifies bold text in prompt input fields
+     */
+    verifyBoldPrompt: (index) => {
+        matchingPage.promptInputField()
+            .eq(index)
+            .find('strong')
+            .should('exist')
+            .should('have.text', '​​​​​​​This is a bold option');
+    },
+
+
+    /**
+     * Enters text into multiple options input fields.
+     * @param {string[]} promptTextArray - Array of text to enter into the option input fields.
+     */
+    enterTextInOptionInputField: (optionsArray) => {
+        optionsArray.forEach((options, index) => {
+            matchingPage.optionInputField()
+                .eq(index)
+                .clear()
+                .type(options)
+                .should('have.text', options);
+        });
+    },
+
+    /**
+     * This function enters text in an option
+     * @param {number} index of option
+     * @param {text} options to be entered in option field
+     */
+    enterTextInOneOptionInputField: (index, options) => {
+        matchingPage.optionInputField()
+            .eq(index)
+            .type(options);
+    },
+
+    /**
+     * @param {number} index of the option input field
+     * @description this function focuses in and out of options input fields
+     */
+    focusInOptionsInputField: (index) => {
+        matchingPage.optionInputField()
+            .eq(index)
+            .click();
+    },
+
+    /**
+     * @param {number} index of the option input field
+     * @param {string} option input text
+     * @description this function add input to options input fields
+     */
+    addBoldTextInputToOptionsInputField: (index) => {
+        matchingPage.optionInputField()
+            .eq(index)
+            .type('This is a bold option')
+            .should('have.text', '​​​​​​​This is a bold option');
+    },
+
+    /**
+     * @param {number} index of option
+     * @description this function verifies bold text in options input fields
+     */
+    verifyBoldOption: (index) => {
+        matchingPage.optionInputField()
+            .eq(index)
+            .find('strong')
+            .should('exist')
+            .should('have.text', '​​​​​​​This is a bold option');
+    },
+
+    //Specify correct answer section
+    /**
+    * Enter text in the answer input fields of the specify correct answer section.
+    * @param {Object[]} options - An array of objects containing the optionText and dropzoneIndex.
+    * @param {string} options[].optionText - The text of the draggable option.
+    * @param {number} options[].dropzoneIndex - The index of the dropzone.
+    */
+    clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection: (options) => {
+        options.forEach(({ optionText, dropzoneIndex }) => {
+            draggableOptionContainer.draggableOption()
+                .contains(optionText)
+                .click();
+            matchingPage.dropzoneSpecifyCorrectAnswerSection()
+                .eq(dropzoneIndex)
+                .click({ force: true });
+        });
+    },
+
+    //Preview tab
+    /**
+    * Enter text in the answer input fields of the specify correct answer section.
+    * @param {Object[]} options - An array of objects containing the optionText and dropzoneIndex.
+    * @param {string} options[].optionText - The text of the draggable option.
+    * @param {number} options[].dropzoneIndex - The index of the dropzone.
+    */
+    clickAndDropOptionInDropzonePreviewTab: (options) => {
+        options.forEach(({ optionText, dropzoneIndex }) => {
+            draggableOptionContainer.optionsContainerPreviewTab()
+                .eq(0)
+                .within(() => {
+                    draggableOptionContainer.draggableOption()
+                        .contains(optionText)
+                        .click();
+                });
+            matchingPage.dropzonePreviewTab()
+                .eq(dropzoneIndex)
+                .click({ force: true });
+        });
+    },
+
+    /**
+    * Verifies the text content of a dropzone in the Preview Tab.
+    * @param {number} dropzoneIndex - Index of the dropzone to verify.
+    * @param {string} dropzoneText - Expected text content of the dropzone.
+    */
+    verifyDropzoneTextContentPreviewTab: (dropzoneIndex, dropzoneText) => {
+        utilities.verifyInnerText(utilities.getNthElement(matchingPage.dropzonePreviewTab(), dropzoneIndex), dropzoneText);
+    },
+
+    /**
+    * @description Verifies the text content of a specific preview tab dropzone element.
+    * @param {number} count - The index of the preview tab dropzone element to verify (zero-based).
+    * @param {string} text - The expected text content to match against the inner text of the specified dropzone element.
+    */
+    verifyDropzoneContainsTextPreviewTab: (count, text) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(count)
+            .contains(text);
+    },
+
+    /**
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyDraggableOptionWithEquationTextInPreviewTab: (optionIndex) => {
+        matchingPage.dropzonePreviewTab()
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+        utilities.verifyElementVisibilityState(utilities.getNthElement(draggableOptionContainer.draggableOptionDragIcon(), optionIndex), 'exist');
+    },
+
+    /**
+     * @description Verifies that the image in the Preview tab has the correct source and alt text.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyDropzoneWithImageInPreviewTab: (optionIndex) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(optionIndex)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    /**
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyDropzoneWithEquationTextInPreviewTab: (optionIndex) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(optionIndex)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    /**
+    * @description Verifies that the image in the Preview tab has the correct source and alt text.
+    * @param {number} optionIndex - The index of the option in the Preview tab.
+    */
+    verifyDraggableOptionWithImageInPreviewTab: (optionIndex) => {
+        matchingPage.correctAnswersOptionContainer()
+            .eq(optionIndex)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+        utilities.verifyElementVisibilityState(utilities.getNthElement(draggableOptionContainer.draggableOptionDragIcon(), optionIndex), 'exist');
+    },
+
+    /**
+     * @description Verifies that the bold text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyDraggableOptionWithBoldTextInPreviewTab: (optionIndex) => {
+        matchingPage.correctAnswersOptionContainer()
+            .eq(optionIndex)
+            .find('strong')
+            .should('have.text', 'This is a bold option');
+        utilities.verifyElementVisibilityState(utilities.getNthElement(draggableOptionContainer.draggableOptionDragIcon(), optionIndex), 'exist');
+    },
+
+    /**
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyDraggableOptionWithEquationTextInPreviewTab: (optionIndex) => {
+        matchingPage.correctAnswersOptionContainer()
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+        utilities.verifyElementVisibilityState(utilities.getNthElement(draggableOptionContainer.draggableOptionDragIcon(), optionIndex), 'exist');
+    },
+
+    /**
+    * @description Verifies that the image in the Preview tab has the correct source and alt text.
+    * @param {number} optionIndex - The index of the option in the Preview tab.
+    */
+    verifyPromptWithImageInPreviewTab: (optionIndex) => {
+        matchingPage.promptContainerPreviewTab()
+            .eq(optionIndex)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    /**
+     * @description Verifies that the bold text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyPromptWithBoldTextInPreviewTab: (optionIndex) => {
+        matchingPage.promptContainerPreviewTab()
+            .eq(optionIndex)
+            .find('strong')
+            .should('have.text', 'This is a bold option');
+    },
+
+    /**
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyPromptWithEquationTextInPreviewTab: (optionIndex) => {
+        matchingPage.promptContainerPreviewTab()
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    verifyDropzoneNumeration: () => {
+        matchingPage.dropzonePreviewTab()
+            .each(($element, index) => {
+                cy.wrap($element)
+                    .within(() => {
+                        matchingPage.dropzoneNumeration()
+                            .should('have.text', `${index + 1}`)
+                    });
+            });
+    },
+
+    /**
+    * Verifies the correct option icon for a specified dropzone in the Preview Tab.
+    * @param {number} dropzoneIndex - The index of the dropzone to verify.
+    * @param {number} optionIndex - The index of the option to verify.
+    */
+    verifyCorrectOptionIcon: (dropzoneIndex, optionIndex = 0) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(dropzoneIndex)
+            .within(() => {
+                matchingPage.dropzoneOptionPreviewTab()
+                    .eq(optionIndex)
+                    .within(() => {
+                        utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'exist');
+                    });
+            });
+    },
+
+    /**
+    * @description Verifies the incorrect option icon for a specified dropzone in the Preview Tab.
+    * @param {number} dropzoneIndex - The index of the dropzone to verify.
+    * @param {number} optionIndex - The index of the option to verify.
+    */
+    verifyIncorrectOptionIcon: (dropzoneIndex, optionIndex = 0) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(dropzoneIndex)
+            .within(() => {
+                matchingPage.dropzoneOptionPreviewTab()
+                    .eq(optionIndex)
+                    .within(() => {
+                        utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'exist');
+                    });
+            });
+    },
+
+    /**
+    * @description Verifies the absence of a correct/incorrect option icon for a specified option in the Preview Tab.
+    * @param {number} optionIndex - The index of the option to verify.
+    */
+    verifyCorrectIncorrectIconNotExist: (optionIndex) => {
+        matchingPage.dropzonePreviewTab()
+            .eq(optionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'notExist');
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'notExist');
+            });
+    },
+
+    /**
+    *@description Verifies the correctness of answer responses in the correct answer section, including the count.
+    * @param {string[][]} correctAnswerArray An array of arrays, each containing the expected answer options for a specific correct answer section.        
+    */
+    verifyCorrectAnswerResponsesInCorrectAnswerSectionAndCount: (correctAnswerArray) => {
+        utilities.verifyElementCount(matchingPage.correctAnswersOptions(), correctAnswerArray.length);
+        correctAnswerArray.forEach((correctAnswer, index) => {
+            utilities.verifyTextContent(utilities.getNthElement(matchingPage.correctAnswersNumeration(), index), index + 1);
+            correctAnswer.forEach((answerOption) => {
+                utilities.verifyTextContent(utilities.getNthElement(matchingPage.correctAnswersOptions(), index), answerOption);
+            });
+        });
+    },
+
+    /**
+    * @param {("correct" | "incorrect")} answerStatus - The status of the answer.
+    * @description Verifies the visibility and content of the correct/incorrect answer label block.
+    * If the answer is correct, it also verifies the visibility of the correct icon; otherwise, it verifies the visibility of the incorrect icon.
+    */
+    verifyCorrectIncorrectAnswerLabel: (answerStatus) => {
+        utilities.verifyElementVisibilityState(matchingPage.correctIncorrectAnswerLabel(), 'exist');
+        utilities.verifyInnerText(matchingPage.correctIncorrectAnswerLabel(), `Your answer is\n${answerStatus}`)
+        if (answerStatus === 'correct') {
+            utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'visible');
+        } else {
+            utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'visible');
+        }
+    },
+
+    verifyCorrectAnswerSectionNotExists: () => {
+        utilities.verifyElementVisibilityState(matchingPage.correctAnswersOptions(), 'notExist');
+    },
+
+    verifyGradingViewOptionDisabled: () => {
+        matchingPage.correctAnswersOptionContainer()
+            .should('have.css', 'pointer-events', 'none');
+    }
+}
+
+const tests = {
+    ...autoScoredScoringPreviewTab.tests,
+}
+
+export const matchingPage = {
+    ...selectors,
+    steps,
+    tests
+}

package/cypress/pages/multipleSelectionGridPage.js

@@ -1,11 +1,13 @@
 import utilities from "../support/helpers/utilities";
-import { createQuestionBasePage, questionInstructionsComponent, gridQuestionCommonComponent, scoringSectionBaseEditTab, autoScoredScoringPreviewTab, correctIncorrectAnswerLabelComponent } from "./components";
+import { createQuestionBasePage, questionInstructionsComponent, gridQuestionCommonComponent, scoringSectionBaseEditTab, autoScoredScoringPreviewTab, correctIncorrectAnswerLabelComponent, autoScoredStudentViewSettings, specifyRowsAndColumnsComponent, autoScoredSpecifyCorrectAnswerSection, autoScoredScoringSectionMultiResponseType } from "./components";
 const css = Cypress.env('css');
 
 const selectors = {
     ...questionInstructionsComponent,
     ...gridQuestionCommonComponent,
-    ...correctIncorrectAnswerLabelComponent
+    ...correctIncorrectAnswerLabelComponent,
+    ...autoScoredSpecifyCorrectAnswerSection,
+    ...autoScoredScoringSectionMultiResponseType,
 }
 
 const steps = {
@@ -15,6 +17,10 @@ const steps = {
     ...scoringSectionBaseEditTab.steps,
     ...autoScoredScoringPreviewTab.steps,
     ...correctIncorrectAnswerLabelComponent.steps,
+    ...autoScoredStudentViewSettings.steps,
+    ...specifyRowsAndColumnsComponent.steps,
+    ...autoScoredSpecifyCorrectAnswerSection.steps,
+    ...autoScoredScoringSectionMultiResponseType.steps,
     /**
      * Modifies the property of an option cell in the grid for checkbox settings.
      * @param {Object} position - The position of the option cell.
@@ -103,7 +109,9 @@ const steps = {
 
 const tests = {
     ...questionInstructionsComponent.tests,
-    ...autoScoredScoringPreviewTab.tests
+    ...autoScoredScoringPreviewTab.tests,
+    ...scoringSectionBaseEditTab.tests,
+    ...autoScoredScoringSectionMultiResponseType.tests
 }
 
 export const multipleSelectionGridPage = {

package/cypress/pages/singleSelectionGridPage.js

@@ -1,5 +1,5 @@
 import utilities from "../support/helpers/utilities";
-import { createQuestionBasePage, questionInstructionsComponent, gridQuestionCommonComponent, scoringSectionBaseEditTab, ckEditorToolbar, equationEditorFlyout, autoScoredScoringPreviewTab, correctIncorrectAnswerLabelComponent } from "./components";
+import { createQuestionBasePage, questionInstructionsComponent, gridQuestionCommonComponent, scoringSectionBaseEditTab, ckEditorToolbar, equationEditorFlyout, autoScoredScoringPreviewTab, correctIncorrectAnswerLabelComponent, autoScoredStudentViewSettings } from "./components";
 const css = Cypress.env('css');
 
 const selectors = {
@@ -19,6 +19,7 @@ const steps = {
     ...equationEditorFlyout.steps,
     ...autoScoredScoringPreviewTab.steps,
     ...correctIncorrectAnswerLabelComponent.steps,
+    ...autoScoredStudentViewSettings.steps,
     /**
      * Modifies the property of an option cell in the grid for radio button settings.
      * @param {Object} position - The position of the option cell.

package/cypress/pages/textEntryMathPage.js

@@ -651,6 +651,11 @@ const steps = {
         utilities.verifyTextContent(utilities.getNthElement(textEntryMathPage.responseFieldPreviewTab(), index), inputFieldText);
     },
 
+    verifyResponseAreaContainsTextPreviewTab: (index, inputFieldText) => {
+        utilities.getNthElement(textEntryMathPage.responseFieldPreviewTab(), index)
+            .contains(inputFieldText);
+    },
+    
     /**
     *@description Verifies the correctness of answer responses in the correct answer section, including the count.
     * @param {string[]} correctAnswerArray An array of arrays, each containing the expected answer options for a specific correct answer section.

package/cypress/pages/textEntryMathWithImagePage.js

@@ -14,7 +14,7 @@ const selectors = {
     responseFieldPreviewTab: () => cy.get('.cloze-math-background-preview .equation-input-without-andornment'),
     canvasInPreviewTab: () => cy.get('[class*="PreviewTabstyles__ContentWrapper"] .image-container'),
     textAreaPreviewTab: () => cy.get('.label-image-with-text-preview [class*="TextBoxContainer"]'),
-    tickIcon: () => cy.get('.tick-icon-wrapper [data-name*="Rectangle"]'),
+    tickIcon: () => cy.get('.add-background-tick-icon-wrapper [data-name*="Rectangle"]'),
     responseFieldWrapperPreviewTab: () => cy.get('.cloze-response-wrapper'),
     responseFieldNumerationPreviewTab: () => cy.get('.image-container .response-input-adornment')
 }
@@ -129,6 +129,11 @@ const steps = {
         utilities.verifyTextContent(utilities.getNthElement(textEntryMathWithImagePage.responseFieldPreviewTab(), index), inputFieldText);
     },
 
+    verifyResponseAreaContainsTextPreviewTab: (index, inputFieldText) => {
+        utilities.getNthElement(textEntryMathWithImagePage.responseFieldPreviewTab(), index)
+            .contains(inputFieldText);
+    },
+
     /**
      * This function verifies the aria label entered in the response field 
      * @param {string} ariaLabel of the equation entered

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itemengine-cypress-automation",
-  "version": "1.0.145-equationAndCheckAnswerSeelctorUpdate-b61f46e.0",
+  "version": "1.0.145",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -35,4 +35,4 @@
     "node-fetch": "^3.3.2",
     "react-uuid": "^2.0.0"
   }
-}
+}