itemengine-cypress-automation 1.0.553-IEI-7000-main-8cb7c78.0 → 1.0.554-IEI-5835-LIVE-30c8e27.0

package/cypress/pages/liveStudentViewBase.js

@@ -0,0 +1,183 @@
+import utilities from "../support/helpers/utilities";
+
+/**
+ * Live Student View Base - Common functionality for all question types
+ * This module provides reusable Live Student View functionality that works with any question type
+ */
+
+const css = Cypress.env('css');
+
+const selectors = {
+    // Main Live Student View containers - common to all question types
+    student1Container: () => cy.get('#nextgen-live-student1'),
+    student2Container: () => cy.get('#nextgen-live-student2'),
+    studentsWrapper: () => cy.get('.LiveStudentViewstyles__StudentsWrapper-hx9itz-3'),
+    
+    // Student headers - common to all question types
+    student1Header: () => cy.get('#nextgen-live-student1').parent().find('.LiveStudentViewstyles__LiveStudentHeader-hx9itz-2').contains('Student-1'),
+    student2Header: () => cy.get('#nextgen-live-student2').parent().find('.LiveStudentViewstyles__LiveStudentHeader-hx9itz-2').contains('Student-2'),
+
+    // Multiple Session Live Student View selectors - common to all question types
+    pageTitle: () => cy.get('[id="header-title"]'),
+    enableLiveClassCheckbox: () => cy.get('[data-ngie-testid="enable-live-class-checkbox"]'),
+    enableLiveClassCheckboxInput: () => cy.get('[data-ngie-testid="enable-live-class-checkbox"] input[type="checkbox"]'),
+    getStudentViewSessionDataButton: () => cy.contains('button', 'Get student view session data'),
+    refreshUserResponsesButton: () => cy.contains('button', 'Refresh User Responses'),
+    launchGradingButton: () => cy.get('[data-testid="launchGrading"]'),
+    resetFieldsButton: () => cy.contains('button', 'Reset Fields')
+}
+
+const steps = {
+    /**
+     * Common navigation methods - works for all question types
+     */
+    navigateToLiveStudentView: (itemReferenceID) => {
+        const encodedId = utilities.base64Encoding(itemReferenceID);
+        cy.visit(`/item-engine/demo/live-student-view/${encodedId}`);
+        cy.wait(2000); // Wait for page to load
+    },
+
+    navigateToMultipleSessionLiveStudentView: () => {
+        cy.visit('/item-engine/multiple-session/live-student-view');
+        cy.wait(2000); // Wait for page to load
+    },
+
+    navigateToMultipleSessionWithItem: (itemReferenceID = null) => {
+        if (itemReferenceID) {
+            const encodedId = utilities.base64Encoding(itemReferenceID);
+            cy.visit(`/item-engine/multiple-session/live-student-view/${encodedId}`);
+        } else {
+            liveStudentViewBase.steps.navigateToMultipleSessionLiveStudentView();
+        }
+        cy.wait(2000); // Wait for page to load
+    },
+
+    /**
+     * Common verification methods - works for all question types
+     */
+    verifyBothStudentContainersExist: () => {
+        liveStudentViewBase.student1Container().should('exist').should('be.visible');
+        liveStudentViewBase.student2Container().should('exist').should('be.visible');
+    },
+    
+    verifyStudentHeaders: () => {
+        liveStudentViewBase.student1Header().should('be.visible');
+        liveStudentViewBase.student2Header().should('be.visible');
+    },
+
+    /**
+     * Multiple Session Live Student View methods - common to all question types
+     */
+    verifyMultipleSessionPageTitle: () => {
+        liveStudentViewBase.pageTitle().should('contain.text', 'Multiple Session Grading View');
+    },
+
+    checkEnableLiveClassCheckbox: () => {
+        liveStudentViewBase.enableLiveClassCheckboxInput().then(($checkbox) => {
+            if (!$checkbox.is(':checked')) {
+                liveStudentViewBase.enableLiveClassCheckbox().click();
+            }
+        });
+    },
+
+    verifyEnableLiveClassCheckboxIsChecked: () => {
+        liveStudentViewBase.enableLiveClassCheckboxInput().should('be.checked');
+    },
+
+    verifyEnableLiveClassCheckboxIsUnchecked: () => {
+        liveStudentViewBase.enableLiveClassCheckboxInput().should('not.be.checked');
+    },
+
+    clickGetStudentViewSessionDataButton: () => {
+        liveStudentViewBase.getStudentViewSessionDataButton().should('be.visible').click();
+    },
+
+    clickRefreshUserResponsesButton: () => {
+        liveStudentViewBase.refreshUserResponsesButton().should('be.visible').click();
+    },
+
+    clickLaunchGradingButton: () => {
+        liveStudentViewBase.launchGradingButton().should('be.visible').click();
+    },
+
+    clickResetFieldsButton: () => {
+        liveStudentViewBase.resetFieldsButton().should('be.visible').click();
+    },
+}
+
+/**
+ * Common tests that work for all question types
+ */
+const tests = {
+    /**
+     * Verifies Live Student View interface - common to all question types
+     */
+    verifyLiveStudentViewInterface: () => {
+        it('Both student containers should exist and be visible', () => {
+            liveStudentViewBase.steps.verifyBothStudentContainersExist();
+            liveStudentViewBase.steps.verifyStudentHeaders();
+        });
+    },
+
+    /**
+     * Verifies Multiple Session Live Student View functionality - common to all question types
+     */
+    verifyMultipleSessionLiveStudentView: () => {
+        it('Navigate to Multiple Session Live Student View and interact with Live Class controls', () => {
+            liveStudentViewBase.steps.navigateToMultipleSessionLiveStudentView();
+            liveStudentViewBase.steps.verifyMultipleSessionPageTitle();
+            liveStudentViewBase.steps.checkEnableLiveClassCheckbox();
+            liveStudentViewBase.steps.verifyEnableLiveClassCheckboxIsChecked();
+            liveStudentViewBase.steps.clickGetStudentViewSessionDataButton();
+            liveStudentViewBase.steps.clickLaunchGradingButton();
+        });
+    },
+
+    /**
+     * Common accessibility test for Live Student View - works with any question type
+     */
+    verifyLiveStudentViewAccessibility: () => {
+        it('Accessibility of Live Student View containers', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(liveStudentViewBase.studentsWrapper());
+        });
+    },
+
+    /**
+     * Common navigation test - works with any question type
+     */
+    verifyLiveStudentViewNavigation: (itemReferenceID) => {
+        it('Should successfully navigate to Live Student View', () => {
+            liveStudentViewBase.steps.navigateToLiveStudentView(itemReferenceID);
+            liveStudentViewBase.steps.verifyBothStudentContainersExist();
+        });
+    }
+}
+
+/**
+ * Helper function to get student-specific selectors for any question type
+ * @param {number} studentNum - Student number (1 or 2)
+ * @param {string} selector - The selector string to find within student container
+ * @returns {Cypress.Chainable} - Cypress element within specific student container
+ */
+const getStudentSpecificElement = (studentNum, selector) => {
+    const container = studentNum === 1 ? liveStudentViewBase.student1Container() : liveStudentViewBase.student2Container();
+    return container.find(selector);
+}
+
+/**
+ * Helper function to perform actions within a specific student container
+ * @param {number} studentNum - Student number (1 or 2)
+ * @param {function} callback - Callback function to execute within student container
+ */
+const withinStudentContainer = (studentNum, callback) => {
+    const container = studentNum === 1 ? liveStudentViewBase.student1Container() : liveStudentViewBase.student2Container();
+    container.within(callback);
+}
+
+export const liveStudentViewBase = {
+    ...selectors,
+    steps,
+    tests,
+    getStudentSpecificElement,
+    withinStudentContainer
+}

package/cypress/pages/liveStudentViewPage.js

@@ -0,0 +1,227 @@
+import constants from "../fixtures/constants";
+import utilities from "../support/helpers/utilities";
+import { multipleSelectionPage } from "./multipleSelectionPage";
+import { liveStudentViewBase } from "./liveStudentViewBase";
+
+const css = Cypress.env('css');
+
+const selectors = {
+    // Import common Live Student View selectors from base
+    ...liveStudentViewBase,
+    
+    // Question elements - reusing multipleSelectionPage selectors
+    questionInstructions: (studentNum = null) => {
+        if (studentNum === 1) {
+            return liveStudentViewBase.student1Container().find('[data-testid="question-instruction-element"]');
+        } else if (studentNum === 2) {
+            return liveStudentViewBase.student2Container().find('[data-testid="question-instruction-element"]');
+        }
+        return multipleSelectionPage.questionInstructionsText();
+    },
+    
+    // Option elements - reusing multipleSelectionPage selectors
+    optionCheckboxes: (studentNum = null) => {
+        if (studentNum === 1) {
+            return liveStudentViewBase.student1Container().find('[data-ngie-testid="response-option-checkbox"]');
+        } else if (studentNum === 2) {
+            return liveStudentViewBase.student2Container().find('[data-ngie-testid="response-option-checkbox"]');
+        }
+        return multipleSelectionPage.optionsCheckboxWrapperPreviewTab();
+    },
+    
+    optionInputs: (studentNum = null) => {
+        if (studentNum === 1) {
+            return liveStudentViewBase.student1Container().find('[data-ngie-testid="response-option-checkbox"] [type="checkbox"]');
+        } else if (studentNum === 2) {
+            return liveStudentViewBase.student2Container().find('[data-ngie-testid="response-option-checkbox"] [type="checkbox"]');
+        }
+        return multipleSelectionPage.optionsCheckboxPreviewTab();
+    },
+    
+    // Multiple Selection specific option types - using base helper functions
+    imageOption: (studentNum, optionIndex = 0) => {
+        return liveStudentViewBase.getStudentSpecificElement(studentNum, '[data-ngie-testid="response-option-checkbox"]').eq(optionIndex).find('img');
+    },
+    
+    boldTextOption: (studentNum, optionIndex = 1) => {
+        return liveStudentViewBase.getStudentSpecificElement(studentNum, '[data-ngie-testid="response-option-checkbox"]').eq(optionIndex).find('strong');
+    },
+    
+    equationOption: (studentNum, optionIndex = 2) => {
+        return liveStudentViewBase.getStudentSpecificElement(studentNum, '[data-ngie-testid="response-option-checkbox"]').eq(optionIndex).find('.mathjx-rendered');
+    }
+}
+
+const steps = {
+    // Import common Live Student View steps from base
+    ...liveStudentViewBase.steps,
+    
+    // Multiple Selection specific student interactions
+    selectOptionForStudent: (studentNum, optionIndex) => {
+        liveStudentViewBase.withinStudentContainer(studentNum, () => {
+            // Use multipleSelectionPage method for consistent checkbox clicking
+            multipleSelectionPage.optionsCheckboxWrapperPreviewTab().eq(optionIndex).click();
+        });
+        cy.wait(2000); // Wait for API response
+    },
+    
+    selectMultipleOptionsForStudent: function(studentNum, optionIndexes) {
+        optionIndexes.forEach(optionIndex => {
+            this.selectOptionForStudent(studentNum, optionIndex);
+        });
+    },
+    
+    // Multiple Selection specific verification methods
+    verifyOptionCheckedForStudent: (studentNum, optionIndex) => {
+        liveStudentViewBase.withinStudentContainer(studentNum, () => {
+            // Use multipleSelectionPage method for consistent checkbox verification
+            multipleSelectionPage.optionsCheckboxPreviewTab().eq(optionIndex).should('be.checked');
+        });
+    },
+    
+    verifyOptionUncheckedForStudent: (studentNum, optionIndex) => {
+        liveStudentViewBase.withinStudentContainer(studentNum, () => {
+            // Use multipleSelectionPage method for consistent checkbox verification
+            multipleSelectionPage.optionsCheckboxPreviewTab().eq(optionIndex).should('not.be.checked');
+        });
+    },
+    
+    verifyStudentSelections: function(studentNum, checkedOptions = [], uncheckedOptions = []) {
+        // Verify checked options
+        checkedOptions.forEach(optionIndex => {
+            this.verifyOptionCheckedForStudent(studentNum, optionIndex);
+        });
+        
+        // Verify unchecked options
+        uncheckedOptions.forEach(optionIndex => {
+            this.verifyOptionUncheckedForStudent(studentNum, optionIndex);
+        });
+    },
+
+    // Method to use multipleSelectionPage's existing unchecked state verification
+    verifyAllOptionsUncheckedInitially: () => {
+        // Use multipleSelectionPage method for initial unchecked state verification
+        for (let index = 0; index < 4; index++) {
+            multipleSelectionPage.steps.verifyOptionsCheckboxInPreviewTabUncheckedState(index);
+        }
+    },
+
+    // Method to use multipleSelectionPage's checkbox clicking
+    clickOptionUsingMultipleSelectionMethod: (optionIndex) => {
+        multipleSelectionPage.steps.checkOptionsCheckboxInPreviewTab(optionIndex);
+    },
+    
+    // Content verification methods - reusing multipleSelectionPage methods
+    verifyQuestionInstructionsVisible: (expectedText, studentNum = null) => {
+        if (studentNum) {
+            const questionElement = selectors.questionInstructions(studentNum);
+            questionElement.should('be.visible');
+            if (expectedText) {
+                questionElement.should('contain.text', expectedText);
+            }
+        } else {
+            // Use multipleSelectionPage method for question instructions verification
+            utilities.verifyInnerText(multipleSelectionPage.questionInstructionsText(), expectedText);
+            utilities.verifyElementVisibilityState(multipleSelectionPage.questionInstructionsText(), 'visible');
+        }
+    },
+    
+    // Content verification methods - using multipleSelectionPage methods
+    verifyImageOptionVisible: (studentNum, optionIndex = 0) => {
+        if (studentNum) {
+            selectors.imageOption(studentNum, optionIndex).should('exist').should('be.visible');
+        } else {
+            // Use multipleSelectionPage method
+            multipleSelectionPage.steps.verifyImageInPreviewTab(optionIndex);
+        }
+    },
+    
+    verifyBoldTextOptionVisible: (studentNum, optionIndex = 1, expectedText = null) => {
+        if (studentNum) {
+            const boldElement = selectors.boldTextOption(studentNum, optionIndex);
+            boldElement.should('exist').should('be.visible');
+            if (expectedText) {
+                boldElement.should('contain.text', expectedText);
+            }
+        } else {
+            // Use multipleSelectionPage method
+            multipleSelectionPage.steps.verifyBoldTextInPreviewTab(optionIndex);
+        }
+    },
+    
+    verifyEquationOptionVisible: (studentNum, optionIndex = 2) => {
+        if (studentNum) {
+            selectors.equationOption(studentNum, optionIndex).should('exist').should('be.visible');
+        } else {
+            // Use multipleSelectionPage method
+            multipleSelectionPage.steps.verifyEquationTextInPreviewTab(optionIndex);
+        }
+    },
+    
+    // Combined test scenarios
+    testIndependentStudentInteractions: function() {        
+        // Student-1 selects options 0 and 1
+        this.selectMultipleOptionsForStudent(1, [0, 1]);
+        
+        // Student-2 selects options 2 and 3
+        this.selectMultipleOptionsForStudent(2, [2, 3]);
+        
+        // Verify Student-1's selections
+        this.verifyStudentSelections(1, [0, 1], [2, 3]);
+        
+        // Verify Student-2's selections
+        this.verifyStudentSelections(2, [2, 3], [0, 1]);
+    },
+    
+
+
+    /**
+     * Verifies that the image in both student containers has the correct source and alt text.
+     * @param {number} index - The index of the option in both student containers.
+     */
+    verifyImageInBothStudentContainers: function(index) {
+        this.verifyImageOptionVisible(1, index);
+        this.verifyImageOptionVisible(2, index);
+    },
+
+    /**
+     * Verifies that the bold text in both student containers is correct.
+     * @param {number} index - The index of the option in both student containers.
+     */
+    verifyBoldTextInBothStudentContainers: function(index) {
+        this.verifyBoldTextOptionVisible(1, index);
+        this.verifyBoldTextOptionVisible(2, index);
+    },
+
+    /**
+     * Verifies that the equation text in both student containers is correct.
+     * @param {number} index - The index of the option in both student containers.
+     */
+    verifyEquationInBothStudentContainers: function(index) {
+        this.verifyEquationOptionVisible(1, index);
+        this.verifyEquationOptionVisible(2, index);
+    },
+
+}
+
+const tests = {
+    // Import common Live Student View tests from base
+    ...liveStudentViewBase.tests,
+    
+    /**
+     * Multiple Selection specific Live Student View tests
+     */
+    verifyMultipleSelectionLiveStudentViewInteractions: () => {
+        it('Live Student View should allow real-time interaction with both students for Multiple Selection', () => {
+            liveStudentViewBase.steps.verifyBothStudentContainersExist();
+            liveStudentViewBase.steps.verifyStudentHeaders();
+            steps.testIndependentStudentInteractions();
+        });
+    }
+}
+
+export const liveStudentViewPage = {
+    ...selectors,
+    steps,
+    tests
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itemengine-cypress-automation",
-  "version": "1.0.553-IEI-7000-main-8cb7c78.0",
+  "version": "1.0.554-IEI-5835-LIVE-30c8e27.0",
   "description": "",
   "main": "index.js",
   "scripts": {

package/scripts/sorry-cypress.mjs

@@ -214,8 +214,29 @@ export async function runSorryCypressSpinnakerSmoke() {
     startTime = process.env.START_TIME;
     ciBuildId = setCiBuildId("spinnaker", startTime);
     const envArgs = setCommandLineEnvArgs()
-    let command = `cy2 run --parallel --browser chrome --record --key imaginelearning/itemengine-cypress-automation --ci-build-id ${ciBuildId} ${envArgs} --spec "cypress/e2e/ILC/**/*.smoke.js"`;
+    
+    // Define specific folders to run smoke tests from (subset of tests - approximately 60%)
+    const testFolders = [
+        "cypress/e2e/ILC/EssayResponse/**/*.smoke.js",
+        "cypress/e2e/ILC/MultipleSelection/**/*.smoke.js",
+        "cypress/e2e/ILC/DragAndDropIntoCategoriesNew/**/*.smoke.js",
+        "cypress/e2e/ILC/FillInTheGapsTextNew/**/*.smoke.js",
+        "cypress/e2e/ILC/FillInTheGapsDropdownNew/**/*.smoke.js",
+        "cypress/e2e/ILC/FillInTheGapsDragAndDropNew/**/*.smoke.js",
+        "cypress/e2e/ILC/UploadResponse/**/*.smoke.js",
+        "cypress/e2e/ILC/Matching/**/*.smoke.js",
+        "cypress/e2e/ILC/ShortTextResponseNew/**/*.smoke.js",
+        "cypress/e2e/ILC/ListOrderingNew/**/*.smoke.js",
+        "cypress/e2e/ILC/AudioResponseNew/**/*.smoke.js",
+        "cypress/e2e/ILC/SingleSelection/**/*.smoke.js",
+        "cypress/e2e/ILC/ThinkSphere/**/*.smoke.js",
+        "cypress/e2e/ILC/DrawingResponse/**/*.smoke.js",
+        "cypress/e2e/ILC/ContentBlocks/**/*.smoke.js"
+    ].join(",");
+    
+    let command = `cy2 run --parallel --browser chrome --record --key imaginelearning/itemengine-cypress-automation --ci-build-id ${ciBuildId} ${envArgs} --spec "${testFolders}"`;
     console.log(`command: ${command}`);
+    console.log(`Running smoke tests from selected folders (subset)`);
     const isOtkv2 = process.env.OTK_VERSION === '2';
     try {
         execSync(command, { stdio: "inherit" });