itemengine-cypress-automation 1.0.2

package/cypress/pages/fillInTheGapsSetCorrectAnswerSection.js

@@ -0,0 +1,260 @@
+import { fillInTheGapsTextPage } from "./fillInTheGapsTextPage";
+import { fillInTheGapsDropdownPage } from "./fillInTheGapsDropdownPage";
+import { autoScoredScoringSectionMultipleResponsesType, fillInTheGapsCommonComponents, scoringSectionBase } from "./components";
+import { autoScoredSetCorrectAnswerSection } from "./components";
+
+const tests = {
+    verifyPointsInEditTabForAutoScoredAllOrNothingWhenMatchFromAllResponsesIsTrue: (questionType) => {
+        it('When the user adds alternate answer and enables the \'Match from all responses\' functionality, the points field should be in disabled state and should have the value of points same as set in the \'Correct\' tab', () => {
+            autoScoredSetCorrectAnswerSection.alternateAnswerButton()
+                .click();
+            switch (questionType) {
+                case 'fill in the gaps - text':
+                    fillInTheGapsTextPage.steps.setCorrectAnswerResponses(['Response 3', 'Response 4']);
+                    break;
+                case 'fill in the gaps - dropdown':
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(0, 'healthy');
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(1, 'decreasingly');
+                    break;
+                default:
+                    throw new Error('Invalid question type');
+            };
+            scoringSectionBase.steps.allotPoints(3);
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('be.checked');
+            scoringSectionBase.pointsInputField()
+                .should('have.value', '7')
+                .and('be.disabled');
+        });
+
+        it('When the user adds another tab, the new alternate answer tab should also have the same point value as the \'Correct\' tab', () => {
+            autoScoredSetCorrectAnswerSection.alternateAnswerButton()
+                .click();
+            scoringSectionBase.pointsInputField()
+                .should('have.value', '7')
+                .and('be.disabled');
+        });
+
+        it('When the user has already set different points in the alternate answer tab and then enables the \'Match from all responses\' functionality, the points field in the \'Alternate\' tab should get disabled and should have the value of points same as set in the \'Correct\' tab', () => {
+            cy.log('Pre:step - unchecking the \'Match from all responses\' checkbox and updating the points')
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('not.be.checked');
+            switch (questionType) {
+                case 'fill in the gaps - text':
+                    fillInTheGapsTextPage.steps.setCorrectAnswerResponses(['Response 5', 'Response 6']);
+                    break;
+                case 'fill in the gaps - dropdown':
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(0, 'progressively');
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(1, 'decreasingly');
+                    break;
+                default:
+                    throw new Error('Invalid question type');
+            };
+            scoringSectionBase.pointsInputField()
+                .type('10');
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('be.checked');
+            scoringSectionBase.pointsInputField()
+                .should('have.value', '7')
+                .and('be.disabled');
+        });
+
+        it('When the user disables the \'Match from all responses\' functionality, the score should go back to their previously set values', () => {
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('not.be.checked');
+            scoringSectionBase.pointsInputField()
+                .should('have.value', '10');
+            autoScoredSetCorrectAnswerSection.correctTab()
+                .click();
+            scoringSectionBase.pointsInputField()
+                .should('have.value', '7');
+        });
+    },
+
+    verifyPointsInEditTabForAutoScoredPartialEqualWeightsWhenMatchFromAllResponsesIsTrue: (questionType) => {
+        it('When the user adds alternate answer and enables the \'Match from all responses\' functionality, the points field should be in disabled state and should have the value of points same as set in the \'Correct\' tab', () => {
+            autoScoredSetCorrectAnswerSection.alternateAnswerButton()
+                .click();
+            switch (questionType) {
+                case 'fill in the gaps - text':
+                    fillInTheGapsTextPage.steps.setCorrectAnswerResponses(['Response 3', 'Response 4']);
+                    break;
+                case 'fill in the gaps - dropdown':
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(0, 'healthy');
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(1, 'decreasingly');
+                    break;
+                default:
+                    throw new Error('Invalid question type');
+            };
+            scoringSectionBase.steps.allotPoints(3);
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('be.checked');
+            scoringSectionBase.pointsInputField()
+                .should('have.value', '7')
+                .and('be.disabled');
+            fillInTheGapsCommonComponents.partialEqualWeightsPointsPerResponseScore()
+                .each(($element) => {
+                    cy.wrap($element)
+                        .verifyInnerText('3.5');
+                });
+        });
+
+        it('When the user adds another tab, the new alternate answer tab should also have the same point value as the \'Correct\' tab', () => {
+            autoScoredSetCorrectAnswerSection.alternateAnswerButton()
+                .click();
+            scoringSectionBase.pointsInputField()
+                .should('have.value', '7')
+                .and('be.disabled');
+            fillInTheGapsCommonComponents.partialEqualWeightsPointsPerResponseScore()
+                .each(($element) => {
+                    cy.wrap($element)
+                        .verifyInnerText('3.5');
+                });
+        });
+
+        it('When the user has already set different points in the alternate answer tab and then enables the \'Match from all responses\' functionality, the points field in the \'Alternate\' tab should get disabled and should have the value of points same as set in the \'Correct\' tab', () => {
+            switch (questionType) {
+                case 'fill in the gaps - text':
+                    fillInTheGapsTextPage.steps.setCorrectAnswerResponses(['Response 5', 'Response 6']);
+                    break;
+                case 'fill in the gaps - dropdown':
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(0, 'progressively');
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(1, 'decreasingly');
+                    break;
+                default:
+                    throw new Error('Invalid question type');
+            };
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('not.be.checked');
+            scoringSectionBase.pointsInputField()
+                .type(10);
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('be.checked');
+            scoringSectionBase.pointsInputField()
+                .should('have.value', '7')
+                .and('be.disabled');
+            fillInTheGapsCommonComponents.partialEqualWeightsPointsPerResponseScore()
+                .each(($element) => {
+                    cy.wrap($element)
+                        .verifyInnerText('3.5');
+                });
+        });
+
+        it('When the user disables the \'Match from all responses\' functionality, the score should go back to their previously set values', () => {
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('not.be.checked');
+            scoringSectionBase.pointsInputField()
+                .should('have.value', '10');
+            fillInTheGapsCommonComponents.partialEqualWeightsPointsPerResponseScore()
+                .each(($element) => {
+                    cy.wrap($element)
+                        .verifyInnerText('5');
+                });
+            autoScoredSetCorrectAnswerSection.correctTab()
+                .click();
+            scoringSectionBase.pointsInputField()
+                .should('have.value', '7');
+        });
+    },
+
+    verifyPointsInEditTabForAutoScoredPartialDifferentWeightsWhenMatchFromAllResponsesIsTrue: (questionType) => {
+        let partialDifferentWeightPoints = [1, 7];
+        it('When the user adds alternate answer and enables the \'Match from all responses\' functionality, the points field should be in disabled state and should have the value of points same as set in the \'Correct\' tab', () => {
+            autoScoredSetCorrectAnswerSection.alternateAnswerButton()
+                .click();
+            switch (questionType) {
+                case 'fill in the gaps - text':
+                    fillInTheGapsTextPage.steps.setCorrectAnswerResponses(['Response 3', 'Response 4']);
+                    break;
+                case 'fill in the gaps - dropdown':
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(0, 'healthy');
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(1, 'decreasingly');
+                    break;
+                default:
+                    throw new Error('Invalid question type');
+            };
+            autoScoredScoringSectionMultipleResponsesType.steps.addPartialDifferentWeightsPoints([2, 8]);
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('be.checked');
+            partialDifferentWeightPoints.forEach((points, count) => {
+                scoringSectionBase.pointsInputField()
+                    .eq(count)
+                    .should('have.value', points)
+                    .and('be.disabled');
+            });
+        });
+
+        it('When the user adds another tab, the new alternate answer tab should also have the same point value as the \'Correct\' tab', () => {
+            autoScoredSetCorrectAnswerSection.alternateAnswerButton()
+                .click();
+            partialDifferentWeightPoints.forEach((points, count) => {
+                scoringSectionBase.pointsInputField()
+                    .eq(count)
+                    .should('have.value', points)
+                    .and('be.disabled');
+            });
+        });
+
+        //https://redmine.zeuslearning.com/issues/528115
+        it('When the user has already set different points in the alternate answer tab and then enables the \'Match from all responses\' functionality, the points field in the \'Alternate\' tab should get disabled and should have the value of points same as set in the \'Correct\' tab', () => {
+            cy.log('Pre:step - unchecking the \'Match from all responses\' checkbox and updating the points')
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('not.be.checked');
+            switch (questionType) {
+                case 'fill in the gaps - text':
+                    fillInTheGapsTextPage.steps.setCorrectAnswerResponses(['Response 5', 'Response 6']);
+                    break;
+                case 'fill in the gaps - dropdown':
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(0, 'progressively');
+                    fillInTheGapsDropdownPage.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(1, 'decreasingly');
+                    break;
+                default:
+                    throw new Error('Invalid question type');
+            };
+            autoScoredScoringSectionMultipleResponsesType.steps.addPartialDifferentWeightsPoints([3, 9]);
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('be.checked');
+            partialDifferentWeightPoints.forEach((points, count) => {
+                scoringSectionBase.pointsInputField()
+                    .eq(count)
+                    .should('have.value', points)
+                    .and('be.disabled');
+            });
+        });
+
+        it('When the user disables the \'Match from all responses\' functionality, the score should go back to their previously set values', () => {
+            let pointsSetInAlternateTab = [3, 9];
+            let pointsSetInCorrectTab = [1, 7];
+            fillInTheGapsCommonComponents.matchFromAllResponsesCheckbox()
+                .click()
+                .should('not.be.checked');
+            pointsSetInAlternateTab.forEach((points, count) => {
+                scoringSectionBase.pointsInputField()
+                    .eq(count)
+                    .should('have.value', points);
+            });
+            autoScoredSetCorrectAnswerSection.correctTab()
+                .click();
+            pointsSetInCorrectTab.forEach((points, count) => {
+                scoringSectionBase.pointsInputField()
+                    .eq(count)
+                    .should('have.value', points);
+            });
+        });
+    }
+}
+
+export const fillInTheGapsSetCorrectAnswerSection = {
+    tests
+}

package/cypress/pages/fillInTheGapsTextPage.js

@@ -0,0 +1,225 @@
+import { questionInstructionsComponent, scoringSectionBase, createQuestionBasePage, additionalSettingsPanel, commonComponents, autoScoredPreviewBase, autoScoredAdditionalSettings, autoScoredSetCorrectAnswerSection, autoScoredScoringSectionMultipleResponsesType, autoScoredScoringSection, fillInTheGapsCommonComponents, specialCharactersFlyoutComponent, specialAndCustomSpecialCharactersComponent, previewScoringAndShowCorrectAnswerComponent } from "./components";
+import { answerNumerationComponent } from "./components/answerNumerationComponent";
+const css = Cypress.env('css');
+
+const selectors = {
+    ...scoringSectionBase,
+    ...createQuestionBasePage,
+    ...additionalSettingsPanel,
+    ...questionInstructionsComponent,
+    ...commonComponents,
+    ...autoScoredSetCorrectAnswerSection,
+    ...autoScoredAdditionalSettings,
+    ...autoScoredPreviewBase,
+    ...autoScoredScoringSectionMultipleResponsesType,
+    ...fillInTheGapsCommonComponents,
+    ...specialCharactersFlyoutComponent,
+    ...specialAndCustomSpecialCharactersComponent,
+    ...previewScoringAndShowCorrectAnswerComponent,
+    ...answerNumerationComponent,
+    setCorrectAnswerResponseField: () => cy.get('.response-input-field input[type="text"]'),
+    caseSensitiveLabel: () => cy.get('[data-ngie-testid="case-sensitive-checkbox"] .MuiFormControlLabel-label'),
+    ignoreSpacesBeforeAndAfterLabel: () => cy.get('[data-ngie-testid="ignore-spaces-before-and-after-checkbox"] .MuiFormControlLabel-label'),
+    matchFromAllResponsesLabel: () => cy.get('[data-ngie-testid="match-from-all-responses-checkbox"] .MuiFormControlLabel-label'),
+    caseSensitiveCheckbox: () => cy.get('[data-ngie-testid="case-sensitive-checkbox"] input'),
+    ignoreSpacesBeforeAndAfterCheckbox: () => cy.get('[data-ngie-testid="ignore-spaces-before-and-after-checkbox"] input'),
+    matchFromAllResponsesCheckbox: () => cy.get('[data-ngie-testid="match-from-all-responses-checkbox"] input'),
+    //Additional settings
+    multilineResponseLabel: () => cy.get('[data-ngie-testid="multiline-response-checkbox"] .MuiFormControlLabel-label'),
+    multilineResponseCheckbox: () => cy.get('[data-ngie-testid="multiline-response-checkbox"] input'),
+    setCorrectAnswerMultilineTextArea: () => cy.get('.response-multiline-input-field'),
+    previewTabMultilineTextArea: () => cy.get('.cloze-with-text-response-preview-wrapper .response-multiline-input-field'),
+    spellCheckLabel: () => cy.get('[data-ngie-testid="spell-check-checkbox"] .MuiFormControlLabel-label'),
+    spellCheckCheckbox: () => cy.get('[data-ngie-testid="spell-check-checkbox"] input'),
+    previewTabResponseFieldSpecialCharactersButton: () => cy.get('.cloze-with-text-response-preview-wrapper .custon-special-character-button'),
+    typeOfAnswerInputLabel: () => cy.get('.additional-settings-label[id*="Type-of-Answer-input"]'),
+    typeOfAnswerInputDropdown: () => cy.get('.drop-down-parent[id*="Type-of-Answer-input"]').eq(0),
+    typeOfAnswerInputDropdownListOptions: (optionNumber) => cy.get('[aria-labelledby*="Type-of-Answer-input"] .dropdown-menu-item').eq(optionNumber),
+    setCharacterLimitLabel: () => cy.get('[aria-labelledby="Set character limit"]'),
+    setCharacterLimitInputField: () => cy.get('.dropdown-wrapper .text-input-field input[type="text"]').eq(0),
+    //Preview tab
+    previewTabResponseField: () => cy.get('.cloze-with-text-response-preview-wrapper [type="text"]'),
+    previewTabResponseFieldWrapper: () => cy.get('.cloze-with-text-answer-status-response-preview-wrapper'),
+}
+
+const steps = {
+    ...createQuestionBasePage.steps,
+    ...questionInstructionsComponent.steps,
+    ...scoringSectionBase.steps,
+    ...additionalSettingsPanel.steps,
+    ...autoScoredSetCorrectAnswerSection.steps,
+    ...autoScoredPreviewBase.steps,
+    ...autoScoredSetCorrectAnswerSection.steps,
+    ...autoScoredScoringSection.steps,
+    ...autoScoredAdditionalSettings.steps,
+    ...fillInTheGapsCommonComponents.steps,
+    ...specialCharactersFlyoutComponent.steps,
+    ...autoScoredScoringSectionMultipleResponsesType.steps,
+    ...answerNumerationComponent.steps,
+    expandResponseAccordion: (responseIndex) => {
+        fillInTheGapsTextPage.responseAccordionWrapper()
+            .eq(responseIndex)
+            .find('.additional-settings-panel')
+            .should('have.attr', 'aria-expanded', 'false')
+            .click()
+            .should('have.attr', 'aria-expanded', 'true');
+    },
+
+    setCorrectAnswerResponses: (responseTextArray) => {
+        responseTextArray.forEach((responseFieldText, count) => {
+            fillInTheGapsTextPage.setCorrectAnswerResponseField()
+                .eq(count)
+                .type(responseFieldText)
+                .should('have.value', responseFieldText);
+        });
+    },
+
+    verifyAnswerInputScoreAndCorrectIncorrectAnswerLabel: (answerInput, score, isCorrect) => {
+        cy.log('Pre-requisite: This can only be used for questions with single response fields');
+        fillInTheGapsTextPage.previewTabResponseField()
+            .clear()
+            .type(answerInput)
+            .blur();
+        previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+            .verifyInnerText(score);
+        autoScoredPreviewBase.checkAnswerButton()
+            .realClick();
+        if (isCorrect) {
+            fillInTheGapsTextPage.steps.verifyCorrectOptionCheckmarkIcon('0');
+            autoScoredPreviewBase.steps.verifyCorrectIncorrectAnswerLabel('Correct');
+        } else {
+            fillInTheGapsTextPage.steps.verifyIncorrectOptionCrossmarkIcon('0');
+            autoScoredPreviewBase.steps.verifyCorrectIncorrectAnswerLabel('Incorrect');
+        };
+    },
+
+    enterAnswerResponsesInPreviewTab: (responseTextArray) => {
+        responseTextArray.forEach((responseFieldText, count) => {
+            fillInTheGapsTextPage.previewTabResponseField()
+                .eq(count)
+                .clear()
+                .type(responseFieldText)
+                .should('have.value', responseFieldText);
+        });
+    }
+}
+
+const tests = {
+    ...commonComponents.tests,
+    ...createQuestionBasePage.tests,
+    ...questionInstructionsComponent.tests,
+    ...additionalSettingsPanel.tests,
+    ...scoringSectionBase.tests,
+    ...autoScoredSetCorrectAnswerSection.tests,
+    ...autoScoredAdditionalSettings.tests,
+    ...autoScoredScoringSection.tests,
+    ...fillInTheGapsCommonComponents.tests,
+    ...specialCharactersFlyoutComponent.tests,
+    ...specialAndCustomSpecialCharactersComponent.tests,
+    ...previewScoringAndShowCorrectAnswerComponent.tests,
+    ...autoScoredScoringSectionMultipleResponsesType.tests,
+    ...answerNumerationComponent.tests,
+    verifySetCorrectAnswerTabContentsAndFunctionality: (tabName) => {
+        it(`CSS of ${tabName} contents`, { tags: 'css' }, () => {
+            fillInTheGapsTextPage.setCorrectAnswerResponseFieldLabel()
+                .eq(0)
+                .verifyCSS(css.color.labels, css.fontSize.default, css.fontWeight.regular);
+            fillInTheGapsTextPage.setCorrectAnswerResponseField()
+                .eq(0)
+                .verifyCSS(css.color.text, css.fontSize.default, css.fontWeight.regular);
+        });
+
+        it('By default, an empty points input field and two empty response fields with labels \'Response 1\' and \'Response 2\' should be present', () => {
+            fillInTheGapsTextPage.pointsInputField()
+                .should('have.value', '');
+            for (let index = 0; index < 2; index++) {
+                fillInTheGapsTextPage.setCorrectAnswerResponseFieldLabel()
+                    .eq(index)
+                    .verifyInnerText(`Response ${index + 1}`);
+                fillInTheGapsTextPage.setCorrectAnswerResponseField()
+                    .eq(index)
+                    .should('be.visible');
+            };
+        });
+
+        it('User should be able to enter text in the empty response field', () => {
+            fillInTheGapsTextPage.setCorrectAnswerResponseField()
+                .eq(0)
+                .type('Lorem Ipsum')
+                .should('have.value', 'Lorem Ipsum');
+        });
+
+        it(`When the user has only partially filled response fields out of the available response fields, \'Error: Please set a correct answer.\' validation error message should be thrown along with an error icon on the \'${tabName}\'`, () => {
+            fillInTheGapsTextPage.setCorrectAnswerResponseField()
+                .eq(1)
+                .focus()
+                .blur();
+            commonComponents.errorMessage()
+                .should('have.text', 'Error: Please set a correct answer.');
+            if (tabName == 'Correct tab') {
+                autoScoredSetCorrectAnswerSection.correctTab()
+                    .within(() => {
+                        autoScoredSetCorrectAnswerSection.setCorrectAnswerErrorIcon()
+                            .should('be.visible');
+                    });
+            } else {
+                autoScoredSetCorrectAnswerSection.alternateAnswerTab(1)
+                    .within(() => {
+                        autoScoredSetCorrectAnswerSection.setCorrectAnswerErrorIcon()
+                            .should('be.visible');
+                    });
+            };
+        });
+
+        autoScoredSetCorrectAnswerSection.tests.verifyCSSAndA11yOfAutoScoredSetCorrectAnswerErrorMessage();
+
+        it('CSS of response field error state', { tags: 'css' }, () => {
+            fillInTheGapsTextPage.setCorrectAnswerResponseField()
+                .eq(1)
+                .parents('.response-input-field')
+                .should('have.css', 'background-color', css.color.errorFieldBg)
+                .find('fieldset')
+                .should('have.css', 'border', `1px solid ${css.color.errorFieldBorder}`)
+        });
+
+        it('Accessibility of response field error state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(fillInTheGapsTextPage.setCorrectAnswerResponseField().parents('.cloze-with-text-response-form-controls-wrapper'));
+        });
+
+        it('When the user has added text in all the available response fields, the error message should disappear', () => {
+            fillInTheGapsTextPage.setCorrectAnswerResponseField()
+                .eq(1)
+                .type('dolor sit amet')
+                .should('have.value', 'dolor sit amet');
+            commonComponents.errorMessage()
+                .should('not.exist');
+        });
+
+        autoScoredSetCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(tabName);
+    },
+
+    verifyMinimumScoreAwardedForIncorrectAnswer: (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.minimumScoreIfAttemptedInputField()
+                .type('1')
+                .should('have.value', '1');
+            createQuestionBasePage.steps.switchToPreviewTab()
+            fillInTheGapsTextPage.previewTabResponseField()
+                .eq(0)
+                .type('Incorrect answer')
+                .blur();
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .then(($points) => {
+                    expect($points.text()).to.equal(`1/${totalPoints}`);
+                });
+        });
+    }
+}
+
+export const fillInTheGapsTextPage = {
+    ...selectors,
+    steps,
+    tests
+}