itemengine-cypress-automation 1.0.78 → 1.0.80

package/cypress/pages/components/autoScoredScoringSectionMultipleResponsesType.js

@@ -2,7 +2,7 @@ import utilities from "../../support/helpers/utilities";
 import { commonComponents } from "./commonComponents";
 import { scoringSectionBase } from "./scoringSectionBase";
 const css = Cypress.env('css');
-
+//Enhancement: This file will get deprecated: New file - autoScoredScoringSectionMultiResponseType
 const selectors = {
     allOrNothingCheckboxLabel: () => cy.get('label[for*="defaultScoring"]'),
     allOrNothingCheckbox: () => cy.get('input[type*="radio"][aria-label="All or Nothing"]'),
@@ -10,12 +10,13 @@ const selectors = {
     partialDifferentWeightsCheckbox: () => cy.get('input[type*="radio"][aria-label="Partial - different weights"]'),
     partialEqualWeightsCheckbox: () => cy.get('input[type="radio"][aria-label="Partial - equal weights"]'),
     partialEqualWeightsCheckboxLabel: () => cy.get('label[for*="partialEqualScoring"]'),
-    pointsPerResponseLabel: () => cy.get('[class*="partial-points-per-response-label"]'),
-    partialEqualWeightsPointsPerResponseScore: () => cy.get('.cloze-with-text-partial-points'),
+    pointsPerResponseLabel: () => cy.get('[class*="PartialPointsPerResponseLabel"]'),
+    partialEqualWeightsPointsPerResponseScore: () => cy.get('[class*="EqualPoints"]'),
     penaltyPointsLabel: () => cy.get('.penalty-points-label'),
     penaltyPointsInputField: () => cy.get('.penlty-points-input-field [type="text"]'),
     rounddownScoreCheckboxLabel: () => cy.get('#rounding-dropdown-label'),
     rounddownScoreCheckbox: () => cy.get('[data-ngie-testid="round-down-score-checkbox"] input'),
+    roundingLabel: () => cy.get('#rounding-dropdown-label'),
     roundingDropdown: () => cy.get('#rounding-select'),
     roundingDropdownListOptions: (ariaLabel = null) => {
         if (ariaLabel) {
@@ -24,6 +25,7 @@ const selectors = {
             return cy.get('[aria-labelledby*="rounding-dropdown-label"] [role="option"]')
         }
     },
+    penaltyScoringLabel: () => cy.get('#penalty-scoring-dropdown-label'),
     penaltyScoringDropdown: () => cy.get('#penalty-scoring-select'),
     penaltyScoringDropdownListOptions: (ariaLabel = null) => {
         if (ariaLabel) {
@@ -32,6 +34,10 @@ const selectors = {
             return cy.get('[aria-labelledby*="penalty-scoring-dropdown-label"] [role="option"]')
         }
     },
+    minimumPointsLabel: () => cy.get('.min-score-points-label'),
+    minimumPointsInputField: () => cy.get('.min-score-points-input-field input'),
+    roundNegativeScoresToZeroCheckboxLabel: () => cy.get('[data-ngie-testid="round-negative-scores-to-zero-checkbox"]'),
+    roundNegativeScoresToZeroCheckbox: () => cy.get('[data-ngie-testid="round-negative-scores-to-zero-checkbox"] input'),
 }
 
 const steps = {
@@ -91,7 +97,7 @@ const steps = {
             .click();
     },
 
-    expandPenaltyScoringDropdown: () =>  {
+    expandPenaltyScoringDropdown: () => {
         autoScoredScoringSectionMultipleResponsesType.penaltyScoringDropdown()
             .click();
     },
@@ -201,42 +207,94 @@ const steps = {
                 .should('have.value', points);
         });
     },
+
+    verifyAllOrNothingRadioButtonIsChecked: () => {
+        autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckbox()
+            .should('be.checked');
+    },
+
+    verifyPartialEqualWeightsRadioButtonIsUnchecked: () => {
+        autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckbox()
+            .should('not.be.checked');
+    },
+
+    verifyPartialDifferentWeightsRadioButtonIsUnchecked: () => {
+        autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckbox()
+            .should('not.be.checked');
+    },
+
+    allotMinimumPoints: (points) => {
+        autoScoredScoringSectionMultipleResponsesType.minimumPointsInputField()
+            .clear()
+            .type(points)
+            .should('have.value', points);
+    },
+
+    focusInAndOutOfMinimumPointsInputField: () => {
+        autoScoredScoringSectionMultipleResponsesType.minimumPointsInputField()
+            .click()
+            .blur();
+    },
+
+    clearMinimumPointsInputField: () => {
+        autoScoredScoringSectionMultipleResponsesType.minimumPointsInputField()
+            .clear()
+            .should('have.value', '');
+    },
+
+    verifyDefaultRoundingNegativeScoresToZeroCheckboxCheckedAndLabel: () => {
+        utilities.verifyInnerText(autoScoredScoringSectionMultipleResponsesType.roundNegativeScoresToZeroCheckboxLabel(), 'Round negative scores to zero')
+        utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.roundNegativeScoresToZeroCheckboxLabel(), 'visible')
+        autoScoredScoringSectionMultipleResponsesType.roundNegativeScoresToZeroCheckbox()
+            .should('be.checked');
+    },
 }
 
 const tests = {
     verifyAutoScoredScoringTypeSectionWithCSSAnda11y: () => {
         it('\'All or nothing\', \'Partial - equal weights\' and \'Partial - different weights\' labels and radio buttons should be displayed and by default \'All or nothing\' radio button should be selected', () => {
-            autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckboxLabel()
-                .verifyInnerText('All or nothing')
-                .and('be.visible');
-            autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckbox()
-                .should('be.checked');
-            autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckboxLabel()
-                .verifyInnerText('Partial - equal weights')
-                .and('be.visible');
-            autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckbox()
-                .should('not.be.checked');
-            autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckboxLabel()
-                .verifyInnerText('Partial - different weights')
-                .and('be.visible');
-            autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckbox()
-                .should('not.be.checked');
+            utilities.verifyInnerText(autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckboxLabel(), 'All or nothing');
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckboxLabel(), 'visible');
+            autoScoredScoringSectionMultipleResponsesType.steps.verifyAllOrNothingRadioButtonIsChecked();
+            utilities.verifyInnerText(autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckboxLabel(), 'Partial - equal weights');
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckboxLabel(), 'visible');
+            autoScoredScoringSectionMultipleResponsesType.steps.verifyPartialEqualWeightsRadioButtonIsUnchecked();
+            utilities.verifyInnerText(autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckboxLabel(), 'Partial - different weights');
+            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckboxLabel(), 'visible');
+            autoScoredScoringSectionMultipleResponsesType.steps.verifyPartialDifferentWeightsRadioButtonIsUnchecked();
         });
 
         it('CSS of Scoring section', { tags: 'css' }, () => {
-            scoringSectionBase.scoringLabel()
-                .verifyCSS(css.color.sectionHeading, css.fontSize.default, css.fontWeight.semibold);
-            scoringSectionBase.scoringTypeLabel()
-                .verifyCSS(css.color.labels, css.fontSize.normal, css.fontWeight.semibold);
-            scoringSectionBase.scoringTypeDropdown()
-                .find('.dropdown-label-text')
-                .verifyCSS(css.color.liText, css.fontSize.default, css.fontWeight.regular);
-            autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckboxLabel()
-                .verifyCSS(css.color.labelText, css.fontSize.normal, css.fontWeight.regular);
-            autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckboxLabel()
-                .verifyCSS(css.color.labelText, css.fontSize.normal, css.fontWeight.regular);
-            autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckboxLabel()
-                .verifyCSS(css.color.labelText, css.fontSize.normal, css.fontWeight.regular);
+            utilities.verifyCSS(scoringSectionBase.scoringLabel(), {
+                'color': css.color.sectionHeading,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(scoringSectionBase.scoringTypeLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(scoringSectionBase.scoringTypeDropdown().find('.dropdown-label-text'), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckboxLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckboxLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckboxLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
         });
 
         it('Accessibility of Scoring Section', { tags: 'a11y' }, () => {
@@ -298,10 +356,10 @@ const tests = {
             autoScoredScoringSectionMultipleResponsesType.rounddownScoreCheckboxLabel()
                 .verifyCSS(css.color.labelText, css.fontSize.normal, css.fontWeight.regular);
             utilities.verifyCSS(autoScoredScoringSectionMultipleResponsesType.roundingDropdown(), {
-                'color' : css.color.liText,
-                'font-size' : css.fontSize.default,
-                'font-weight' : css.fontWeight.regular,
-                'border' : `1px solid ${css.color.defaultDropdownBorder}`
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+                'border': `1px solid ${css.color.defaultDropdownBorder}`
             })
         });
 

package/cypress/pages/components/autoScoredSpecifyCorrectAnswerSection.js

@@ -7,15 +7,18 @@ const css = Cypress.env('css');
 const selectors = {
     specifyCorrectAnswerLabel: () => cy.get('.set-correct-answer-label'),
     specifyCorrectAnswerHelpText: () => cy.get('.edit-set-correct-answer-help-text'),
-    alternativeAnswerButton: () => cy.get('.alternate-answer-btn-cls button'),
+    specifyCorrectAnswerSectionWrapper: () => cy.get('.edit-question-auto-scored-set-correct-answer-wrapper'),
+    alternativeAnswerButton: () => cy.get('[class*="AddAlternateAnswer"] button'),
     //TODO: Need to update the selector of correct answer accordion once a unique selector is made available
     correctAnswerAccordion: () => cy.get('.correct-answer-accordion [role="button"]').eq(0),
-    alternativeAnswerAccordion: () => cy.get('.correct-answer-accordion [role="button"]'),
+    alternativeAnswerAccordion: () => cy.get('.correct-answer-accordion .ngie-accordion-summary'),
     //TODO: Need to update the selector of correct answer accordion once a unique selector is made available
     correctAnswerAccordionLabel: () => cy.get('[class*="AnswerAccordionstyles__Label"]').eq(0),
     alternativeAnswerAccordionLabel: () => cy.get('[class*="AnswerAccordionstyles__Label"]'),
     deleteAlternateAccordionButton: () => cy.get('.answer-accordion-label button'),
     specifyCorrectAnswerErrorIcon: () => cy.get('[aria-label="Error in"]'),
+    pointsLabelAnswerAccordion: () => cy.get('[class*="AnswerAccordionstyles__PointsLabel"]'),
+    pointsAnswerAccordion: () => cy.get('[class*="PointsLabel"]').next('[class*="AnswerAccordionstyles__Points"]')
 }
 
 const steps = {
@@ -48,6 +51,29 @@ const steps = {
             .should('have.attr', 'aria-expanded', 'true');
     },
 
+    verifyCorrectAnswerAccordionIsCollapsed: () => {
+        autoScoredSpecifyCorrectAnswerSection.correctAnswerAccordion()
+            .should('have.attr', 'aria-expanded', 'false');
+    },
+
+    /**
+    * @description Verify that the alternative answer accordion is expanded
+    * @param {number} accordionIndex - The index of the alternative answer accordion 
+    */
+    verifyAlternateAnswerAccordionIsExpanded: (accordionIndex) => {
+        utilities.getNthElement(autoScoredSpecifyCorrectAnswerSection.alternativeAnswerAccordion(), accordionIndex)
+            .should('have.attr', 'aria-expanded', 'true');
+    },
+
+    /**
+    * @description Verify that the alternative answer accordion is collapsed
+    * @param {number} accordionIndex - The index of the alternative answer accordion 
+    */
+    verifyAlternateAnswerAccordionIsCollapsed: (accordionIndex) => {
+        utilities.getNthElement(autoScoredSpecifyCorrectAnswerSection.alternativeAnswerAccordion(), accordionIndex)
+            .should('have.attr', 'aria-expanded', 'false');
+    },
+
     /**
      * @description Expands the alternative answer accordion at the specified index.
      * @param {number} accordionIndex - The index of the alternative answer accordion to be expanded.
@@ -87,8 +113,24 @@ const steps = {
      * @description - This function checks if the label of the alternative answer accordion matches the expected value.
      */
     verifyAlternativeAnswerAccordionLabel: (accordionIndex) => {
-        utilities.verifyInnerText(utilities.getNthElement(autoScoredSpecifyCorrectAnswerSection.alternativeAnswerAccordion(), accordionIndex), `Alternative ${accordionIndex}`);
+        utilities.verifyInnerText(utilities.getNthElement(autoScoredSpecifyCorrectAnswerSection.alternativeAnswerAccordion().find('.answer-accordion-label'), accordionIndex), `Alternative ${accordionIndex}`);
     },
+
+    /**
+     * @param {number} accordionIndex - The index of the answer accordion.
+     * @param {string} points - The expected points value to be verified.
+     * @description Verifies the points label and points value on the specified answer accordion.
+     */
+    verifyPointsLabelAndPointsOnAnswerAccordion: (accordionIndex, points) => {
+        utilities.verifyInnerText(utilities.getNthElement(autoScoredSpecifyCorrectAnswerSection.pointsLabelAnswerAccordion(), accordionIndex), 'Points:');
+        utilities.verifyInnerText(utilities.getNthElement(autoScoredSpecifyCorrectAnswerSection.pointsAnswerAccordion(), accordionIndex), points);
+    },
+
+    verifySpecifyCorrectAnswerErrorMessage: () => {
+        commonComponents.errorMessage()
+            .last()
+            .verifyInnerText('Error: Please set a correct answer.');
+    }
 }
 
 const tests = {
@@ -128,7 +170,7 @@ const tests = {
                     helpText = 'You can set the correct answer(s) by selecting the correct answer option(s).';
                     break;
                 case 'drag and drop into categories':
-                    helpText = 'You can set the correct answer by dragging the correct answer(s) in the response area(s).';
+                    helpText = 'You can set the correct answer by dragging the correct answer(s) in the dropzone(s).';
                     break;
                 case 'list matching':
                     helpText = 'You can set the correct answer by dragging the correct answer(s) in the response area(s).'
@@ -151,6 +193,12 @@ const tests = {
                 case 'fill in the gaps over image - dropdown':
                     helpText = 'You can set the correct answer by selecting the correct answer(s) in the response area(s).';
                     break;
+                case 'text entry math':
+                    helpText = 'You can set the correct answer by entering the correct answer in the input field(s).';
+                    break;
+                case 'fill in the gaps over image - drag and drop':
+                    helpText = 'You can set the correct answer by dragging the correct answer(s) in the dropzone(s).';
+                    break;
                 default:
                     throw new Error('Invalid question type');
             }
@@ -208,10 +256,15 @@ const tests = {
             };
         });
 
-        it('When the user enters point in Points input field then the \'Error: Please enter points.\' validation text and error icon displayed on the \'Correct\' tab the should disappear', () => {
+        it(`When the user allots points then the \'Error: Please enter points.\' validation text and error icon displayed on the \'${accordionName}\' accordion should disappear, the allotted points should be displayed on the \'${accordionName}\' accordion`, () => {
             scoringSectionBase.steps.allotPoints(20);
             utilities.verifyElementVisibilityState(scoringSectionBase.pleaseEnterPointsErrorMessage(), 'notExist');
             autoScoredSpecifyCorrectAnswerSection.steps.verifySpecifyCorrectAnswerErrorIconNotExists();
+            if (accordionName === 'Correct') {
+                autoScoredSpecifyCorrectAnswerSection.steps.verifyPointsLabelAndPointsOnAnswerAccordion(0, '20');
+            } else {
+                autoScoredSpecifyCorrectAnswerSection.steps.verifyPointsLabelAndPointsOnAnswerAccordion(1, '20');
+            }
         });
     },
 
@@ -292,11 +345,14 @@ const tests = {
                 .within(() => {
                     utilities.verifyElementVisibilityState(autoScoredSpecifyCorrectAnswerSection.specifyCorrectAnswerErrorIcon(), 'visible');
                 });
-            utilities.verifyInnerText(scoringSectionBase.pleaseEnterPointsErrorMessage(), 'Error: Please enter points.');
+            utilities.verifyInnerText(utilities.getNthElement(scoringSectionBase.pleaseEnterPointsErrorMessage(), 0), 'Error: Please enter points.');
             utilities.verifyElementVisibilityState(scoringSectionBase.pleaseEnterPointsErrorMessage(), 'visible');
             if (questionType != 'list ordering') {
-                utilities.verifyInnerText(utilities.getNthElement(commonComponents.errorMessage(), 1), 'Error: Please set a correct answer.');
-                utilities.verifyElementVisibilityState(utilities.getNthElement(commonComponents.errorMessage(), 1), 'visible');
+                steps.verifySpecifyCorrectAnswerErrorMessage();
+            }
+            if (questionType === 'fill in the gaps over image text' || questionType === 'text entry math') {
+                utilities.verifyInnerText(commonComponents.errorMessage().last(), 'Error: Please enter points.');
+                utilities.verifyElementVisibilityState(commonComponents.errorMessage().last(), 'visible');
             }
         });
     },

package/cypress/pages/components/autoScoredStudentViewSettings.js

@@ -0,0 +1,141 @@
+import utilities from "../../support/helpers/utilities";
+const maxCheckAnswerAttemptsOptions = ['No limit', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10'];
+const css = Cypress.env('css');
+
+//Note: We need to work on this file, as disablePreviousIncorrectOptionLabel is not present for all auto scored question types, need to create different component files allowStudentsToCheckAnswerComponent, disablePreviousOptionComponent
+const selectors = {
+    allowStudentToCheckAnswerLabel: () => cy.get('[data-ngie-testid="allow-student-to-check-answer-checkbox"] .MuiFormControlLabel-label'),
+    allowStudentToCheckAnswerCheckbox: () => cy.get('[data-ngie-testid="allow-student-to-check-answer-checkbox"] input'),
+    maximumCheckAnswerAttemptsDropdownLabel: () => cy.get('#Maximum-check-answer-attempts-dropdown-label'),
+    maximumCheckAnswerAttemptsDropdown: () => cy.get('#Maximum-check-answer-attempts-select'),
+    maximumCheckAnswerAttemptsDropdownListOptions: (ariaLabel = null) => {
+        if (ariaLabel) {
+            return cy.get(`[aria-labelledby*="Maximum-check-answer-attempts-dropdown-label"] [role="option"][aria-label="${ariaLabel}"]`)
+        } else {
+            return cy.get('[aria-labelledby*="Maximum-check-answer-attempts-dropdown-label"] [role="option"]')
+        }
+    },
+    disablePreviousIncorrectOptionLabel: () => cy.get('[data-ngie-testid="disable-previous-incorrect-options-checkbox"] .MuiFormControlLabel-label'),
+    disablePreviousIncorrectOptionCheckbox: () => cy.get('[data-ngie-testid="disable-previous-incorrect-options-checkbox"] input')
+}
+
+const steps = {
+    verifyAllowStudentsToCheckAnswerCheckboxUnchecked: () => {
+        autoScoredStudentViewSettings.allowStudentToCheckAnswerCheckbox()
+            .should('not.be.checked');
+    },
+
+
+    checkAllowStudentsToCheckAnswerCheckbox: () => {
+        autoScoredStudentViewSettings.allowStudentToCheckAnswerCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    verifyDisablePreviousIncorrectOptionCheckboxUnchecked: () => {
+        autoScoredStudentViewSettings.disablePreviousIncorrectOptionCheckbox()
+            .should('not.be.checked');
+    },
+
+    checkDisablePreviousIncorrectOptionCheckbox: () => {
+        autoScoredStudentViewSettings.disablePreviousIncorrectOptionCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    setMaximumCheckAnswerAttempts: (maxCheckAnswerAttempts) => {
+        autoScoredStudentViewSettings.steps.checkAllowStudentToCheckAnswerCheckbox();
+        autoScoredStudentViewSettings.steps.expandMaxCheckAnswerAttemptsDropdown();
+        autoScoredStudentViewSettings.steps.addInputToMaximumCheckAnswerAttemptsInputField(maxCheckAnswerAttempts)
+    },
+
+    expandMaxCheckAnswerAttemptsDropdown: () => {
+        autoScoredStudentViewSettings.maximumCheckAnswerAttemptsDropdown()
+            .click();
+    },
+
+    /**
+     * @param {('No limit'| 'Any value from 1 to 10')} listOption 
+     * @description this function selects an option from expanded minimum scoring dropdown
+     */
+    selectMaxCheckAnswerAttemptsDropdownListOption: (listOption) => {
+        autoScoredStudentViewSettings.maximumCheckAnswerAttemptsDropdownListOptions(listOption)
+            .click();
+    },
+
+    checkAllowStudentToCheckAnswerCheckbox: () => {
+        autoScoredStudentViewSettings.allowStudentToCheckAnswerCheckbox()
+            .click()
+            .should('be.checked');
+    }
+}
+
+const tests = {
+    verifyAllowStudentsToCheckAnswerLabelAndCheckboxCSS: () => {
+        it('\'Allow student to check answer\' label and checkbox should be displayed and it should be unchecked by default', () => {
+            utilities.verifyInnerText(autoScoredStudentViewSettings.allowStudentToCheckAnswerLabel(), 'Allow student to check answer');
+            autoScoredStudentViewSettings.steps.verifyAllowStudentsToCheckAnswerCheckboxUnchecked();
+        });
+
+        it('CSS of \'Allow student to check answer\' checkbox and label - unchecked state', { tags: 'css' }, () => {
+            utilities.verifyCSS(autoScoredStudentViewSettings.allowStudentToCheckAnswerLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(autoScoredStudentViewSettings.allowStudentToCheckAnswerCheckbox().parent().find('svg'), {
+                'fill': css.color.uncheckedCheckbox
+            });
+        });
+    },
+
+    verifyMaxCheckAnswerAttemptsDropdown: () => {
+        it('\'Maximum check answer attempts\' should have \'No limit\' selected by default and on expanding the dropdown options 1 to 10 should also be displayed', () => {
+            utilities.verifyInnerText(autoScoredStudentViewSettings.maximumCheckAnswerAttemptsDropdownLabel(), 'Maximum check answer attempts');
+            utilities.verifyInnerText(autoScoredStudentViewSettings.maximumCheckAnswerAttemptsDropdown(), maxCheckAnswerAttemptsOptions[0]);
+            autoScoredStudentViewSettings.steps.expandMaxCheckAnswerAttemptsDropdown();
+            maxCheckAnswerAttemptsOptions.forEach((option, index) => {
+                utilities.verifyInnerText(utilities.getNthElement(autoScoredStudentViewSettings.maximumCheckAnswerAttemptsDropdownListOptions(), index), option)
+            });
+        });
+    },
+
+    verifyAllowStudentsToCheckAnswerContentsCSSAndA11y: () => {
+        it('CSS of \'Allow students to check answer\' section', { tags: 'css' }, () => {
+            utilities.verifyCSS(autoScoredStudentViewSettings.allowStudentToCheckAnswerLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(autoScoredStudentViewSettings.allowStudentToCheckAnswerCheckbox().parents('[data-ngie-testid="allow-student-to-check-answer-checkbox"]').find('g').eq(1), {
+                'fill': css.color.activeButtons
+            });
+            utilities.verifyCSS(autoScoredStudentViewSettings.maximumCheckAnswerAttemptsDropdownLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(autoScoredStudentViewSettings.maximumCheckAnswerAttemptsDropdown().find('span'), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(autoScoredStudentViewSettings.maximumCheckAnswerAttemptsDropdownListOptions().eq(0), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+                'background-color': css.color.liTextSelectedBg
+            });
+        });
+
+        it('Accessibility of \'Check answer\' section', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(autoScoredStudentViewSettings.allowStudentToCheckAnswerCheckbox().parents('[class*="CheckAnswerWrapper"]'));
+        });
+    }
+}
+
+export const autoScoredStudentViewSettings = {
+    ...selectors,
+    steps,
+    tests
+}

package/cypress/pages/components/autoScoredStudentViewSettingsForPredefinedOptions.js

@@ -0,0 +1,84 @@
+const selectors = {
+    randomizeOptionsLabel: () => cy.get('[data-ngie-testid="randomize-options-checkbox"] .MuiFormControlLabel-label'),
+    randomizeOptionsCheckbox: () => cy.get('[data-ngie-testid="randomize-options-checkbox"] input'),
+    lockOptionPositionLabel: () => cy.get('[data-ngie-testid="lock-option-position-checkbox"] .MuiFormControlLabel-label'),
+    lockOptionPositionCheckbox: () => cy.get('[data-ngie-testid="lock-option-position-checkbox"] input'),
+    lockUnlockOptionsButton: () => cy.get('.lock-unlock-btn-icon-wrapper button')
+}
+
+const steps = {
+    verifyRandomizeOptionsCheckboxUnchecked: () => {
+        autoScoredStudentViewSettingsForPredefinedOptions.randomizeOptionsCheckbox()
+            .should('not.be.checked');
+    },
+
+    checkRandomizeOptionsCheckbox: () => {
+        autoScoredStudentViewSettingsForPredefinedOptions.randomizeOptionsCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    uncheckRandomizeOptionsCheckbox: () => {
+        autoScoredStudentViewSettingsForPredefinedOptions.randomizeOptionsCheckbox()
+            .click();
+        steps.verifyRandomizeOptionsCheckboxUnchecked();
+    },
+
+    verifyLockOptionPositionCheckboxUnchecked: () => {
+        autoScoredStudentViewSettingsForPredefinedOptions.lockOptionPositionCheckbox()
+            .should('not.be.checked');
+    },
+
+    checkLockOptionPositionCheckbox: () => {
+        autoScoredStudentViewSettingsForPredefinedOptions.lockOptionPositionCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    /**
+     * @description this function verifies if an option is unlocked
+     * @param {number} index of the option
+     */
+    verifyOptionsUnlocked: (index) => {
+        autoScoredStudentViewSettingsForPredefinedOptions.lockUnlockOptionsButton()
+            .eq(index)
+            .should('have.attr', 'aria-label', 'Unlock option')
+    },
+
+    /**
+    * @description this function verifies if an option is locked
+    * @param {number} index of the option
+    */
+    verifyOptionsLocked: (index) => {
+        autoScoredStudentViewSettingsForPredefinedOptions.lockUnlockOptionsButton()
+            .eq(index)
+            .should('have.attr', 'aria-label', 'Lock option')
+    },
+
+    /**
+    * @description this function locks an option
+    * @param {number} index of the option to be locked
+    */
+    lockOption: (index) => {
+        autoScoredStudentViewSettingsForPredefinedOptions.lockUnlockOptionsButton()
+            .eq(index)
+            .click();
+        steps.verifyOptionsLocked(index);
+    },
+
+    /**
+    * @description this function unlocks an option
+    * @param {number} index of the option to be unlocked
+    */
+    unlockOption: (index) => {
+        autoScoredStudentViewSettingsForPredefinedOptions.lockUnlockOptionsButton()
+            .eq(index)
+            .click();
+        steps.verifyOptionsUnlocked(index);
+    }
+}
+
+export const autoScoredStudentViewSettingsForPredefinedOptions = {
+    ...selectors,
+    steps
+}

package/cypress/pages/components/backgroundImageUploadComponent.js

@@ -0,0 +1,29 @@
+import utilities from "../../support/helpers/utilities";
+
+const selectors = {
+    backgroundImageLabel: () => cy.get('[class*="Background"][class*="LabelWrapper"]'),
+    inputTypeFile: () => cy.get('input[type="file"]'),
+    uploadLabel: () => cy.get('[class*="SimpleImageUploaderstyles__LabelWrapper"]').eq(0),
+    fileNameLabel: () => cy.get('[class*="SimpleImageUploaderstyles__LabelWrapper"]').eq(1),
+    fileUploadSection: () => cy.get('.file-input-wrapper'),
+    chooseFileButton: () => cy.get('.choose-file-button'),
+    noFileChosenLabel: () => cy.get('[aria-label="No file chosen"]'),
+    uploadImageProgressBar: () => cy.get('[class*="ProgressBar"]'),
+    uploadedFileNameLabel: () => cy.get('[class*="SimpleImageUploaderstyles__SelectedFile-"]'),
+}
+
+const steps = {
+    /**
+     * @param {string} file name of the file in fixtures/upload folder
+     * @description this function uploads a file
+     */
+    uploadFile: (file) => {
+        backgroundImageUploadComponent.inputTypeFile()
+            .attachFile(`uploads/${file}`);
+    }
+}
+
+export const backgroundImageUploadComponent = {
+    ...selectors,
+    steps
+}

package/cypress/pages/components/ckEditorToolbar.js

@@ -23,6 +23,7 @@ const steps = {
 
     selectImageOptionFromCKEditorToolbar: () => {
         ckEditorToolbar.imageIcon()
+            .scrollIntoView()
             .click();
     },
 

package/cypress/pages/components/commonComponents.js

@@ -4,7 +4,7 @@ const css = Cypress.env('css');
 
 const selectors = {
     previewTabQuestionWrapper: () => cy.get('.edit-question-preview-wrapper'),
-    tooltipText: () => cy.get('.MuiTooltip-tooltip'),
+    tooltipText: () => cy.get('[class*="MuiTooltip-tooltip"]'),
     snackbar: () => cy.get('.MuiSnackbarContent-message'),
     snackbarCloseButton: () => cy.get('.MuiSnackbarContent-action'),
     errorMessage: () => cy.get('.error-text-message'),
@@ -64,20 +64,27 @@ const steps = {
         commonComponents.snackbarCloseButton()
             .click();
         utilities.verifyElementVisibilityState(commonComponents.snackbar(), 'notExist');
-    }
+    },
+
+    verifyDropdownIsCollapsed: () => {
+        utilities.verifyElementVisibilityState(commonComponents.dropdownList(), 'notExist');
+    },
 }
 
 const tests = {
-    verifya11yOfCreateItemWrapperContents: () => {
+    verifyCreateItemWrapperContentsA11y: () => {
         it('Accessibility of create item wrapper contents', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(commonComponents.nextGenCreateItemWrapper())
+            cy.checkAccessibility(commonComponents.nextGenCreateItemWrapper());
         });
     },
 
-    verifyCSSAnda11yOfErrorMessage: () => {
+    verifyErrorMessageCSSAndA11y: () => {
         it('CSS of error message', { tags: 'css' }, () => {
-            commonComponents.errorMessage()
-                .verifyCSS(css.color.errorText, css.fontSize.small, css.fontWeight.regular);
+            utilities.verifyCSS(commonComponents.errorMessage(), {
+                'color': css.color.errorText,
+                'font-size': css.fontSize.small,
+                'font-weight': css.fontWeight.regular
+            });
         });
 
         it('Accessibility of error message', { tags: 'a11y' }, () => {