itemengine-cypress-automation 1.0.113 → 1.0.114

package/cypress/pages/shortTextResponsePage.js

@@ -1,21 +1,15 @@
-import { questionInstructionsComponent, scoringSectionBase, createQuestionBasePage, additionalSettingsPanel, commonComponents, autoScoredPreviewBase, autoScoredSetCorrectAnswerSection, autoScoredScoringSection, autoScoredAdditionalSettings, specialCharactersFlyoutComponent, specialAndCustomSpecialCharactersComponent, previewScoringAndShowCorrectAnswerComponent } from "./components/";
-import { studentResponseAndLayoutComponent } from "./components/studentResponseAreaAndLayoutComponent";
+import { createQuestionBasePage, autoScoredStudentViewSettings, autoScoredScoringPreviewTab, scoringSectionBaseEditTab, questionInstructionsComponent, autoScoredScoringSectionMultiResponseType, autoScoredSpecifyCorrectAnswerSection, commonComponents, additionalSettingsPanel } from "./components/";
+import { dialogBoxBase } from "./dialogBoxBase";
+import utilities from "../support/helpers/utilities";
 const css = Cypress.env('css');
 
 const selectors = {
-    ...scoringSectionBase,
-    ...createQuestionBasePage,
-    ...additionalSettingsPanel,
     ...questionInstructionsComponent,
-    ...commonComponents,
-    ...autoScoredSetCorrectAnswerSection,
-    ...autoScoredAdditionalSettings,
-    ...autoScoredPreviewBase,
-    ...specialCharactersFlyoutComponent,
-    ...specialAndCustomSpecialCharactersComponent,
-    ...previewScoringAndShowCorrectAnswerComponent,
-    setCorrectAnswerResponseField: () => cy.get('.short-text-response-input-field input'),
-    setCorrectAnswerResponseFieldWrapper: () => cy.get('.short-text-response-input-field input').parents('.MuiTextField-root'),
+    ...autoScoredSpecifyCorrectAnswerSection,
+    
+    correctAnswerAccordionLabel: () => cy.get('[class*="AnswerAccordionstyles__Label"]'),
+    specifyCorrectAnswerResponseField: () => cy.get('.short-text-response-input-field input'),
+    specifyCorrectAnswerResponseFieldWrapper: () => cy.get('.short-text-response-input-field input').parents('.MuiTextField-root'),
     exactRadioOptionLabel: () => cy.get('.ngie-radio-label').eq(0),
     containsTextRadioOptionLabel: () => cy.get('.ngie-radio-label').eq(1),
     caseSensitiveCheckboxLabel: () => cy.get('[data-ngie-testid="case-sensitive-checkbox"] .MuiFormControlLabel-label'),
@@ -24,10 +18,10 @@ const selectors = {
     containsTextRadioButton: () => cy.get('input[aria-label="Contains text"]'),
     caseSensitiveCheckbox: () => cy.get('[data-ngie-testid="case-sensitive-checkbox"] input'),
     ignoreSpacesBeforeAndAfterCheckbox: () => cy.get('[data-ngie-testid="ignore-spaces-before-and-after-checkbox"] input'),
-    previewTabResponseField: () => cy.get('[class*="edit-question-preview-wrapper"] .short-text-preview-response-input-field input'),
+    previewTabResponseField: () => cy.get('.input-field input:visible'),
     previewTabResponseFieldWrapper: () => cy.get('[class*="edit-question-preview-wrapper"] .short-text-preview-response-input-field input').parents('.MuiTextField-root'),
     //Preview tab
-    previewTabCorrectAnswerContainer: () => cy.get('[class*="ShortTextResponsestyles__CorrectAnswerWrapper"]'),
+    previewTabCorrectAnswerWrapper: () => cy.get('[class*="ShortTextResponsestyles__CorrectAnswerWrapper"]'),
     previewTabCorrectAnswerLabel: () => cy.get('[class*="ShortTextResponsestyles__CorrectAnswerLabel"]'),
     previewTabCorrectAnswerResponse: () => cy.get('[class*="ShortTextResponsestyles__CorrectAnswerValueWrapper"]'),
     previewTabResponseFieldSpecialCharactersButton: () => cy.get('.cloze-with-text-response-preview-wrapper .custon-special-character-button'),
@@ -47,31 +41,56 @@ const selectors = {
 
 const steps = {
     ...createQuestionBasePage.steps,
+    ...autoScoredStudentViewSettings.steps,
+    ...autoScoredScoringPreviewTab.steps,
+    ...scoringSectionBaseEditTab.steps,
     ...questionInstructionsComponent.steps,
-    ...scoringSectionBase.steps,
     ...additionalSettingsPanel.steps,
-    ...autoScoredSetCorrectAnswerSection.steps,
-    ...autoScoredAdditionalSettings.steps,
-    ...autoScoredPreviewBase.steps,
-    ...specialCharactersFlyoutComponent.steps,
-    ...previewScoringAndShowCorrectAnswerComponent.steps,
-    verifyCorrectOptionCheckmarkIcon: () => {
-        autoScoredPreviewBase.correctIcon()
-            .should('be.visible');
+    ...autoScoredSpecifyCorrectAnswerSection.steps,
+
+    verifyCorrectIcon: () => {
+        utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'visible');
+    },
+
+    verifyIncorrectIcon: () => {
+        utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'visible');
+    },
+
+    verifyCorrectIncorrectIconNotVisibleGradingView: () => {
+        utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'notExist');
+        utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'notExist');
+    },
+
+    verifyCorrectAttemptBorder: () => {
+        utilities.verifyCSS(shortTextResponsePage.previewTabResponseField().parent().find('fieldset'), {
+            'border': `1px solid ${css.color.correctAnswer}`
+        });
+    },
+
+    verifyIncorrectAttemptBorder: () => {
+        utilities.verifyCSS(shortTextResponsePage.previewTabResponseField().parent().find('fieldset'), {
+            'border': `1px solid ${css.color.incorrectAnswer}`
+        });
     },
 
-    verifyIncorrectOptionCrossmarkIcon: () => {
-        autoScoredPreviewBase.incorrectIcon()
-            .should('be.visible');
+    verifyCorrectIncorrectBorderNotExist: () => {
+        shortTextResponsePage.previewTabResponseField()
+            .parent()
+            .find('fieldset')
+            .should('not.have.css', 'border', `1px solid ${css.color.incorrectAnswer}`)
+            .and('not.have.css', 'border', `1px solid ${css.color.correctAnswer}`);
     },
 
-    verifyCorrectAnswerResponsesInCorrectAnswerContainerAndCount: (correctAnswer) => {
-        shortTextResponsePage.previewTabCorrectAnswerContainer()
-            .should('be.visible');
-        shortTextResponsePage.previewTabCorrectAnswerResponse()
-            .verifyInnerText(correctAnswer)
-        shortTextResponsePage.previewTabCorrectAnswerResponse()
-            .should('have.length', 1);
+    /**
+     * @param {String} correctAnswer correct answer in correct answer wrapper present in grading view
+     * @description function verifies correct answer wrapper in grading view
+     */
+    verifyCorrectAnswerResponseInCorrectAnswerWrapper: (correctAnswer) => {
+        utilities.verifyElementVisibilityState(shortTextResponsePage.previewTabCorrectAnswerWrapper(), 'visible');
+        utilities.verifyInnerText(shortTextResponsePage.previewTabCorrectAnswerLabel(), 'Correct answer:');
+        utilities.verifyElementVisibilityState(shortTextResponsePage.previewTabCorrectAnswerLabel(), 'visible');
+        utilities.verifyInnerText(shortTextResponsePage.previewTabCorrectAnswerResponse(), correctAnswer);
+        utilities.verifyElementVisibilityState(shortTextResponsePage.previewTabCorrectAnswerResponse(), 'visible');
     },
 
     createBasicShortTextResponseQuestion: (inputQuestion, points, inputAnswer) => {
@@ -79,31 +98,73 @@ const steps = {
             .type(inputQuestion);
         shortTextResponsePage.pointsInputField()
             .type(points);
-        shortTextResponsePage.setCorrectAnswerResponseField()
+        shortTextResponsePage.specifyCorrectAnswerResponseField()
             .type(inputAnswer);
         shortTextResponsePage.saveQuestionButton()
             .click();
+    },
+
+    /**
+     * @param {string} text text to entered in set correct answer input field
+     */
+    enterTextInAnswerInputFieldSpecifyCorrectAnswerSection: (text) => {
+        shortTextResponsePage.specifyCorrectAnswerResponseField()
+            .type(text)
+            .should('have.value', text);
+    },
+
+    clearAndFocusOutOfSpecifyCorrectAnswerInputField: (text) => {
+        shortTextResponsePage.setCorrectAnswerResponseField()
+            .clear()
+            .blur();
+    },
+
+    /**
+     * @param {string} text text to entered in set correct answer input field
+     */
+    enterTextInAnswerInputFieldPreviewTab: (text) => {
+        shortTextResponsePage.previewTabResponseField()
+            .clear()
+            .type(text)
+            .should('have.value', text);
+    },
+
+    /**
+     * @param {string} text text to entered in set correct answer input field
+     */
+    verifyTextInAnswerInputFieldPreviewTab: (text) => {
+        shortTextResponsePage.previewTabResponseField()
+            .should('have.value', text);
+    },
+
+    verifyCorrectAnswerErrorMessage: () => {
+        utilities.verifyInnerText(commonComponents.errorMessage().last(), 'Error: Answer is required.');
+    },
+
+    verifyCorrectAnswerErrorMessageIsNotDisplayed: () => {
+        commonComponents.steps.verifyErrorMessageIsNotDisplayed();
+    },
+    
+    verifyCorrectAnswerWrapperNotExist: () => {
+        utilities.verifyElementVisibilityState(shortTextResponsePage.previewTabCorrectAnswerWrapper(), 'notExist');
     }
 }
 
 const tests = {
-    ...commonComponents.tests,
+    ...autoScoredScoringPreviewTab.tests,
+    ...scoringSectionBaseEditTab.tests,
+    ...autoScoredScoringSectionMultiResponseType.tests,
     ...createQuestionBasePage.tests,
-    ...questionInstructionsComponent.tests,
+    ...dialogBoxBase.tests,
+    ...commonComponents.tests,
     ...additionalSettingsPanel.tests,
-    ...scoringSectionBase.tests,
-    ...autoScoredSetCorrectAnswerSection.tests,
-    ...autoScoredScoringSection.tests,
-    ...autoScoredAdditionalSettings.tests,
-    ...specialCharactersFlyoutComponent.tests,
-    ...specialAndCustomSpecialCharactersComponent.tests,
-    ...previewScoringAndShowCorrectAnswerComponent.tests,
-    ...studentResponseAndLayoutComponent.tests,
+    ...autoScoredSpecifyCorrectAnswerSection.tests,
+
     verifyAnswerInputScoreAndCorrectIncorrectAnswerLabel: (answerInput, score, isCorrect) => {
         shortTextResponsePage.previewTabResponseField()
             .clear()
             .type(answerInput);
-        previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+        autoScoredScoringPreviewTab.previewScoreText()
             .verifyInnerText(score);
         autoScoredPreviewBase.checkAnswerButton()
             .click();
@@ -116,71 +177,42 @@ const tests = {
         };
     },
 
-    verifySetCorrectAnswerTabContentsAndFunctionality: (tabName) => {
-        it(`CSS of ${tabName} contents`, { tags: 'css' }, () => {
-            shortTextResponsePage.setCorrectAnswerResponseField()
-                .verifyCSS(css.color.text, css.fontSize.default, css.fontWeight.regular);
+    /**
+   * Verifies the contents and functionality of the 'Specify correct answer' accordion for multiple selection questions.
+   * @param {{'Correct' | 'Alternative'}} accordionName - The name of the accordion to be used in the validation.
+   * @example - verifySpecifyCorrectAnswerAccordionContentsAndFunctionality('Correct');
+   */
+    verifySpecifyCorrectAnswerAccordionContentsAndFunctionality: (accordionName) => {
+        it('User should be able to enter answer in Answer input field in specify correct answer section', () => {
+            shortTextResponsePage.steps.enterTextInAnswerInputFieldSpecifyCorrectAnswerSection('Petals');
         });
 
-        it('By default, an empty points input field and a correct answer response field', () => {
-            shortTextResponsePage.pointsInputField()
-                .should('have.value', '');
-            shortTextResponsePage.setCorrectAnswerResponseField()
-                .should('be.visible');
+        it('When user focuses in and out of the response accordion \'Answer\' input field, \'Error: Answer is required.\' error message should be displayed', () => {
+            shortTextResponsePage.steps.clearAndFocusOutOfSpecifyCorrectAnswerInputField();
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible');
+            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Answer is required.');
         });
 
-        it('User should be able to enter text in the empty response field', () => {
-            shortTextResponsePage.setCorrectAnswerResponseField()
-                .type('Lorem Ipsum')
-                .should('have.value', 'Lorem Ipsum');
-        });
+        autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredCorrectAnswerErrorMessageCSSAndA11y();
 
-        it(`When the user focuses in and out of the empty correct answer response field, \'Error: Please set a correct answer.\' validation error message should be thrown along with an error icon on the \'${tabName}\'`, () => {
-            cy.log('Pre-step : Clearing the correct answer response field')
-            shortTextResponsePage.setCorrectAnswerResponseField()
-                .clear();
-            cy.get('body')
-                .click();
-            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');
-                    });
-            };
+        it('When gives an input to \'Answer\' input field,then error message should disappear', () => {
+            shortTextResponsePage.steps.enterTextInAnswerInputFieldSpecifyCorrectAnswerSection('Nature');
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
         });
 
-        autoScoredSetCorrectAnswerSection.tests.verifyCSSAndA11yOfAutoScoredSetCorrectAnswerErrorMessage();
+        autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(accordionName);
 
-        it('CSS of response field error state', { tags: 'css' }, () => {
-            shortTextResponsePage.setCorrectAnswerResponseField()
-                .should('have.css', 'background-color', css.color.errorFieldBg)
-                .parent('.short-text-response-input-field')
-                .find('fieldset')
-                .should('have.css', 'border', `1px solid ${css.color.errorFieldBorder}`)
+        it(`CSS of ${accordionName} accordion contents`, { tags: 'css' }, () => {
+            utilities.verifyCSS(utilities.getNthElement(shortTextResponsePage.correctAnswerAccordionLabel(), 0), {
+                'color': css.color.accordionLabel,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.bold
+            });
         });
 
-        it('Accessibility of response field error state', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(shortTextResponsePage.setCorrectAnswerResponseField().parents('[class*="ShortTextResponsestyles__ResponseFieldSpecialCharacterButtonWrapper"]'));
+        it(`Accessibility of ${accordionName} accordion contents`, { tags: 'a11y' }, () => {
+            cy.checkAccessibility(shortTextResponsePage.correctAnswerAccordionLabel().parents('[aria-label="Specify correct answer section"]'));
         });
-
-        it('When the user has added text in correct answer response field, the error message should disappear', () => {
-            shortTextResponsePage.setCorrectAnswerResponseField()
-                .type('dolor sit amet')
-                .should('have.value', 'dolor sit amet');
-            commonComponents.errorMessage()
-                .should('not.exist');
-        });
-
-        autoScoredSetCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(tabName);
     },
 
     verifyMinimumScoreAwardedForIncorrectAnswer: (totalPoints) => {
@@ -196,12 +228,19 @@ const tests = {
             shortTextResponsePage.previewTabResponseField()
                 .type('Incorrect answer')
                 .blur();
-            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+            autoScoredScoringPreviewTab.previewScoreText()
                 .then(($points) => {
                     expect($points.text()).to.equal(`1/${totalPoints}`);
                 });
         });
-    }
+    },
+
+    verifyContentsOfSpecifyCorrectAnswerSection: () => {
+        it('In the \'Correct\' accordion, one answer input field should be visible', () => {
+            utilities.verifyElementVisibilityState(shortTextResponsePage.specifyCorrectAnswerResponseField(), 'visible');
+            utilities.verifyElementCount(shortTextResponsePage.specifyCorrectAnswerResponseField(), 1);
+        });
+    },
 }
 
 export const shortTextResponsePage = {

package/cypress/pages/textEntryMathPage.js

@@ -80,7 +80,8 @@ const selectors = {
     textContainersAriaLabelInputFieldNumeration: () => cy.get('[class*="ClozeMathstyle__Numeration"]'),
 
     //Preview tab
-    responseFieldPreviewTab: () => cy.get('.preview-question-text-wrapper [role="textbox"]'),
+    responseFieldPreviewTab: () => cy.get('.preview-question-text-wrapper .response-input-field'),
+    responseFieldWrapperPreviewTab: () => cy.get('.cloze-response-wrapper'),
     responseFieldNumerationPreviewTab: () => cy.get('.preview-question-text-wrapper .response-input-adornment'),
     questionContainerPreviewTab: () => cy.get('[class*="ClozeWithTextPreviewstyle__QuestionPreviewWrapper"]'),
     tickIcon: () => cy.get('.cloze-with-text-answer-status-response-preview-wrapper .tick-icon-wrapper'),
@@ -619,21 +620,39 @@ const steps = {
             });
     },
 
-    //Preview tab
+    //Preview 
+    /**
+     * This function verifies the input field text of response area
+     * @param {number} index index of response field
+     * @param {string} inputFieldText input field text in the preview tab 
+     */
+    verifyResponseAreaTextContentPreviewTab: (index, inputFieldText) => {
+        utilities.verifyTextContent(utilities.getNthElement(textEntryMathPage.responseFieldPreviewTab(), index), 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.
+    * @param {string[]} correctAnswerArray An array of arrays, each containing the expected answer options for a specific correct answer section.
     */
     verifyCorrectAnswerResponsesInCorrectAnswerSectionAndCount: (correctAnswerArray) => {
         utilities.verifyElementCount(textEntryMathPage.correctAnswersContainerResponse(), correctAnswerArray.length);
         correctAnswerArray.forEach((correctAnswer, index) => {
             utilities.verifyTextContent(utilities.getNthElement(textEntryMathPage.correctAnswersContainerResponseNumeration(), index), index + 1);
-            correctAnswer.forEach((answerOption) => {
-                utilities.verifyTextContent(utilities.getNthElement(textEntryMathPage.correctAnswersContainerResponse(), index), answerOption);
-            });
+            utilities.verifyTextContent(utilities.getNthElement(textEntryMathPage.correctAnswersContainerResponse(), index), correctAnswer);
         });
     },
 
+    /**
+    *@description Verifies the correctness of answer responses in the correct answer section, including the count.
+    * @param {string} correctAnswerArray the expected answer options aria label for a specific correct answer section.
+    */
+    verifyCorrectAnswerResponsesAriaLabel: (index, correctAnswerAriaLabel) => {
+        textEntryMathPage.correctAnswersContainerResponse()
+            .eq(index)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', correctAnswerAriaLabel);
+    },
+
     verifyResponseFieldNumerationPreviewTab: () => {
         textEntryMathPage.responseFieldNumerationPreviewTab()
             .each(($element, index) => {
@@ -662,18 +681,49 @@ const steps = {
             .click();
     },
 
+    /**
+     * This function verifies the correct/incorrect icon does not exist
+     * @param {number} index of the response field
+     */
+    verifyCorrectIncorrectIconNotExist: (index) => {
+        textEntryMathPage.responseFieldWrapperPreviewTab()
+            .eq(index)
+            .within(() => {
+                utilities.verifyElementVisibilityState(textEntryMathPage.tickIcon(), 'notExist');
+            });
+    },
+
+    /**
+     * This function verifies the correct icon for the response field
+     * @param {number} index of the response field
+     */
     verifyCorrectResponseIcon: (index) => {
         textEntryMathPage.tickIcon()
             .eq(index)
             .verifyPseudoClassBeforeProperty('color', css.color.correctAnswer);
     },
 
+    /**
+     * This function verifies the incorrect icon for the response field
+     * @param {number} index of the response field
+     */
     verifyIncorrectResponseIcon: (index) => {
         textEntryMathPage.tickIcon()
             .eq(index)
             .verifyPseudoClassBeforeProperty('color', css.color.incorrectAnswer);
     },
 
+    /**
+     * This function verifies the aria label entered in the response field 
+     * @param {string} ariaLabel of the equation entered
+     */
+    verifyResponseFieldEquationAriaLabel: (responseIndex, ariaLabel) => {
+        textEntryMathPage.responseFieldPreviewTab()
+            .eq(responseIndex)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', ariaLabel);
+    },
+
     verifyCorrectAnswerSectionNotExists: () => {
         utilities.verifyElementVisibilityState(textEntryMathPage.correctAnswersLabel(), 'notExist');
         utilities.verifyElementVisibilityState(textEntryMathPage.correctAnswersContainerResponse(), 'notExist');
@@ -696,7 +746,7 @@ const steps = {
                     utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'visible');
                 }
             });
-    },
+    }
 }
 
 const tests = {
@@ -706,6 +756,7 @@ const tests = {
     ...autoScoredSpecifyCorrectAnswerSection.tests,
     ...scoringSectionBaseEditTab.tests,
     ...autoScoredScoringSectionMultiResponseType.tests,
+    ...autoScoredScoringPreviewTab.tests,
 
     /**
      * Verifies the contents and functionality of the 'Specify correct answer' accordion for multiple selection questions.

package/package.json

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