dceky 1.0.0-beta-profile.1 → 1.0.0-beta-yuenler.2

package/src/commands/launchLTIUsingToken.ts

@@ -0,0 +1,84 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Log into Canvas using an access token and launch an LTI app
+       * @param accessToken the user's Canvas access token
+       * @param courseId the Canvas ID of the course to launch from
+       * @param appName the name of the app as it appears in the course's left-hand nav
+       * @example cy.launchLTIUsingToken('your_access_token', 12345, 'My LTI App')
+       */
+      launchLTIUsingToken(accessToken: string, courseId: number, appName: string): Chainable<void>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const launchLTIUsingToken = () => {
+  Cypress.Commands.add('launchLTIUsingToken', (accessToken: string, courseId: number, appName: string) => {
+    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: accessToken
+    }).then((externalTools: any[]) => {
+      cy.log(`Found ${externalTools.length} external tools`);
+
+      // Find the external tool of interest
+      let toolId = 0;
+      
+      for (const externalTool of externalTools) {
+        // Skip non-nav items
+        if (!externalTool.course_navigation || typeof externalTool.course_navigation !== 'object') {
+          continue;
+        }
+
+        // Skip non-labeled items
+        if (!externalTool.course_navigation.text) {
+          continue;
+        }
+
+        // Check if this app matches the name
+        const thisAppName = externalTool.course_navigation.text.trim().toLowerCase();
+        if (thisAppName === appName.trim().toLowerCase()) {
+          toolId = externalTool.id;
+          cy.log(`Found matching app: "${externalTool.course_navigation.text}" with ID ${toolId}`);
+          break;
+        }
+      }
+
+      // 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: accessToken
+      }).then((sessionlessLaunchInfo: any) => {
+        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,45 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Navigate to href attribute of Harvard identity provider button
+       * @param opts object containing all arguments
+       * @param opts.item the CSS selector of interest
+       * @param opts.domain the domain of the page
+       * @returns The full URL constructed from the href
+       * @example cy.navigateToHref({ item: '#login-button', domain: 'https://example.com' })
+       */
+      navigateToHref(opts: { item: string; domain: string }): Chainable<string>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const navigateToHref = () => {
+  Cypress.Commands.add('navigateToHref', (opts: { item: string; domain: string }) => {
+    const { item, domain } = opts;
+
+    cy.waitForElementVisible(item);
+    return cy
+      .get(item)
+      .invoke('attr', 'href')
+      .then((href: any) => {
+        return domain + href; 
+      }); 
+  });
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default navigateToHref;

package/src/commands/runScript.ts

@@ -0,0 +1,42 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Run a script on the page
+       * @param scriptLines the script to run in an anonymous function on the page.
+       *   If multiple script arguments are included, each argument will be considered a
+       *   new line of the script.
+       * @returns return value of the script
+       * @example cy.runScript('console.log("Hello");', 'return document.title;')
+       */
+      runScript(...scriptLines: string[]): Chainable<any>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const runScript = () => {
+  Cypress.Commands.add('runScript', (...scriptLines: string[]) => {
+    cy.log('Running script');
+    const fullScript = scriptLines.join('\n');
+    return cy.window().then((win: any) => {
+      const result = win.eval(fullScript);
+      return cy.wrap(result);
+    });
+  });
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default runScript;

package/src/commands/typeInto.ts

@@ -0,0 +1,57 @@
+/// <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
+       * @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
+       * @example cy.typeInto({ item: '#username', text: 'john_doe', pressEnter: false })
+       */
+      typeInto(opts: {
+        item: string;
+        text: string;
+        pressEnter?: boolean;
+      }): Chainable<Element>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const typeInto = () => {
+  Cypress.Commands.add('typeInto', (opts: { item: string; text: string; pressEnter?: boolean }) => {
+    const { item, text, pressEnter } = opts;
+    cy.log(`Type "${text}" into ${item}`);
+    
+    // Check if the text contains an enter key press
+    const enterAtEndOfText = text.charAt(text.length - 1) === '\n';
+    
+    // Type the text without a trailing enter if there was one
+    const textWithoutTrailingEnter = enterAtEndOfText 
+      ? text.substring(0, text.length - 1)
+      : text;
+    
+    cy.get(item).clear().type(textWithoutTrailingEnter);
+    
+    // Press enter if explicitly requested or if text ended with newline
+    if (pressEnter || enterAtEndOfText) {
+      cy.get(item).type('{enter}');
+    }
+  });
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default typeInto;

package/src/commands/visitCanvasGETEndpoint.ts

@@ -0,0 +1,48 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Makes a GET request to Canvas API endpoint
+       * @param opts object containing all arguments
+       * @param opts.path The API path (e.g., '/courses', '/users/self')
+       * @param opts.accessToken The Canvas access token
+       * @returns The API response body
+       * @example cy.visitCanvasGETEndpoint({ path: '/courses', accessToken: 'your_token' })
+       */
+      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,40 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Wait for an element to be visible
+       * @param item the CSS selector of interest
+       * @param timeoutSec the number of seconds to wait before timing out (default: 10)
+       * @example cy.waitForElementVisible('#submit-button', 15)
+       */
+      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');
+    timeoutSec = timeoutSec || 10;
+
+    const timeoutMs = timeoutSec * 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.ts

@@ -0,0 +1,11 @@
+/**
+ * Generate Cypress configuration based on global credentials,
+ * variables, resources, and profiles
+ * @author Yuen Ler Chow
+ * ...
+ */
+const genConfiguration = () => {
+  return {};
+};
+
+export default genConfiguration;

package/src/index.ts

@@ -2,16 +2,11 @@
 import init from './init';
 import genConfiguration from './genConfiguration';
 
-// Import types
-import GlobalsOrProfile from './genConfiguration/types/GlobalsOrProfile';
-
 // Automatically initialize upon importing the library
 init();
 
+// Export key functions
 export {
-  // Helpers
-  init,
   genConfiguration,
-  // Types
-  GlobalsOrProfile,
+  init,
 };

package/src/init.ts

@@ -1,5 +1,17 @@
 // Import all commands
-import clickSomething from './commands/clickSomething';
+import assertDoesNotHaveClass from './commands/assertDoesNotHaveClass';
+import assertHasClass from './commands/assertHasClass';
+import assertNumElements from './commands/assertNumElements';
+import clickWithRetry from './commands/clickWithRetry';
+import getNumElements from './commands/getNumElements';
+import handleHarvardKey from './commands/handleHarvardKey';
+import launchAs from './commands/launchAs';
+import launchLTIUsingToken from './commands/launchLTIUsingToken';
+import navigateToHref from './commands/navigateToHref';
+import runScript from './commands/runScript';
+import typeInto from './commands/typeInto';
+import visitCanvasGETEndpoint from './commands/visitCanvasGETEndpoint';
+import waitForElementVisible from './commands/waitForElementVisible';
 
 /**
  * Initialize custom commands
@@ -7,7 +19,19 @@ import clickSomething from './commands/clickSomething';
  */
 const init = () => {
   // Execute each command adder
-  clickSomething();
+  assertDoesNotHaveClass();
+  assertHasClass();
+  assertNumElements();
+  clickWithRetry();
+  getNumElements();
+  handleHarvardKey();
+  launchAs();
+  launchLTIUsingToken();
+  navigateToHref();
+  runScript();
+  typeInto();
+  visitCanvasGETEndpoint();
+  waitForElementVisible();
 };
 
 export default init;

package/tsconfig.json

@@ -8,7 +8,6 @@
     "declaration": true,
     "sourceMap": true,
     "target": "es5",
-    "lib": ["es5", "es2015.promise", "es2017.object"],
     "outDir": "./lib"
   },
   "include": [

package/docs/GlobalsAndProfiles.md

@@ -1,23 +0,0 @@
-# Globals and Profiles Configuration
-
-### Configuration Setup
-
-The configuration setup involves the following steps:
-
-1. Split each globals/profiles map into two: `basic` values and `dependsOn` values.
-2. Merge all `basic` values into a running env object (in order so last ones processed are the highest priority).
-3. Go through each `dependsOn` value, look up the value it depends on in the running env object.
-4. Add `dependsOn` values into the running env object (in order so last ones processed are the highest priority).
-5. Wrap the env object into a config.
-
-### Assumptions
-
-* `dependsOn` values must depend on a basic `value`, not on another `dependsOn` value.
-
-### DependsOn Value
-
-The `dependsOn` value is an object that has the following structure:
-
-* `dependsOn`: the key of the `basic` value that we are depending on
-* `value`: the value that we are depending on (can be a string, number, boolean, etc.)
-* `default`: the default value if the `dependsOn` value is not found

package/profileChooser/chooseProfile.ts

@@ -1,35 +0,0 @@
-// TODO: implement a *synchronous* profile chooser that executes the correct launch command
-
-// Import libs
-import path from 'path';
-import fs from 'fs';
-
-// Import helpers
-import print from './helpers/print';
-import showChooser from './helpers/showChooser';
-
-// Get the project directory
-const pwd = path.join(process.env.PWD || process.env.CWD || __dirname, '../..');
-// NOTE: this is a dependency of the main project, so the actual project
-// directory is up two levels (outside this folder, then outside node_modules)
-console.log('Project directory:', pwd);
-
-// TODO: explore the file tree to figure out which profiles exist
-// (Build a chooser based on what you find)
-// Maybe: /cypress/profiles/[Name].Profile.ts
-
-print.title('Here\'s a title');
-
-console.log('Let us do the thing.');
-print.enterToContinue();
-
-const choice = showChooser({
-  question: 'Choose an option:',
-  options: [
-    { tag: 'A', description: 'First option' },
-    { tag: 'B', description: 'Second option' },
-    { tag: 'C', description: 'Third option' },
-  ],
-});
-
-console.log('You chose:', choice);

package/profileChooser/helpers/print.ts

@@ -1,155 +0,0 @@
-/* eslint-disable no-console */
-
-/**
- * Get the left buffer for a centered message
- * @author Gabe Abrams
- * @param message message to print
- * @param padding amount of padding to add
- * @returns number of chars in the buffer
- */
-const leftBuffer = (message: string, padding: number): number => {
-  return (Math.floor(process.stdout.columns / 2) - padding - Math.ceil(message.length / 2));
-};
-
-/**
- * Get the right buffer for a centered message
- * @author Gabe Abrams
- * @param message message to print
- * @param padding amount of padding to add
- * @returns number of chars in the buffer
- */
-const rightBuffer = (message: string, padding: number): number => {
-  return (Math.ceil(process.stdout.columns / 2) - padding - Math.floor(message.length / 2));
-};
-
-/**
- * Surround text with a border and spaces
- * @author Gabe Abrams
- * @param str text to print
- * @param border single character to use as a border
- * @returns text to print
- */
-const surroundWithBuffer = (str: string, border: string): string => {
-  return (
-    border
-    + ' '.repeat(leftBuffer(str, border.length))
-    + str
-    + ' '.repeat(rightBuffer(str, border.length))
-    + border
-  );
-};
-
-/**
- * Surround text with a character as the buffer
- * @author Gabe Abrams
- * @param str text to print
- * @param char character to place as the buffer
- * @returns text to print
- */
-const surroundWithChars = (str: string, char: string): string => {
-  if (str.length > process.stdout.columns) {
-    return str;
-  }
-  if (str.length === process.stdout.columns - 1) {
-    return char + str;
-  }
-  if (str.length === process.stdout.columns - 2) {
-    return char + str + char;
-  }
-  return (
-    char.repeat(leftBuffer(str, 1))
-    + ' '
-    + str
-    + ' '
-    + char.repeat(rightBuffer(str, 1))
-  );
-};
-
-// Prompt instance
-let cachedPrompt: any;
-
-const print = {
-  /**
-   * Print a title
-   * @author Gabe Abrams
-   * @param str text to print
-   */
-  title: (str: string) => {
-    if (str.length > process.stdout.columns) {
-      return console.log(str);
-    }
-    console.log('\u2554' + '\u2550'.repeat(process.stdout.columns - 2) + '\u2557');
-    console.log(surroundWithBuffer(str, '\u2551'));
-    console.log('\u255A' + '\u2550'.repeat(process.stdout.columns - 2) + '\u255D');
-  },
-  /**
-   * Print a sub title (subheading)
-   * @author Gabe Abrams
-   * @param str text to print
-   */
-  subtitle: (str: string) => {
-    if (str.length > process.stdout.columns) {
-      return console.log(str);
-    }
-    console.log(surroundWithChars(str, '\u257C'));
-  },
-  /**
-   * Print centered text
-   * @author Gabe Abrams
-   * @param str text to print
-   */
-  centered: (str: string) => {
-    const lines = [];
-    let index = 0;
-    while (index < str.length) {
-      lines.push(str.substring(index, Math.min(index + process.stdout.columns, str.length)));
-      index += process.stdout.columns;
-    }
-    lines.forEach((line, lineIndex) => {
-      if (lineIndex !== lines.length - 1) {
-        // No need to center: fills whole line
-        console.log(line);
-      } else {
-        // This line needs to be centered
-        console.log(surroundWithChars(line, ' '));
-      }
-    });
-  },
-  /**
-   * Print a fatal error message
-   * @author Gabe Abrams
-   * @param err error message
-   */
-  fatalError: (err: string) => {
-    console.log('\n');
-    const errLine1 = err.substring(0, process.stdout.columns - 6);
-    const errLine2 = err.substring(process.stdout.columns - 6);
-    console.log('\u2554' + '\u2550'.repeat(3) + '\u2557 ');
-    console.log(`\u2551 ! \u2551 ${errLine1}`);
-    console.log('\u255A' + '\u2550'.repeat(3) + '\u255D ' + errLine2);
-    process.exit(0);
-  },
-  /**
-   * Save a copy of the prompt instance
-   * @author Gabe Abrams
-   * @param promptInstance instance of prompt-sync
-   */
-  savePrompt: (promptInstance: any) => {
-    cachedPrompt = promptInstance;
-  },
-  /**
-   * Ask the user to press enter before continuing
-   * @author Gabe Abrams
-   */
-  enterToContinue: () => {
-    const res = cachedPrompt(
-      surroundWithChars('enter to continue, ctrl+c to quit', '\u257C'),
-      true,
-    );
-    if (res === null) {
-      process.exit(0);
-    }
-  },
-};
-
-export default print;

package/profileChooser/helpers/prompt.ts

@@ -1,23 +0,0 @@
-import initPrompt from 'prompt-sync';
-import print from './print';
-
-const promptSync = initPrompt();
-
-/**
- * Ask the user a question
- * @param title title of the question
- * @param notRequired true if question is not required
- * @returns response
- */
-const prompt = (title: string, notRequired?: boolean): string => {
-  const val = promptSync(title);
-  if (val === null || (!notRequired && !val)) {
-    process.exit(0);
-  }
-  return val;
-};
-
-// Save the prompt for use later
-print.savePrompt(prompt);
-
-export default prompt;