itemengine-cypress-automation 1.0.2

package/cypress/pages/multipleSelectionGridPage.js

@@ -0,0 +1,359 @@
+import { additionalSettingsPanel, autoScoredAdditionalSettings, autoScoredPreviewBase, autoScoredScoringSection, autoScoredScoringSectionMultipleResponsesType, autoScoredSetCorrectAnswerSection, commonComponents, createQuestionBasePage, previewScoringAndShowCorrectAnswerComponent, questionInstructionsComponent, scoringSectionBase } from "./components"
+import { gridCommonComponents } from "./components/gridCommonComponents"
+import { studentResponseAndLayoutComponent } from "./components/studentResponseAreaAndLayoutComponent";
+const css = Cypress.env('css');
+
+const selectors = {
+    ...commonComponents,
+    ...gridCommonComponents,
+    ...autoScoredSetCorrectAnswerSection,
+    ...scoringSectionBase,
+    ...autoScoredScoringSectionMultipleResponsesType,
+    ...autoScoredAdditionalSettings,
+    ...previewScoringAndShowCorrectAnswerComponent,
+    ...autoScoredPreviewBase,
+    ...questionInstructionsComponent,
+    ...additionalSettingsPanel,
+    optionsCheckbox: () => cy.get('.choice-option-radio-button input'),
+    optionsCheckboxWrapper: () => cy.get('.single-selection-grid-radio-label-wrapper'),
+    pointsPerResponseLabel: () => cy.get('[class*="indexstyles__PartialDifferentPointsHeader"]'),
+    partialEqualWeightsPointsPerResponseScore: () => cy.get('[class*="indexstyles__PartialPointsDiv"]')
+}
+
+const steps = {
+    ...createQuestionBasePage.steps,
+    ...questionInstructionsComponent.steps,
+    ...autoScoredSetCorrectAnswerSection.steps,
+    ...scoringSectionBase.steps,
+    ...gridCommonComponents.steps,
+    ...commonComponents.steps,
+    ...autoScoredScoringSectionMultipleResponsesType.steps,
+    ...additionalSettingsPanel.steps,
+    ...previewScoringAndShowCorrectAnswerComponent.steps,
+    ...autoScoredAdditionalSettings.steps,
+    ...autoScoredPreviewBase.steps,
+    ...autoScoredScoringSection.steps,
+    /**
+     * @param {number} questionStemIndex index of question stem
+     * @param {string[]} optionsArray array of options
+     * @description This function checkmarks the options in a question stem the set correct answer table
+     */
+    setAnswersForQuestionStemInSetCorrectAnswerTable: (questionStemIndex, optionsArray) => {
+        gridCommonComponents.setCorrectAnswerTableRow()
+            .eq(questionStemIndex)
+            .within(() => {
+                optionsArray.forEach((options) => {
+                    multipleSelectionGridPage.optionsCheckbox()
+                        .eq(options)
+                        .click()
+                        .should('be.checked');
+                });
+            });
+    },
+
+    /**
+     * @param {number[][]} optionIndexInQuestionStemRow array of options to be selected for all question stems
+     * @description This function checkmarks all the options in the set correct answer table
+      */
+    setAnswersForAllQuestionStemsInSetCorrectAnswerTable: (optionsArrayForQuestionStem) => {
+        optionsArrayForQuestionStem.forEach((options, questionStemIndex) => {
+            steps.setAnswersForQuestionStemInSetCorrectAnswerTable(questionStemIndex, options);
+        });
+    },
+
+    /**
+     * @param {number} questionStemIndex index of question stem
+     * @param {string[]} optionsArray array of options
+     * @description This function checkmarks the options in a question stem the preview tab answer table
+     */
+    setAnswersForQuestionStemInPreviewTabAnswerTable: (questionStemIndex, optionsArray) => {
+        gridCommonComponents.previewTabAnswerTableRow()
+            .eq(questionStemIndex)
+            .within(() => {
+                optionsArray.forEach((options) => {
+                    multipleSelectionGridPage.optionsCheckbox()
+                        .eq(options)
+                        .click()
+                        .should('be.checked');
+                });
+            });
+    },
+
+    /**
+     * @param {number[][]} optionIndexInQuestionStemRow array of options to be selected for all question stems
+     * @description This function checkmarks all the options in the set correct answer table
+      */
+    setAnswersForAllQuestionStemsInPreviewTabAnswerTable: (optionsArrayForQuestionStem) => {
+        optionsArrayForQuestionStem.forEach((optionsArray, questionStemIndex) => {
+            multipleSelectionGridPage.steps.setAnswersForQuestionStemInPreviewTabAnswerTable(questionStemIndex, optionsArray)
+        });
+    },
+
+    verifyTableRowCheckboxesInSetCorrectAnswerTable: (rowIndex, checkboxesCount) => {
+        gridCommonComponents.setCorrectAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                multipleSelectionGridPage.optionsCheckbox()
+                    .should('have.length', checkboxesCount)
+            });
+    },
+
+    verifyTableRowCheckboxesInPreviewTabAnswerTable: (rowIndex, checkboxesCount) => {
+        gridCommonComponents.previewTabAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                multipleSelectionGridPage.optionsCheckbox()
+                    .should('have.length', checkboxesCount)
+            });
+    },
+
+    verifyDisabledTableRowCheckboxesInSetCorrectAnswerTable: (rowIndex) => {
+        gridCommonComponents.setCorrectAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                multipleSelectionGridPage.optionsCheckbox()
+                    .each(($el) => {
+                        cy.wrap($el)
+                            .should('be.disabled');
+                    });
+            });
+    },
+
+    verifyCheckboxesUncheckedInPreviewTabAnswerTable: () => {
+        gridCommonComponents.previewTabAnswerTableRow()
+            .each(($el) => {
+                cy.wrap($el)
+                    .within(() => {
+                        multipleSelectionGridPage.optionsCheckbox()
+                            .each(($el) => {
+                                cy.wrap($el)
+                                    .should('not.be.checked');
+                            });
+                    });
+            });
+    },
+
+    verifyEnabledUncheckedTableRowCheckboxesInSetCorrectAnswerTable: (rowIndex) => {
+        gridCommonComponents.setCorrectAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                multipleSelectionGridPage.optionsCheckbox()
+                    .each(($el) => {
+                        cy.wrap($el)
+                            .should('be.enabled')
+                            .and('not.be.checked');
+                    });
+            });
+    },
+
+    /**
+    * @param {number} rowIndex index of the row 
+    * @param {number} optionIndex index of the option to be selected within the row
+    * @description This function verifies the incorrect icon in the preview tab table
+    */
+    verifyIncorrectOptionsCrossmarkIcon: (rowIndex, optionsArray) => {
+        gridCommonComponents.previewTabAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                optionsArray.forEach((options) => {
+                    multipleSelectionGridPage.optionsCheckboxWrapper()
+                        .eq(options)
+                        .within(() => {
+                            gridCommonComponents.correctIncorrectIconWrapper()
+                                .should('have.class', 'icon-incorrect')
+                                .and('be.visible');
+                        });
+                });
+            });
+    },
+
+    /**
+    * @param {number} rowIndex index of the row 
+    * @param {number[]} optionsArray array of index of the option to be selected within the row
+    * @description This function verifies the correct icon in the preview tab table
+    */
+    verifyCorrectOptionsCheckmarkIcon: (rowIndex, optionsArray) => {
+        gridCommonComponents.previewTabAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                optionsArray.forEach((options) => {
+                    multipleSelectionGridPage.optionsCheckboxWrapper()
+                        .eq(options)
+                        .within(() => {
+                            gridCommonComponents.correctIncorrectIconWrapper()
+                                .should('have.class', 'icon-correct')
+                                .and('be.visible');
+                        });
+                });
+            });
+    },
+
+
+    verifyCorrectIncorrectIconDoesNotExist: (rowIndex, optionsArray) => {
+        gridCommonComponents.previewTabAnswerTableRow()
+            .eq(rowIndex)
+            .within(() => {
+                optionsArray.forEach((options) => {
+                    multipleSelectionGridPage.optionsCheckboxWrapper()
+                        .eq(options)
+                        .within(() => {
+                            gridCommonComponents.correctIncorrectIconWrapper()
+                                .should('not.exist');
+                        });
+                });
+            });
+    },
+
+    resetQuestionPreview: () => {
+        createQuestionBasePage.steps.switchToEditTab();
+        createQuestionBasePage.steps.switchToPreviewTab();
+        steps.verifyCheckboxesUncheckedInPreviewTabAnswerTable();
+    },
+
+    //TODO: Make all border related changes once https://redmine.zeuslearning.com/issues/518498 is resolved
+    verifyCorrectAttemptBorder: () => {
+        gridCommonComponents.correctIncorrectAnswerBorder()
+            .should('have.css', 'border', `1px solid ${css.color.correctAnswer}`);
+    },
+
+    verifyIncorrectAttemptBorder: () => {
+        gridCommonComponents.correctIncorrectAnswerBorder()
+            .should('have.css', 'border', `1px solid ${css.color.incorrectAnswer}`);
+    },
+
+    verifyCorrectIncorrectBorderNotVisible: () => {
+        gridCommonComponents.correctIncorrectAnswerBorder()
+            .should('have.css', 'border')
+            .and('match', /0px none/);
+    },
+
+    //V3 - This function should be updated in all files
+    /**
+    * @param {number} points points displayed in partial equal weights points per response
+    * @description Verify points displayed in partial equal weights points per response
+    */
+    verifyPartialEqualWeightsPointsPerResponseScore: (points) => {
+        multipleSelectionGridPage.partialEqualWeightsPointsPerResponseScore()
+            .each(($element) => {
+                cy.wrap($element)
+                    .verifyInnerText(`${points}`);
+            });
+    },
+}
+
+const tests = {
+    ...createQuestionBasePage.tests,
+    ...commonComponents.tests,
+    ...questionInstructionsComponent.tests,
+    ...gridCommonComponents.tests,
+    ...autoScoredSetCorrectAnswerSection.tests,
+    ...autoScoredScoringSection.tests,
+    ...scoringSectionBase.tests,
+    ...previewScoringAndShowCorrectAnswerComponent.tests,
+    ...additionalSettingsPanel.tests,
+    ...autoScoredAdditionalSettings.tests,
+    ...studentResponseAndLayoutComponent.tests,
+    verifyAllContentsOfSetCorrectAnswerTableForScoringType: (scoringType, questionStemsArray, optionsArray) => {
+        it(`When user has selected ${scoringType} scoring type then added question stems, options and enabled checkboxes should be displayed`, () => {
+            multipleSelectionGridPage.steps.verifyQuestionStemsInSetCorrectAnswerTable(questionStemsArray);
+            multipleSelectionGridPage.steps.verifyTableHeaderContentsInSetCorrectAnswerTable(optionsArray);
+            for (let index = 0; index < 4; index++) {
+                multipleSelectionGridPage.steps.verifyEnabledUncheckedTableRowCheckboxesInSetCorrectAnswerTable(index);
+            }
+        });
+    },
+
+    /**
+     * @param {number} totalPoints the maximum points that can be scored by the user
+     * @description this function verifies the functionality of minimum points when penalty points are not set and user attempts incorrect answer
+     */
+    verifyMinimumScoreAwardedIfAttemptedFunctionalityForIncorrectAnswer: (totalPoints) => {
+        it('When user has provided minimum score awarded (if attempted) points, then in Preview tab on entering incorrect answer, minimum score should be provided for the question', () => {
+            cy.log('Switch to edit tab and set minimum score if attempted points')
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted('1')
+            createQuestionBasePage.steps.switchToPreviewTab()
+            multipleSelectionGridPage.steps.setAnswersForAllQuestionStemsInPreviewTabAnswerTable([[0, 1], [0, 1, 2], [1], [1]]);
+            multipleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`1/${totalPoints}`);
+        });
+
+        it('When user removes minimum score awarded (if attempted) points, then in Preview tab on selecting any options other than correct answers, points should not be provided', () => {
+            cy.log('Switch to edit tab and remove minimum score if attempted points')
+            createQuestionBasePage.steps.switchToEditTab();
+            multipleSelectionGridPage.steps.clearMinimumScoreIfAttemptedPointsField();
+            createQuestionBasePage.steps.switchToPreviewTab()
+            multipleSelectionGridPage.steps.setAnswersForQuestionStemInPreviewTabAnswerTable(2, [2]);
+            multipleSelectionGridPage.steps.setAnswersForQuestionStemInPreviewTabAnswerTable(3, [0]);
+            multipleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`0/${totalPoints}`);
+        });
+    },
+
+    /**
+     * 
+     * @param {number} scoredPoints the points scored by the user
+     * @param {number} totalPoints the maximum points that can be scored by the user
+     * @description this function verifies the functionality of Penalty points when minimum points are not set and user attempts incorrect answer
+     */
+    verifyPenaltyPointsFunctionalityForIncorrectAnswer: (scoredPoints, totalPoints) => {
+        it('When user has defined penalty points', () => {
+            cy.log('Pre-step: Switch to edit tab and set penalty points');
+            createQuestionBasePage.steps.switchToEditTab();
+            multipleSelectionGridPage.steps.allotPenaltyPoints('3')
+
+            cy.log('After switching to preview tab, when user adds an incorrect answer input, then 0 points should be awarded(no negative points)');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            multipleSelectionGridPage.steps.setAnswersForAllQuestionStemsInPreviewTabAnswerTable([[0, 1], [0, 1, 2], [1], [1]]);
+            multipleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`0/${totalPoints}`);
+
+            cy.log('When user adds a partially correct answer input, the points should be updated accordingly with deducted penalty points');
+            multipleSelectionGridPage.steps.resetQuestionPreview()
+            multipleSelectionGridPage.steps.setAnswersForAllQuestionStemsInPreviewTabAnswerTable([[0, 2], [0, 2], [0, 1], [1, 2]]);
+            multipleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`${scoredPoints}/${totalPoints}`);
+        });
+    },
+
+    /**
+     * @param {number} scoredPoints the points scored by the user
+     * @param {number} totalPoints the maximum points that can be scored by the user
+     * @description this function verifies the functionality of Minimum score if attempted points when penalty points are set and user attempts incorrect answer
+     */
+    verifyMinimumScoreIfAttemptedAndPenaltyPointsFunctionalityForIncorrectAnswer: (scoredPoints, totalPoints) => {
+        it('When user has defined both penalty points and minimum score awarded (if attempted) points', () => {
+            cy.log('Pre-step: Switch to edit tab and set minimum score awarded (if attempted) points');
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted('1');
+
+            cy.log('Switch to preview tab and give incorrect answer input to check that minimum points are displayed');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            multipleSelectionGridPage.steps.setAnswersForAllQuestionStemsInPreviewTabAnswerTable([[0, 1], [0, 1, 2], [1], [1]]);
+            multipleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`1/${totalPoints}`);
+
+            cy.log('When user adds a partially correct answer such that the points of the attempt(with penalty points deducted) is more than the minimum score awarded(if attempted) points');
+            multipleSelectionGridPage.steps.resetQuestionPreview()
+            multipleSelectionGridPage.steps.setAnswersForAllQuestionStemsInPreviewTabAnswerTable([[0, 2], [0, 2], [0, 1], [1, 2]]);
+            multipleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`${scoredPoints}/${totalPoints}`);
+
+            cy.log('When user switches to edit tab and increases the minimum score awarded (if attempted) points to check the case for an attempt in which points of the attempt is less than minimum score awarded (if attempted) points, then the minimum score awarded (if attempted) points should be displayed to the user');
+            createQuestionBasePage.steps.switchToEditTab();
+            multipleSelectionGridPage.steps.clearMinimumScoreIfAttemptedPointsField()
+            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted('6')
+            cy.log('Switching to preview tab');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            multipleSelectionGridPage.steps.setAnswersForAllQuestionStemsInPreviewTabAnswerTable([[0, 2], [0, 2], [1], [1]]);
+            multipleSelectionGridPage.previewScoreText()
+                .verifyInnerText(`6/${totalPoints}`);
+        });
+    }
+}
+
+export const multipleSelectionGridPage = {
+    ...selectors,
+    steps,
+    tests
+}

package/cypress/pages/multipleSelectionPage.js

@@ -0,0 +1,88 @@
+import { additionalSettingsPanel, autoScoredPreviewBase, createQuestionBasePage, mcqAdditionalSettingsBase, mcqOptionsComponent, mcqPreviewComponents, mcqSetCorrectAnswerSection, questionInstructionsComponent, scoringSectionBase, autoScoredAdditionalSettings, autoScoredSetCorrectAnswerSection, autoScoredScoringSectionMultipleResponsesType, autoScoredScoringSection, mcqScoringComponent, previewScoringAndShowCorrectAnswerComponent, optionsWrapperComponent } from "./components"
+import { mcqQuestionCommonComponents } from "./components/mcqQuestionCommonComponents";
+
+const selectors = {
+    ...mcqAdditionalSettingsBase,
+    ...scoringSectionBase,
+    ...createQuestionBasePage,
+    ...mcqQuestionCommonComponents,
+    ...mcqOptionsComponent,
+    ...additionalSettingsPanel,
+    ...mcqSetCorrectAnswerSection,
+    ...autoScoredPreviewBase,
+    ...questionInstructionsComponent,
+    ...autoScoredAdditionalSettings,
+    ...autoScoredSetCorrectAnswerSection,
+    ...autoScoredScoringSectionMultipleResponsesType,
+    ...previewScoringAndShowCorrectAnswerComponent,
+    ...optionsWrapperComponent,
+    //Maximum and minimum answers
+    minimumNumberOfAnswersLabel: () => cy.get('.min-answer-label'),
+    maximumNumberOfAnswersLabel: () => cy.get('.max-answer-label'),
+    minimumAnswersInputField: () => cy.get('.min-answer-input-field input'),
+    maximumAnswersInputField: () => cy.get('.max-answer-input-field input'),
+    minMaxErrorMessage: () => cy.get('.min-max-answer-error-wrapper')
+}
+
+const steps = {
+    ...createQuestionBasePage.steps,
+    ...questionInstructionsComponent.steps,
+    ...mcqOptionsComponent.steps,
+    ...additionalSettingsPanel.steps,
+    ...autoScoredAdditionalSettings.steps,
+    ...mcqPreviewComponents.steps,
+    ...mcqSetCorrectAnswerSection.steps,
+    ...autoScoredPreviewBase.steps,
+    ...mcqQuestionCommonComponents.steps,
+    ...scoringSectionBase.steps,
+    ...autoScoredSetCorrectAnswerSection.steps,
+    ...autoScoredScoringSection.steps,
+    ...autoScoredScoringSectionMultipleResponsesType.steps,
+    addPartialDifferentWeightsPoints: (optionIndex, points) => {
+        mcqSetCorrectAnswerSection.correctAnswerOptionsWrapper(optionIndex)
+            .within(() => {
+                scoringSectionBase.pointsInputField()
+                    .clear()
+                    .type(points, { delay: 500 })
+                    .should('have.value', points)
+                    .blur();
+            });
+    },
+
+    //TODO: Remove this after https://redmine.zeuslearning.com/issues/528831 is fixed
+    verifyQuestionPreviewStateWhenShowCorrectAnswerIsUnchecked: () => {
+        cy.log('After deselecting Show correct answer checkbox, the question preview should return to the previous state');
+        previewScoringAndShowCorrectAnswerComponent.showCorrectAnswerCheckbox()
+            .click()
+            .should('not.be.checked');
+        autoScoredPreviewBase.correctIcon()
+            .should('not.exist');
+        autoScoredPreviewBase.incorrectIcon()
+            .should('not.exist');
+        autoScoredPreviewBase.correctIncorectAnswerLabel()
+            .should('not.exist');
+        autoScoredPreviewBase.steps.verifyCorrectIncorrectBorderNotExists();
+    },
+}
+
+const tests = {
+    ...createQuestionBasePage.tests,
+    ...questionInstructionsComponent.tests,
+    ...mcqOptionsComponent.tests,
+    ...additionalSettingsPanel.tests,
+    ...mcqAdditionalSettingsBase.tests,
+    ...mcqSetCorrectAnswerSection.tests,
+    ...mcqQuestionCommonComponents.tests,
+    ...scoringSectionBase.tests,
+    ...autoScoredSetCorrectAnswerSection.tests,
+    ...autoScoredScoringSection.tests,
+    ...autoScoredAdditionalSettings.tests,
+    ...mcqScoringComponent.tests,
+    ...previewScoringAndShowCorrectAnswerComponent.tests,
+}
+
+export const multipleSelectionPage = {
+    ...selectors,
+    steps,
+    tests
+}