itemengine-cypress-automation 1.0.2

package/cypress/pages/readingRulerPage.js

@@ -0,0 +1,302 @@
+import utilities from "../support/helpers/utilities";
+import { createQuestionBasePage, additionalSettingsPanel } from "./components";
+import { dialogBoxBase } from "./dialogBoxBase";
+import { selectQuestionResourceToolPage } from "./selectQuestionResourceToolPage";
+const css = Cypress.env('css');
+
+const selectors = {
+    ...additionalSettingsPanel,
+    //TODO: Need to update selectors https://redmine.zeuslearning.com/issues/518498
+    displayButtonToStudentLabel: () => cy.get('[data-ngie-testid="display-button-to-student-checkbox"] .MuiFormControlLabel-label'),
+    allowStudentToResizeLabel: () => cy.get('[data-ngie-testid="allow-student-to-resize-checkbox"] .MuiFormControlLabel-label'),
+    visibleOnLandingLabel: () => cy.get('[data-ngie-testid="visible-on-landing-checkbox"] .MuiFormControlLabel-label'),
+    displayButtonToStudentCheckbox: () => cy.get('[data-ngie-testid="display-button-to-student-checkbox"] input[type="checkbox"]'),
+    allowStudentToResizeCheckbox: () => cy.get('[data-ngie-testid="allow-student-to-resize-checkbox"] input[type="checkbox"]'),
+    visibleOnLandingCheckbox: () => cy.get('[data-ngie-testid="visible-on-landing-checkbox"] input[type="checkbox"]'),
+    readingRulerEditWrapper: () => cy.get('.resource-and-tool-tablist-wrapper'),
+    opacityLabel: () => cy.get('#input-slider'),
+    opacityInputField: () => cy.get('.line-reader-opacity input'),
+    opacitySlider: () => cy.get('.MuiSlider-root'),
+    colorLabel: () => cy.get('[class*="LineReaderstyles__PropertyLabel"]').eq(1),
+    colorBlock: () => cy.get('.MuiFormGroup-root .MuiRadio-root'),
+    colorBlockLabel: () => cy.get('.MuiFormControl-root .MuiFormControlLabel-root .MuiTypography-root'),
+    defaultNumberOfLinesLabel: () => cy.get('[class*="LineReaderstyles__PropertyLabel"]').eq(2),
+    defaultNumberOfLinesInputField: () => cy.get('input[aria-label="Default number of lines"]'),
+    //Preview Tab
+    readingRulerButton: () => cy.get('.LineReaderButton'),
+    readingRuler: () => cy.get('.resizable'),
+    closeButton: () => cy.get('.LineReaderCloseButton'),
+    dragButton: () => cy.get('.LineReaderMoveButton'),
+    resizeButton: () => cy.get('.resizeMaskButton'),
+    topResizeButton: () => cy.get('.resizeTopWindowButton'),
+    bottomResizeButton: () => cy.get('.resizeBottomWindowButton'),
+    previewWrapper: () => cy.get('[class*="TabsComponentstyles__PreviewWrapper"]'),
+    rulerOpacity: () => cy.get('.resizable [class*="LineReaderComponentstyles__LineReaderMask"]').eq(0),
+    rulerColor: () => cy.get('.resizable [class*="LineReaderComponentstyles__LineReaderMask"]').eq(0),
+}
+
+const steps = {
+    ...createQuestionBasePage.steps,
+    ...additionalSettingsPanel.steps,
+
+    verifyDisplayButtonToStudentCheckboxIsChecked: () => {
+        readingRulerPage.displayButtonToStudentCheckbox()
+            .should('be.checked');
+    },
+
+    verifyAllowStudentToResizeCheckboxIsChecked: () => {
+        readingRulerPage.allowStudentToResizeCheckbox()
+            .should('be.checked');
+    },
+
+    verifyVisibleOnLandingCheckboxIsUnchecked: () => {
+        readingRulerPage.visibleOnLandingCheckbox()
+            .should('not.be.checked');
+    },
+
+    verifyDefaultNumberOfLinesInputFieldValue: (value) => {
+        readingRulerPage.defaultNumberOfLinesInputField()
+            .should('have.value', value)
+    },
+
+    verifyOpacityInputFieldValue: (opacityValue) => {
+        readingRulerPage.opacityInputField()
+            .should('have.value', opacityValue)
+    },
+
+    verifyOpacitySliderValue: (opacityValue) => {
+        readingRulerPage.opacitySlider()
+            .find('input')
+            .should('have.value', opacityValue)
+    },
+
+    verifyMaxOpacitySliderValue: (maxValue) => {
+        readingRulerPage.opacitySlider()
+            .find('[role="slider"]')
+            .should('have.attr', 'aria-valuemax', maxValue)
+    },
+
+    verifyColorBlock: (blockIndex, colorLabel, color) => {
+        utilities.verifyCSS(readingRulerPage.colorBlock().eq(blockIndex), {
+            'background-color': color
+        });
+        utilities.verifyElementVisibilityState(readingRulerPage.colorBlockLabel().eq(blockIndex), 'visible');
+        utilities.verifyInnerText(readingRulerPage.colorBlockLabel().eq(blockIndex), colorLabel);
+    },
+
+    verifyColorBlockSelectedState: (blockIndex) => {
+        readingRulerPage.colorBlock()
+            .eq(blockIndex)
+            .find('svg')
+            .should('be.visible');
+    },
+
+    verifyColorBlockUnSelectedState: (blockIndex) => {
+        readingRulerPage.colorBlock()
+            .eq(blockIndex)
+            .find('svg')
+            .should('not.exist');
+    },
+
+    selectColorBlock: (blockIndex) => {
+        readingRulerPage.colorBlock()
+            .eq(blockIndex)
+            .click();
+    },
+
+    addInputToOpacityInputField: (value) => {
+        readingRulerPage.opacityInputField()
+            .clear()
+            .type(value, { delay: 0 })
+    },
+
+    addInputToDefaultNumberOfLinesInputField: (value) => {
+        readingRulerPage.defaultNumberOfLinesInputField()
+            .clear()
+            .type(value, { delay: 0 })
+    },
+
+    clickOnOpacitySlider: () => {
+        readingRulerPage.opacitySlider()
+            .click();
+    },
+
+    //Conditional checkboxes
+    checkDisplayButtonToStudentCheckbox: () => {
+        readingRulerPage.displayButtonToStudentCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    uncheckDisplayButtonToStudentCheckbox: () => {
+        readingRulerPage.displayButtonToStudentCheckbox()
+            .click()
+            .should('not.be.checked');
+    },
+
+    checkAllowStudentToResizeCheckbox: () => {
+        readingRulerPage.allowStudentToResizeCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    uncheckAllowStudentToResizeCheckbox: () => {
+        readingRulerPage.allowStudentToResizeCheckbox()
+            .click()
+            .should('not.be.checked');
+    },
+
+    checkVisibleOnLandingCheckbox: () => {
+        readingRulerPage.visibleOnLandingCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    uncheckVisibleOnLandingCheckbox: () => {
+        readingRulerPage.visibleOnLandingCheckbox()
+            .click()
+            .should('not.be.checked');
+    },
+
+    verifySelectedStateOfReadingRulerButton: () => {
+        readingRulerPage.readingRulerButton()
+            .should('have.class', 'active');
+    },
+
+    verifyUnselectedStateOfReadingRulerButton: () => {
+        readingRulerPage.readingRulerButton()
+            .should('not.have.class', 'active');
+    },
+
+    clickOnReadingRulerButton: () => {
+        readingRulerPage.readingRulerButton()
+            .click({ force: true });
+    },
+
+    verifyResizeButtonsEnabled: () => {
+        readingRulerPage.resizeButton()
+            .should('be.enabled');
+        readingRulerPage.topResizeButton()
+            .should('be.enabled');
+        readingRulerPage.bottomResizeButton()
+            .should('be.enabled');
+    },
+
+    verifyCloseButtonEnabled: () => {
+        readingRulerPage.closeButton()
+            .should('be.enabled');
+    },
+
+    verifyDragButtonEnabled: () => {
+        readingRulerPage.dragButton()
+            .should('be.enabled');
+    },
+
+    verifyResizeButtonDisabled: () => {
+        readingRulerPage.resizeButton()
+            .should('be.disabled');
+        readingRulerPage.topResizeButton()
+            .should('be.disabled');
+        readingRulerPage.bottomResizeButton()
+            .should('be.disabled');
+    },
+
+    hoverOnReadingRulerButton: () => {
+        readingRulerPage.readingRulerButton()
+            .realHover()
+    },
+
+    hoverAwayFromReadingRulerButton: () => {
+        readingRulerPage.readingRulerButton()
+            .realHover({ position: 'topLeft' })
+    },
+
+    clickOnCloseButtonInReadingRuler: () => {
+        readingRulerPage.closeButton()
+            .click()
+    },
+
+    /**
+     * @param {number} opacityValue opacity of the ruler
+     * @description this function verifies opacity of the ruler displayed in the preview tab
+     */
+    verifyReadingRulerOpacityInPreviewTab: (opacityValue) => {
+        readingRulerPage.rulerOpacity()
+            .should('have.attr', 'opacity', opacityValue)
+    },
+
+    /**
+     * @param {string} colorValue color of the ruler
+     * @description this function verifies color of the ruler displayed in the preview tab
+     */
+    verifyReadingRulerColorInPreviewTab: (colorValue) => {
+        readingRulerPage.rulerColor()
+            .should('have.attr', 'color', colorValue)
+    },
+
+    /**
+     * @param {number} heightValue height of the ruler
+     * @param {number} sizeValue size of the ruler
+     * @description this function verifies height and size of ruler displayed in the preview tab
+     */
+    verifyHeightAndSizeOfReadingRuler: (heightValue, sizeValue) => {
+        readingRulerPage.readingRuler()
+            .should('have.attr', 'height', heightValue)
+            .should('have.attr', 'size', sizeValue)
+    },
+
+    //additional settings
+    addTextToTeacherGuidelinesInputField: () => {
+        readingRulerPage.additionalSettingsTeacherGuidelinesInputField()
+            .type('Teacher scoring guidelines', { delay: 0 })
+            .blur();
+    },
+}
+
+const tests = {
+    ...createQuestionBasePage.tests,
+    ...additionalSettingsPanel.tests,
+    //Header section
+    verifyCancelButton: () => {
+        it('When user has made no edits and clicks on Cancel button, the user should be directed back to the \'Select a Question\' page', () => {
+            createQuestionBasePage.cancelButton()
+                .click();
+            utilities.verifyElementVisibilityState(selectQuestionResourceToolPage.selectAQuestionHeaderText(), 'visible');
+            utilities.verifyElementVisibilityState(selectQuestionResourceToolPage.questionTypeOptionTitle(), 'visible');
+        });
+
+        it('When user has made some edits/changes and clicks on Cancel button, a popup should be displayed', () => {
+            selectQuestionResourceToolPage.steps.selectResourceType('Reading ruler');
+            utilities.verifyElementVisibilityState(readingRulerPage.opacityInputField(), 'visible');
+            readingRulerPage.steps.addInputToOpacityInputField('30');
+            createQuestionBasePage.cancelButton()
+                .click();
+            utilities.verifyElementVisibilityState(dialogBoxBase.dialogBox(), 'visible')
+        });
+
+        dialogBoxBase.tests.verifyContentsOfLeavePagePopupWithCSSAnda11y();
+
+        it(`Clicking on \'No, I'd like to go back\' button should close the popup and user should remain on the edit interface of the question`, () => {
+            dialogBoxBase.buttonReject()
+                .click();
+            createQuestionBasePage.editTab()
+                .should('have.attr', 'aria-selected', 'true')
+            readingRulerPage.steps.verifyOpacityInputFieldValue('30');
+        });
+
+        it(`Clicking on \'Yes, I want to leave this page\' button should discard all changes and direct the user to the \'Select a question\' page.`, () => {
+            createQuestionBasePage.cancelButton()
+                .click();
+            dialogBoxBase.buttonAccept()
+                .click();
+            utilities.verifyElementVisibilityState(selectQuestionResourceToolPage.selectAQuestionHeaderText(), 'visible');
+            utilities.verifyElementVisibilityState(selectQuestionResourceToolPage.questionTypeOptionTitle(), 'visible');
+        });
+    },
+}
+
+export const readingRulerPage = {
+    ...selectors,
+    steps,
+    tests
+}

package/cypress/pages/selectQuestionResourceToolPage.js

@@ -0,0 +1,64 @@
+const selectors = {
+    questionTypeOptionTitle: (ariaLabel = null) => {
+        if (ariaLabel) {
+            return cy.get(`.type-card-container [aria-label="${ariaLabel}"]`)
+        } else {
+            return cy.get('.type-card-container')
+        }
+    },
+    selectAQuestionHeaderText: () => cy.get('[class*="QuestionResourceToolstyles__HeaderText"]'),
+    questionTypeCategory: () => cy.get('[class*="QuestionResourceToolstyles__CategorySection"]'),
+    resourceTypeCategory: () => cy.get('.MuiCard-root')
+}
+
+const questionTypeCategoryMap = {
+    'multiple selection': 'Multiple choice selection',
+    'single selection': 'Multiple choice selection',
+    'single selection - block': 'Multiple choice selection',
+    'true or false': 'Multiple choice selection',
+    'single selection grid': 'Multiple choice selection',
+    'multiple selection grid': 'Multiple choice selection',
+    'multiple selection - block': 'Multiple choice selection',
+    'fill in the gaps with dropdown': 'Fill in the gaps',
+    'fill in the gaps with text': 'Fill in the gaps',
+    'fill in the gaps over image - dropdown': 'Fill in the gaps',
+    'fill in the gaps over image - text': 'Fill in the gaps',
+    'fill in the gaps with drag and drop': 'Fill in the gaps',
+    'drag and drop into categories': 'Drag and drop',
+    'list matching': 'List',
+    'list ordering': 'List',
+    'list sorting': 'List',
+    'essay response - rich text': 'Constructed response',
+    'essay response - basic': 'Constructed response',
+    'essay response - math': 'Constructed response',
+    'short text response': 'Constructed response',
+    'upload response': 'Recorded response',
+    'audio response': 'Recorded response',
+    'video response': 'Recorded response',
+    'highlight': 'Highlight',
+    'highlight image': 'Highlight',
+    'feedback scale': 'Miscellaneous',
+}
+
+const steps = {
+    //TODO: Need to update this for all question types on high priority
+    selectQuestionType: (questionType) => {
+        const questionCategory = questionTypeCategoryMap[questionType];
+        selectQuestionResourceToolPage.questionTypeCategory()
+            .contains(questionCategory)
+            .click();
+        selectQuestionResourceToolPage.questionTypeOptionTitle(questionType)
+            .click();
+    },
+
+    selectResourceType: (resourceCategory) => {
+        selectQuestionResourceToolPage.resourceTypeCategory()
+            .contains(resourceCategory)
+            .click();
+    }
+}
+
+export const selectQuestionResourceToolPage = {
+    ...selectors,
+    steps
+}

package/cypress/pages/shortTextResponsePage.js

@@ -0,0 +1,197 @@
+import { questionInstructionsComponent, scoringSectionBase, createQuestionBasePage, additionalSettingsPanel, commonComponents, autoScoredPreviewBase, autoScoredSetCorrectAnswerSection, autoScoredScoringSection, autoScoredAdditionalSettings, specialCharactersFlyoutComponent, specialAndCustomSpecialCharactersComponent, previewScoringAndShowCorrectAnswerComponent } from "./components/";
+import { studentResponseAndLayoutComponent } from "./components/studentResponseAreaAndLayoutComponent";
+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'),
+    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'),
+    ignoreSpacesBeforeAndAfterCheckboxLabel: () => cy.get('[data-ngie-testid="ignore-spaces-before-and-after-checkbox"] .MuiFormControlLabel-label').eq(1),
+    exactRadioButton: () => cy.get('input[aria-label="Exact"]'),
+    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'),
+    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"]'),
+    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'),
+    //Additional settings
+    ariaLabelLabel: () => cy.get('[class*="ShortTextResponsestyle__AriaLabelWrapper"] .text-label'),
+    ariaLabelInputField: () => cy.get('.input-field [aria-label="ARIA label"]'),
+    placeholderTextLabel: () => cy.get('[class*="ShortTextResponsestyle__PlaceholderWrapper"] .text-label'),
+    placeholderTextInputField: () => cy.get('input[aria-label="Placeholder Text"]'),
+    typeOfAnswerInputLabel: () => cy.get('#Type-of-Answer-input-dropdown-label'),
+    typeOfAnswerInputDropdown: () => cy.get('#Type-of-Answer-input-select'),
+    typeOfAnswerInputDropdownListOptions: (optionNumber) => cy.get('[aria-labelledby*="Type-of-Answer-input"] .dropdown-menu-item').eq(optionNumber),
+    setCharacterLimitLabel: () => cy.get('label[aria-labelledby="Set character limit"]'),
+    setCharacterLimitInputField: () => cy.get('input[aria-label="Set character limit"]'),
+    spellCheckLabel: () => cy.get('[data-ngie-testid="spell-check-checkbox"] .MuiFormControlLabel-label'),
+    spellCheckCheckbox: () => cy.get('[data-ngie-testid="spell-check-checkbox"] input')
+}
+
+const steps = {
+    ...createQuestionBasePage.steps,
+    ...questionInstructionsComponent.steps,
+    ...scoringSectionBase.steps,
+    ...additionalSettingsPanel.steps,
+    ...autoScoredSetCorrectAnswerSection.steps,
+    ...autoScoredAdditionalSettings.steps,
+    ...autoScoredPreviewBase.steps,
+    ...specialCharactersFlyoutComponent.steps,
+    verifyCorrectOptionCheckmarkIcon: () => {
+        autoScoredPreviewBase.correctIcon()
+            .should('be.visible');
+    },
+
+    verifyIncorrectOptionCrossmarkIcon: () => {
+        autoScoredPreviewBase.incorrectIcon()
+            .should('be.visible');
+    },
+
+    verifyCorrectAnswerResponsesInCorrectAnswerContainerAndCount: (correctAnswer) => {
+        shortTextResponsePage.previewTabCorrectAnswerContainer()
+            .should('be.visible');
+        shortTextResponsePage.previewTabCorrectAnswerResponse()
+            .verifyInnerText(correctAnswer)
+        shortTextResponsePage.previewTabCorrectAnswerResponse()
+            .should('have.length', 1);
+    }
+}
+
+const tests = {
+    ...commonComponents.tests,
+    ...createQuestionBasePage.tests,
+    ...questionInstructionsComponent.tests,
+    ...additionalSettingsPanel.tests,
+    ...scoringSectionBase.tests,
+    ...autoScoredSetCorrectAnswerSection.tests,
+    ...autoScoredScoringSection.tests,
+    ...autoScoredAdditionalSettings.tests,
+    ...specialCharactersFlyoutComponent.tests,
+    ...specialAndCustomSpecialCharactersComponent.tests,
+    ...previewScoringAndShowCorrectAnswerComponent.tests,
+    ...studentResponseAndLayoutComponent.tests,
+    verifyAnswerInputScoreAndCorrectIncorrectAnswerLabel: (answerInput, score, isCorrect) => {
+        shortTextResponsePage.previewTabResponseField()
+            .clear()
+            .type(answerInput);
+        previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+            .verifyInnerText(score);
+        autoScoredPreviewBase.checkAnswerButton()
+            .click();
+        if (isCorrect) {
+            autoScoredPreviewBase.correctIcon()
+                .should('be.visible');
+        } else {
+            autoScoredPreviewBase.incorrectIcon()
+                .should('be.visible');
+        };
+    },
+
+    verifySetCorrectAnswerTabContentsAndFunctionality: (tabName) => {
+        it(`CSS of ${tabName} contents`, { tags: 'css' }, () => {
+            shortTextResponsePage.setCorrectAnswerResponseField()
+                .verifyCSS(css.color.text, css.fontSize.default, css.fontWeight.regular);
+        });
+
+        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('User should be able to enter text in the empty response field', () => {
+            shortTextResponsePage.setCorrectAnswerResponseField()
+                .type('Lorem Ipsum')
+                .should('have.value', 'Lorem Ipsum');
+        });
+
+        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');
+                    });
+            };
+        });
+
+        autoScoredSetCorrectAnswerSection.tests.verifyCSSAndA11yOfAutoScoredSetCorrectAnswerErrorMessage();
+
+        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('Accessibility of response field error state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(shortTextResponsePage.setCorrectAnswerResponseField().parents('[class*="ShortTextResponsestyles__ResponseFieldSpecialCharacterButtonWrapper"]'));
+        });
+
+        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) => {
+        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()
+            shortTextResponsePage.previewTabResponseField()
+                .type('Incorrect answer')
+                .blur();
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .then(($points) => {
+                    expect($points.text()).to.equal(`1/${totalPoints}`);
+                });
+        });
+    }
+}
+
+export const shortTextResponsePage = {
+    ...selectors,
+    steps,
+    tests
+}