dceky 1.0.0-beta.6 → 1.0.2

package/src/commands/handleHarvardKey.ts

@@ -0,0 +1,91 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Handle a HarvardKey login page for a user
+       * @author Yuen Ler Chow
+       * @param name the name of the user environment variable
+       * @return Cypress chainable (void) - performs authentication flow, no return value
+       */
+      handleHarvardKey(
+        name: string,
+      ): Chainable<void>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const handleHarvardKey = () => {
+  Cypress.Commands.add(
+    'handleHarvardKey',
+    (
+      name: string,
+    ) => {
+      cy.log('Handling HarvardKey authentication');
+
+      const userInfo = Cypress.env(name);
+      if (!userInfo) {
+        throw new Error(`Could not find ${name} in environment variables`);
+      }
+
+      // Destructure the user info object to get the username and password
+      const { username } = userInfo;
+      const { password } = userInfo;
+
+      // Get the Harvard login URL using originWithKaixa with auto-initialized functions
+      cy.origin('https://apps.cirrusidentity.com', () => {
+        Cypress.require('dceky');
+        // Clicking the button doesn't work for some reason, so we access the href attribute instead
+        return cy.navigateToHref('#idp_1001962798_button');
+      }).then((fullUrl: string) => {
+      // Navigate to the Harvard login page using originWithKaixa
+        cy.origin('https://harvard.idp.cirrusidentity.com', {
+          args: { username, password, fullUrl },
+        }, (args) => {
+          Cypress.require('dceky');
+          const {
+            username: harvardUsername,
+            password: harvardPassword,
+            fullUrl: harvardLoginUrl,
+          } = args;
+
+          cy.on('uncaught:exception', (e: Error) => {
+            // Ignore known HarvardKey errors
+            if (!e.message.includes('ready is not defined')) {
+              throw e;
+            }
+            return false;
+          });
+
+          // Visit the Harvard login page
+          cy.visit(harvardLoginUrl);
+
+          // Wait for and fill in the login form
+          cy.waitForElementVisible('#username');
+          cy.waitForElementVisible('#password');
+
+          cy.typeInto({ item: '#username', text: harvardUsername });
+          cy.typeInto({ item: '#password', text: harvardPassword });
+
+          // Submit the form
+          cy.get('input[type="submit"], button[type="submit"], .btn-primary').click();
+        });
+      });
+    },
+  );
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default handleHarvardKey;

package/src/commands/launchAs.ts

@@ -0,0 +1,120 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Log into Canvas and launch an LTI app as a specific user from environment variables.
+       * The user should be defined as an environment variable with the following properties:
+       * - accessToken: Canvas access token for the user (required for production mode)
+       * - type: User type ('student', 'ta', 'teacher') for local mode (defaults to 'teacher')
+       * - simIndex: Simulator index for local mode (defaults to '0')
+       * @author Yuen Ler Chow
+       * @param name the name of the user environment variable
+       * @param opts object containing all arguments
+        * @param [opts.courseId] the Canvas ID of the course to launch from
+        * @param [opts.appName] the name of the app as it appears in the course's left-hand nav
+       * @return Cypress chainable (void) - launches the LTI app, no return value
+       */
+      launchAs(
+        name: string,
+        opts?: {
+          courseId?: number,
+          appName?: string,
+        }
+      ): Chainable<void>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const launchAs = () => {
+  Cypress.Commands.add(
+    'launchAs',
+    (
+      name: string,
+      opts: {
+        courseId?: number,
+        appName?: string,
+      } = {},
+    ) => {
+      let { courseId, appName } = opts;
+
+      // Get courseId from environment variables if not provided
+      if (!courseId) {
+        const envCourseId = Cypress.env('courseId');
+        if (!envCourseId) {
+          throw new Error('Could not find courseId in environment variables');
+        }
+        courseId = Number.parseInt(envCourseId, 10);
+      }
+
+      // Get appName from environment variables if not provided
+      appName = appName || Cypress.env('appName');
+      if (!appName) {
+        throw new Error('Could not find appName in environment variables');
+      }
+
+      // Get user info from environment variables
+      const userInfo = Cypress.env(name);
+      if (!userInfo) {
+        throw new Error(`Could not find ${name} in environment variables`);
+      }
+
+      cy.log(`🚀 Launch as ${name}`);
+
+      // Check if this is a local launch
+      const isLocal = Cypress.env('local') === 'true';
+
+      if (isLocal) {
+        // Handle local simulator launch
+        const userType = userInfo.type || 'teacher';
+        const simIndex = userInfo.simIndex || '0';
+        const simLaunchButtonId = `${userType}_${simIndex}-launch-button`;
+
+        cy.log('Local mode: launching simulator');
+        cy.visit('https://localhost:8088/simulator');
+
+        // Handle potential SSL certificate issues
+        cy.get('body').then(($body) => {
+          if ($body.find('.ssl').length > 0) {
+            cy.log('Handling SSL certificate issue');
+            cy.get('#details-button').click();
+            cy.get('#proceed-link').click();
+          }
+        });
+
+        // Launch the app
+        cy.get(`#${simLaunchButtonId}`).click();
+
+        // Click the authorize button
+        cy.get('.authorize-button', { timeout: 1000 }).click();
+
+        return;
+      }
+
+      // Handle production launch with access token
+      const { accessToken } = userInfo;
+
+      if (!accessToken) {
+        throw new Error(`Could not find accessToken for ${name} in environment variables`);
+      }
+
+      // Launch using the access token
+      cy.launchLTIUsingToken(accessToken, { courseId, appName });
+    },
+  );
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default launchAs;

package/src/commands/launchLTIUsingToken.ts

@@ -0,0 +1,115 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Log into Canvas using an access token and launch an LTI app
+       * @author Yuen Ler Chow
+       * @param accessToken the user's Canvas access token
+       * @param opts object containing all arguments
+       * @param [opts.courseId] the Canvas ID of the course to launch from
+       * @param [opts.appName] the name of the app as it appears in the course's left-hand nav
+       * @return Cypress chainable (void) - launches the LTI app and navigates to it, no return value
+       */
+      launchLTIUsingToken(
+        accessToken: string,
+        opts?: {
+          courseId?: number,
+          appName?: string,
+        }
+      ): Chainable<void>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const launchLTIUsingToken = () => {
+  Cypress.Commands.add(
+    'launchLTIUsingToken',
+    (
+      accessToken: string,
+      opts: {
+        courseId?: number,
+        appName?: string,
+      } = {},
+    ) => {
+      let { courseId, appName } = opts;
+
+      if (!courseId) {
+        const envCourseId = Cypress.env('courseId');
+        if (!envCourseId) {
+          throw new Error('Could not find courseId in environment variables');
+        }
+        courseId = Number.parseInt(envCourseId, 10);
+      }
+
+      appName = appName || Cypress.env('appName');
+      if (!appName) {
+        throw new Error('Could not find appName in environment variables');
+      }
+
+      cy.log(`Launch LTI app "${appName}" in course ${courseId} using access token`);
+
+      // Get the external tools for the course
+      cy.visitCanvasGETEndpoint({
+        path: `/courses/${courseId}/external_tools`,
+        accessToken,
+      }).then((externalTools: { [key: string]: any }[]) => {
+        cy.log(`Found ${externalTools.length} external tools`);
+
+        // Find the external tool of interest
+        const matchingTool = externalTools.find((externalTool) => {
+          // Skip non-nav items
+          if (!externalTool.course_navigation || typeof externalTool.course_navigation !== 'object') {
+            return false;
+          }
+
+          // Skip non-labeled items
+          if (!externalTool.course_navigation.text) {
+            return false;
+          }
+
+          // Skip if the app name does not match the expected name
+          const thisAppName = externalTool.course_navigation.text.trim().toLowerCase();
+          return thisAppName === appName.trim().toLowerCase();
+        });
+
+        const toolId = matchingTool?.id || 0;
+        if (matchingTool) {
+          cy.log(`Found matching app: "${matchingTool.course_navigation.text}" with ID ${toolId}`);
+        }
+
+        // Make sure we found the app
+        if (toolId === 0) {
+          throw new Error(`Could not find any apps named "${appName}" in course ${courseId}`);
+        }
+
+        // Get a sessionless launch URL
+        cy.visitCanvasGETEndpoint({
+          path: `/courses/${courseId}/external_tools/sessionless_launch?id=${toolId}`,
+          accessToken,
+        }).then((sessionlessLaunchInfo) => {
+          const launchURL = sessionlessLaunchInfo.url;
+          cy.log(`Launching LTI app at: ${launchURL}`);
+
+          // Launch the tool
+          cy.visit(launchURL);
+        });
+      });
+    },
+  );
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default launchLTIUsingToken;

package/src/commands/navigateToHref.ts

@@ -0,0 +1,60 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Navigate to href attribute of Harvard identity provider button
+       * @author Yuen Ler Chow
+       * @param item the CSS selector of interest
+       * @return Cypress chainable containing the full URL string (hostname + href attribute value)
+       */
+      navigateToHref(item: string): Chainable<string>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const navigateToHref = () => {
+  Cypress.Commands.add(
+    'navigateToHref',
+    (
+      item: string,
+    ) => {
+      cy.waitForElementVisible(item);
+
+      return cy
+        .url()
+        // get origin (protocol + '//' + host) from current URL
+        .then((url: string) => {
+          const { protocol, host } = new URL(url);
+          return `${protocol}//${host}`;
+        })
+        .then((origin: string) => {
+          return cy
+            .get(item)
+            .invoke('attr', 'href')
+            .then((href: string) => {
+              // If the href is a relative URL, prepend the hostname
+              if (href.startsWith('/')) {
+                return origin + href;
+              }
+              return href;
+            });
+        });
+    },
+  );
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default navigateToHref;

package/src/commands/runScript.ts

@@ -0,0 +1,44 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Run a script on the page
+       * @author Yuen Ler Chow
+       * @param script the script to run
+       * @return Cypress chainable containing the return value from executing the script
+       */
+      runScript(scriptLines: string): Chainable<any>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const runScript = () => {
+  Cypress.Commands.add(
+    'runScript',
+    (
+      script: string,
+    ) => {
+      cy.log('Running script');
+      return cy.window().then((win) => {
+        const result = win.eval(script);
+        return cy.wrap(result);
+      });
+    },
+  );
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default runScript;

package/src/commands/typeInto.ts

@@ -0,0 +1,88 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Type text into an element. This function first removes the previous text in the element
+       * @author Yuen Ler Chow
+       * @param opts object containing all arguments
+       * @param opts.item the CSS selector of interest
+       * @param opts.text the text to type
+       * @param [opts.pressEnter] if true, after typing into the text field, simulate pressing enter
+       * @param [opts.append] if true, append the text to the end of the existing text in the element instead of replacing it
+       * @return Cypress chainable containing the input element that text was typed into
+       */
+      typeInto(
+        opts: {
+          item: string,
+          text: string,
+          pressEnter?: boolean,
+          append?: boolean,
+        },
+      ): Chainable<Element>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const typeInto = () => {
+  Cypress.Commands.add(
+    'typeInto',
+    (
+      opts: {
+        item: string,
+        text: string,
+        pressEnter?: boolean,
+        append?: boolean,
+      },
+    ) => {
+      const {
+        item, text, pressEnter, append,
+      } = opts;
+      // Check if the text contains an enter key press
+      const enterAtEndOfText = text.charAt(text.length - 1) === '\n';
+      const willPressEnter = pressEnter || enterAtEndOfText;
+
+      const action = append ? 'Append' : 'Type';
+      const enterSuffix = willPressEnter ? ' and then press enter' : '';
+      cy.log(`${action} "${text}" into ${item}${enterSuffix}`);
+
+      // Type the text without a trailing enter if there was one
+      const textWithoutTrailingEnter = (
+        enterAtEndOfText
+          ? text.substring(0, text.length - 1)
+          : text
+      );
+
+      if (append) {
+        cy
+          .get(item)
+          .type(textWithoutTrailingEnter);
+      } else {
+        cy
+          .get(item)
+          .clear()
+          .type(textWithoutTrailingEnter);
+      }
+
+      // Press enter if explicitly requested or if text ended with newline
+      if (willPressEnter) {
+        cy.get(item).type('{enter}');
+      }
+    },
+  );
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default typeInto;

package/src/commands/visitCanvasGETEndpoint.ts

@@ -0,0 +1,61 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Makes a GET request to Canvas API endpoint
+       * @author Yuen Ler Chow
+       * @param opts object containing all arguments
+       * @param opts.path The API path (e.g., '/courses', '/users/self')
+       * @param opts.accessToken The Canvas access token
+       * @return Cypress chainable containing the Canvas API response body
+       */
+      visitCanvasGETEndpoint(
+        opts: {
+          path: string,
+          accessToken: string,
+        }
+      ): Chainable<any>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const visitCanvasGETEndpoint = () => {
+  Cypress.Commands.add(
+    'visitCanvasGETEndpoint',
+    (
+      opts: {
+        path: string,
+        accessToken: string,
+      },
+    ) => {
+      cy.log('Visiting Canvas GET endpoint');
+      const { path, accessToken } = opts;
+
+      cy.log(`Canvas API: ${path}`);
+      return cy.request({
+        method: 'GET',
+        url: `https://canvas.harvard.edu/api/v1${path}`,
+        qs: {
+          per_page: 200,
+          access_token: accessToken,
+        },
+      }).its('body');
+    },
+  );
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default visitCanvasGETEndpoint;

package/src/commands/waitForElementVisible.ts

@@ -0,0 +1,49 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Wait for an element to be visible
+       * @author Yuen Ler Chow
+       * @param item the CSS selector of interest
+       * @param [timeoutSec=10] the number of seconds to wait before timing out
+       * @return Cypress chainable containing the visible element
+       */
+      waitForElementVisible(
+        item: string,
+        timeoutSec?: number,
+      ): Chainable<JQuery<HTMLElement>>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const waitForElementVisible = () => {
+  Cypress.Commands.add(
+    'waitForElementVisible',
+    (
+      item: string,
+      timeoutSec?: number,
+    ) => {
+      cy.log('Waiting for element to be visible');
+
+      const timeoutMs = (timeoutSec || 10) * 1000;
+      cy.log(`Wait for ${item} to be visible`);
+      return cy.get(item, { timeout: timeoutMs }).should('be.visible');
+    },
+  );
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default waitForElementVisible;

package/src/genConfiguration/helpers/resolveDependents.ts

@@ -0,0 +1,47 @@
+ 
+// Import shared types
+import type GlobalsOrProfile from '../types/GlobalsOrProfile';
+import type DependentValue from '../types/DependentValue';
+
+/**
+ * Resolve all dependent values using already-merged basics.
+ * @author Gardenia Liu
+ * @param dependentMaps with dependencies on basics
+ * @param basics entries
+ * @returns env with all dependent values resolved
+ */
+const resolveDependents = (
+  dependentMaps: { [k: string]: DependentValue }[],
+  basics: GlobalsOrProfile,
+): GlobalsOrProfile => {
+  const resolved: GlobalsOrProfile = {};
+
+  // Loop through all of the dependency maps
+  dependentMaps.forEach((depMap) => {
+    // Loop through all entries within dependency map
+    Object.entries(depMap).forEach(([k, depVal]) => {
+      // Get basic selector the value depends on
+      const selector = basics[depVal.dependsOn];
+
+      // Create table of values selector can be
+      const { dependsOn, ...table } = depVal as { [k: string]: unknown };
+
+      // Get the selector's picked value
+      const picked = table[selector];
+
+      if (picked !== undefined) {
+        resolved[k] = picked;
+      } else if ('default' in table) {
+        resolved[k] = table.default;
+      } else {
+        // eslint-disable-next-line max-len
+        console.warn(`[cypress.config] Could not resolve ${k}, dependsOn=${dependsOn}, selector=${String(selector)}`);
+        process.exit(1);
+      }
+    });
+  });
+
+  return resolved;
+};
+
+export default resolveDependents;