@suffolklitlab/alkiln 5.0.0 → 5.0.2-feat-github-server-1

package/.github/workflows/github_server.yml

@@ -0,0 +1,37 @@
+name: GitHub server tests
+
+on:
+  push:
+  workflow_dispatch:
+    inputs:
+      tags:
+        required: False
+        description: 'Optional. Use a "tag expression" specify which tagged tests to run (https://cucumber.io/docs/cucumber/api/#tag-expressions)'
+        # Only test 2 tests - one uses an env var, the other uses AL.
+        # They test if env vars get set correctly and depencencies get
+        # pulled in correctly.
+        default: '@e6 or @al1'
+
+jobs:
+
+  github-server-tests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [18.x]
+
+    env:
+      USER1_EMAIL: ${{ secrets.USER1_EMAIL }}
+      USER1_PASSWORD: ${{ secrets.USER1_PASSWORD }}
+      SECRET_VAR1: secret-var1-value
+      SECRET_VAR2: secret-var2-value
+      SECRET_FOR_MISSING_FIELD: secret for missing field
+      
+    steps:
+      - uses: actions/checkout@v3
+      - name: Run ALKiln on the GitHub server
+        uses: SuffolkLITLab/ALKiln/github_server@start_server_take_2
+        with:
+          CONFIG_CONTENTS: "${{ secrets.CONFIG_CONTENTS }}"
+          ALKILN_VERSION: 5.0.2-feat-github-server-1
+      - run: echo "Finished running on the GitHub server"

package/CHANGELOG.md

@@ -40,6 +40,14 @@ Format:
 -->
 <!-- ## [Unreleased] -->
 
+## [5.0.2] - 2023-07-20
+### Fixed
+- Accept `SERVER_RELOAD_TIMEOUT_SECONDS` as an env var input in GitHub.
+
+## [5.0.1] - 2023-07-18
+### Changed
+- Increment version of ALKiln that action.yml is using.
+
 ## [5.0.0] - 2023-07-18
 ### Added
 - added additional functionality to the sign method to allow developers to take a name argument to sign on canvas: issue #596

package/action.yml

@@ -5,15 +5,6 @@ inputs:
   SERVER_URL:
     description: 'The url of your docassemble server. This should be in your GitHub SECRETS or the SECRETS of your org.'
     required: true
-  PLAYGROUND_EMAIL:
-    description: 'The email of your docassemble testing account. This should be in your GitHub SECRETS or the SECRETS of your org.'
-    required: true
-  PLAYGROUND_PASSWORD:
-    description: 'The password of your docassemble testing account. This should be in your GitHub SECRETS or the SECRETS of your org.'
-    required: true
-  PLAYGROUND_ID:
-    description: 'The id of your docassemble testing account. This should be in your GitHub SECRETS or the SECRETS of your org.'
-    required: true
   DOCASSEMBLE_DEVELOPER_API_KEY:
     description: 'API key of the testing account with developer permissions on your docassemble server.'
     required: true
@@ -23,11 +14,15 @@ inputs:
   ALKILN_VERSION:
     description: 'Version of ALKiln to get from npm.'
     required: false
-    default: '^4.0.0'
+    default: '^5.0.0'
   MAX_SECONDS_FOR_SETUP:
     description: "Amount of time to give the Project to upload your package's GitHub code."
     required: false
     default: '120'
+  SERVER_RELOAD_TIMEOUT_SECONDS:
+    description: "Max amount of time to give the server to reload if it needs to"
+    required: false
+    # no default to let the custom Scenario timeouts create the reload timeout
 
 runs:
   using: "composite"
@@ -41,17 +36,15 @@ runs:
         echo "REPO_URL=${{ github.server_url }}/${{ github.repository }}" >> $GITHUB_ENV
         echo "BRANCH_PATH=${{ github.ref }}" >> $GITHUB_ENV
         echo "BASE_URL=${{ inputs.SERVER_URL }}" >> $GITHUB_ENV
-        echo "PLAYGROUND_EMAIL=${{ inputs.PLAYGROUND_EMAIL }}" >> $GITHUB_ENV
-        echo "PLAYGROUND_PASSWORD=${{ inputs.PLAYGROUND_PASSWORD }}" >> $GITHUB_ENV
-        echo "PLAYGROUND_ID=${{ inputs.PLAYGROUND_ID }}" >> $GITHUB_ENV
         echo "DOCASSEMBLE_DEVELOPER_API_KEY=${{ inputs.DOCASSEMBLE_DEVELOPER_API_KEY }}" >> $GITHUB_ENV
         echo "ALKILN_VERSION=${{ inputs.ALKILN_VERSION }}" >> $GITHUB_ENV
         echo "MAX_SECONDS_FOR_SETUP=${{ inputs.MAX_SECONDS_FOR_SETUP }}" >> $GITHUB_ENV
+        echo "SERVER_RELOAD_TIMEOUT_SECONDS=${{ inputs.SERVER_RELOAD_TIMEOUT_SECONDS }}" >> $GITHUB_ENV
         echo "_ORIGIN=github" >> $GITHUB_ENV
       shell: bash
     - name: "ALKiln: confirm info"
       run: |
-        echo -e "\nALKiln version is $ALKILN_VERSION\nRepo is $REPO_URL\nBranch ref is $BRANCH_PATH\nMAX_SECONDS_FOR_SETUP is $MAX_SECONDS_FOR_SETUP\n"
+        echo -e "\nALKiln version is $ALKILN_VERSION\nRepo is $REPO_URL\nBranch ref is $BRANCH_PATH\nMAX_SECONDS_FOR_SETUP is $MAX_SECONDS_FOR_SETUP\nSERVER_RELOAD_TIMEOUT_SECONDS is $SERVER_RELOAD_TIMEOUT_SECONDS\n"
       shell: bash
 
     # Install node
@@ -61,7 +54,7 @@ runs:
         node-version: "18"
     - name: Install ALKiln directly from npm
       run: |
-        npm install -g github:SuffolkLITLab/ALKiln#v5
+        npm install -g @suffolklitlab/alkiln
       shell: bash
 
     # Run tests
@@ -90,10 +83,10 @@ runs:
 
 # ##################################
 # # A developer's workflow should look similar to the below
-# # In place of `uses: suffolkLITLab/ALKiln@releases/v4`, they
+# # In place of `uses: suffolkLITLab/ALKiln@v5`, they
 # # might use another version.
 #
-# name: Use the ALKiln testing framework v4 to run tests
+# name: ALKiln v5 tests
 # on:
 #   push:
 #   workflow_dispatch:
@@ -108,9 +101,9 @@ runs:
 #     runs-on: ubuntu-latest
 #     name: Run interview tests
 #     steps:
-#       - uses: actions/checkout@v2
+#       - uses: actions/checkout@v3
 #       - name: Use ALKiln to run tests
-#         uses: suffolkLITLab/ALKiln@releases/v4
+#         uses: suffolkLITLab/ALKiln@v5
 #         with:
 #           SERVER_URL: "${{ secrets.SERVER_URL }}"
 #           DOCASSEMBLE_DEVELOPER_API_KEY: "${{ secrets.DOCASSEMBLE_DEVELOPER_API_KEY }}"

package/github_server/action.yml

@@ -0,0 +1,57 @@
+name: "ALKiln/github_server: Isolated docassemble tests"
+description: "Automatically test docassemble interviews on GitHub's servers, in an isolated environment. Avoids docassemble reload errors and other external factors."
+
+
+inputs:
+  CONFIG_CONTENTS:
+    description: "The contents of the config file of the docassemble server"
+    required: false
+  # This is necessary to test pre-releases at the very least. It does seem
+  # strange considering we're controlling everything through the action, but
+  # that actually doesn't touch the npm version that's pulled in.
+  ALKILN_VERSION:
+    description: 'Version of ALKiln to get from npm.'
+    required: false
+    default: '^5.0.0'
+  MAX_SECONDS_FOR_SETUP:
+    description: "Amount of time to give the Project to upload your package's GitHub code."
+    required: false
+    default: '120'
+  SERVER_RELOAD_TIMEOUT_SECONDS:
+    description: "Max amount of time to give the server to reload if it needs to"
+    required: false
+    # no default to let the custom Scenario timeouts create the reload timeout
+
+
+runs:
+  using: "composite"
+  steps:
+      - name: "github_server: Set environment variables"
+        run: |
+          echo "DA_ADMIN_API_KEY=abcd1234abcd1234abcd5678abdc5678" >> $GITHUB_ENV
+        shell: bash
+      - name: "github_server: Download and start docker"
+        run: |
+          mkdir /tmp/config
+          echo "$CONFIG_CONTENTS" > /tmp/config/myconfig.yml 
+          docker pull brycewilley/smoldocassemble
+          docker run --env DA_ADMIN_EMAIL="admin@example.com" --env DA_ADMIN_PASSWORD="password" --env DA_ADMIN_API_KEY="${{ env.DA_ADMIN_API_KEY }}" --env DA_CONFIG=/tmp/config/myconfig.yml --volume /tmp/config:/tmp/config --cap-add SYS_PTRACE --memory="4gb" -d -p 80:80 jhpyle/docassemble
+          # TODO before merge: do a while loop here until `localhost` shows "It's ready"
+          sleep 600
+          sleep 600
+          curl localhost
+        shell: bash
+      - name: "github_server: Install the package"
+        run: alkiln-startserver
+        shell: bash
+      - name: "github_server: Run Kiln"
+        # TODO: Research how to get this to always be the same branch we're on
+        uses: SuffolkLITLab/ALKiln@v5
+        with:
+          SERVER_URL: "http://localhost"
+          DOCASSEMBLE_DEVELOPER_API_KEY: "${{ env.DA_ADMIN_API_KEY }}"
+      - name: Docker logs
+        # TODO: create an arifact for this instead
+        run: |
+          docker logs $(docker ps --filter "ancestor=jhpyle/docassemble" --format {{.ID}})
+        shell: bash

package/lib/docassemble/docassemble_api_REST.js

@@ -54,6 +54,22 @@ da.create_project = async function ( project_name, timeout ) {
   }
 };  // Ends da.create_project()
 
+da.install_on_server = async function ( github_repo, branch_name, timeout ) {
+  let options = {
+    method: 'POST',
+    url: `${ session_vars.get_da_server_url() }/api/package`,
+    data: qs.stringify( {
+      key: session_vars.get_dev_api_key(),
+      github_url: github_repo,
+      branch: branch_name
+    }),
+    timeout: timeout,
+  };
+  console.log("%o", options);
+
+  return await axios.request(options);
+};
+
 
 // node -e 'require("./lib/docassemble/docassemble_api_REST.js").pull()'
 da.pull = async function ( timeout ) {
@@ -79,13 +95,21 @@ da.pull = async function ( timeout ) {
 };  // Ends da.pull()
 
 
+da.has_playground_task_finished = async function ( task_id, timeout ) {
+  return await da.has_task_finished( "/api/restart_status", task_id, timeout);
+}
+
+da.has_package_task_finished = async function ( task_id, timeout ) {
+  return await da.has_task_finished( "/api/package_update_status", task_id, timeout);
+}
+
 // node -e 'require("./lib/docassemble/docassemble_api_REST.js").has_task_finished()'
-da.has_task_finished = async function ( task_id, timeout ) {
+da.has_task_finished = async function ( api_endpoint, task_id, timeout ) {
   /* Check task status based on `task_id`. */
   let options = {
     method: 'GET',
     headers: {'X-API-Key': session_vars.get_dev_api_key()},
-    url: `${ session_vars.get_da_server_url() }/api/restart_status`,
+    url: `${ session_vars.get_da_server_url() }${ api_endpoint }`,
     params: {
       task_id: task_id,
     },

package/lib/docassemble/docassemble_api_interface.js

@@ -330,8 +330,30 @@ da_i.pull = async function ( pull_options ) {
 };  // Ends da_i.pull()
 
 
+da_i.install_on_server = async function ( install_options ) {
+  let { timeout } = install_options || { timeout: DEFAULT_MAX_REQUEST_MS };
+
+  try {
+    let response = await _da_REST.install_on_server(
+      session_vars.get_repo_url(),
+      session_vars.get_branch_name(),
+      timeout
+    );
+    if ( response && response.status === 200 ) {
+      // console.log("%o", response);
+      log.debug({ pre: `install task id: ${ response.data.task_id }` });
+      return response.data.task_id;
+    }
+    // console.log(`${ response.status }: ${ response.data }`);
+    return null;
+  } catch (error ) {
+    log.error({ pre: `Installing on the docassemble serve ran into an unexpected error.`, data: error.toJSON()});
+  }
+
+};
+
 // node -e 'require("./lib/docassemble/docassemble_api_interface.js").has_task_finished()'
-da_i.has_task_finished = async function ( task_id, options ) {
+da_i.has_task_finished = async function ( api_endpoint, task_id, options ) {
   /** Check task status if it exists. If not, return true as task did
   *    not require a server restart. See da_i.pull().
   *    See https://docassemble.org/docs/api.html#restart_status. */
@@ -342,7 +364,7 @@ da_i.has_task_finished = async function ( task_id, options ) {
   try {
 
     // If server did need to restart, check if it's done.
-    let response = await _da_REST.has_task_finished( task_id, timeout );
+    let response = await _da_REST.has_task_finished( api_endpoint, task_id, timeout );
     log.debug({ pre: `Task status: ${ response.status }. Docassemble status text: ${ response.data.status }. Task id: ${ task_id }` });
     
     if ( response.data.status === 'completed' ) {
@@ -353,16 +375,15 @@ da_i.has_task_finished = async function ( task_id, options ) {
       return false;
 
     } else if ( response.data.status === 'unknown' ) {
-      // Server is working, but status 'unknown'? We shouldn't even
-      // get here according to the API docs, but it feels weird to have
-      // no default behavior. What to return? Throw?
+      // Server is working, but status 'unknown'? Bad design, but this
+      // does get returned when install packages, so return true
       log.info({
         pre: `\`task_id\` "${ task_id }" has expired. If it's been `
           + `less than 1 hour since the task started, the task is `
           + `complete. See https://docassemble.org/docs/api.html#restart_status.`,
-        data: response,
+        data: response.data,
       });
-      return null;
+      return true;
     }  // ends status type
 
   } catch ( error ) {
@@ -378,8 +399,15 @@ da_i.has_task_finished = async function ( task_id, options ) {
 
 };  // Ends da_i.has_task_finished()
 
+da_i.wait_for_playground_to_restart = async ( task_id, options ) => {
+  return await da_i.wait_for_server_to_restart( "/api/restart_status", task_id, options );
+};
+
+da_i.wait_for_package_to_restart = async ( task_id, options ) => {
+  return await da_i.wait_for_server_to_restart( "/api/package_update_status", task_id, options );
+};
 
-da_i.wait_for_server_to_restart = async ( task_id, options ) => {
+da_i.wait_for_server_to_restart = async ( api_endpoint, task_id, options ) => {
   /** Wait for the server to finish restarting in case a module needs to load.
   *     This is a polling function because things may be returned
   *     that aren't equivalent to the server being done with a task. */
@@ -410,7 +438,7 @@ da_i.wait_for_server_to_restart = async ( task_id, options ) => {
   while ( !done_restarting && num_tries <= max_loops ) {
     num_tries++;
     // Wait only a short time for the task to finish, not the full default timeout
-    done_restarting = await da_i.has_task_finished( task_id, { timeout: wait_for_response } );
+    done_restarting = await da_i.has_task_finished( api_endpoint, task_id, { timeout: wait_for_response } );
     if ( !done_restarting ) {
       if ( num_tries < max_loops ) {
         // Show a slightly different message after a number of tries to reassure

package/lib/docassemble/get_base_interview_url.js

@@ -11,9 +11,18 @@ let get_base_interview_url = async function () {
   *    when the user is not logged in.) We can't use `reset=2` because it caused an
   *    'Unable to locate interview session' error. */
   let server_url = session_vars.get_da_server_url();
-  let dev_id = await docassemble_api_interface.get_dev_id();
-  let project_name = session_vars.get_project_name();
-  return `${ server_url }/interview?new_session=1&i=docassemble.playground${ dev_id }${ project_name }%3A`;
+  console.log(session_vars.get_install_type());
+  if (session_vars.get_install_type() === "server") {
+    let x = `${ server_url }/interview?new_session=1&i=${session_vars.get_package_name().replace("-", ".")}%3A`;
+    console.log(`base_interview_url: ${x}`)
+    return x;
+  } else {
+    let dev_id = await docassemble_api_interface.get_dev_id();
+    let project_name = session_vars.get_project_name();
+    let x = `${ server_url }/interview?new_session=1&i=docassemble.playground${ dev_id }${ project_name }%3A`;
+    console.log(`base_interview_url: ${x}`)
+    return x;
+  }
 };
 
 module.exports = get_base_interview_url;

package/lib/docassemble/setup.js

@@ -39,7 +39,7 @@ const setup = async () => {
   let task_id = await da_i.pull();
   // Task id will be null if server did not need to restart
   if ( task_id ) {
-    await da_i.wait_for_server_to_restart( task_id );
+    await da_i.wait_for_playground_to_restart( task_id );
   }
 
   // Finish

package/lib/docassemble/startserver.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+const puppeteer = require('puppeteer');
+const da_i = require('./docassemble_api_interface');
+const session_vars = require('../utils/session_vars');
+
+const fs = require('fs')
+
+const startserver = async () => {
+  // Open the browser, login with env var creds
+  /*
+  let browser = await puppeteer.launch({headless: !session_vars.get_debug()})
+  let page = await browser.newPage();
+  // Go to the sign in page
+  let login_url = `${ session_vars.get_da_server_url() }/user/sign-in`;
+  try {
+    // puppeteer will ensure proper timeout.
+    await page.goto( login_url, { waitUntil: `domcontentloaded`, timeout: 3000 });
+    await page.waitForSelector( `.dabody` );
+  } catch ( error ) {
+    let err_msg = `Error occurred when ALKiln tried to go to "${ login_url }: ${ error }".`
+    console.log(err_msg);
+    throw error;
+  } 
+
+  let email = process.env[ "DA_ADMIN_API_KEY" ];
+  let password = process.env[ "USER_PASSWORD" ];
+
+  // Try to log in
+  await page.type( `#email`, email );
+  await page.type( `#password`, password );
+  let elem = await page.$( `button[name="submit"]` );
+  await elem.click();
+  await page.waitForNavigation({waitUntil: 'domcontentloaded'});
+
+  // Wait to see the success message.
+  // This is a bit of an assumption and needs success and failure testing
+  // TODO: use a Promise.race to fail faster.
+  await page.waitForSelector( `.datopcenter .alert-success` );
+  // make an API key
+
+  // TODO(brycew): with or without the API key?
+  // Install the package in order to also install all of its dependencies
+  let api_key_url = `${ session_vars.get_da_server_url() }/manage_api?action=new`;
+  await page.goto( api_key_url, { waitUntil: `domcontentloaded`, timeout: 3000 });
+  await page.type( `#name`, "ALKiln tmp key");
+  await page.select( `#method`, "none");
+  let winner = await Promise.all([page.click(`#submit`), page.waitForNavigation({waitUntil: 'domcontentloaded'})]);
+  console.log(`submitted`);
+  const api_text = await page.$eval('body p code', elem => elem.innerText);
+  process.env.DOCASSEMBLE_DEVELOPER_API_KEY = api_text;
+  console.log(`api key: ${api_text}`);
+  let file = fs.writeFileSync( ".tmpenv", `export DOCASSEMBLE_DEVELOPER_API_KEY=${api_text}`);
+
+  await page.goto(`${ session_vars.get_da_server_url() }/user/sign-out`, {waitUntil: `domcontentloaded`});  
+  console.log(`signed out`);
+  await browser.close();
+  */
+
+  let task_id = await da_i.install_on_server();
+  if (task_id) {
+    console.log("Waiting...")
+    await da_i.wait_for_package_to_restart(task_id);
+  }
+  console.log("Done!")
+  session_vars.save_install_type("server");
+
+};  // Ends startserver();
+
+startserver();

package/lib/utils/session_vars.js

@@ -115,6 +115,7 @@ session_vars.get_languages = function () {
 
 const runtime_config_path = `runtime_config.json`;
 const project_name_key = `da_project_name`;
+const install_type_key = `da_install_type`;
 session_vars.save_project_name = function ( project_name ) {
   /* Saves the name of the project to a json obj so deletion can use it later.
   *    Built for local as well as remote testing. Assumes a kosher string.
@@ -197,6 +198,36 @@ session_vars.save_artifacts_path_name = function ( path_name ) {
   return file;
 };  // Ends save_artifacts_path_name()
 
+
+session_vars.save_install_type = function (install_type) {
+  /* Save a key with the name of the current artifacts folder in case it doesn't exist. */
+
+  // Ensure artifacts path file exists
+  if ( !fs.existsSync( runtime_config_path ) ) {
+    // If the file doesn't exist, make one because next we need to read it
+    fs.writeFileSync( runtime_config_path, JSON.stringify( {}, null, 2 ) );
+  }
+
+  // Get the json, changing it, and re-write the file from scratch
+  let json = JSON.parse( fs.readFileSync( runtime_config_path ) );
+  json[ install_type_key ] = install_type;
+  let file = fs.writeFileSync( runtime_config_path, JSON.stringify( json, null, 2 ) );
+
+  return file;
+};  // Ends save_artifacts_path_name()
+
+session_vars.get_install_type = function () {
+  /* Get the name of the current artifacts path. */
+  try {
+    let json = JSON.parse( fs.readFileSync( runtime_config_path ));
+    let install_type = json[ install_type_key ];
+
+    return install_type;
+  } catch ( error ) {
+    return null;
+  }
+};  // Ends get_artifacts_path_name()
+
 session_vars.get_artifacts_path_name = function () {
   /* Get the name of the current artifacts path. */
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suffolklitlab/alkiln",
-  "version": "5.0.0",
+  "version": "5.0.2-feat-github-server-1",
   "description": "Integrated automated end-to-end testing with docassemble, puppeteer, and cucumber.",
   "main": "lib/index.js",
   "scripts": {
@@ -9,6 +9,7 @@
     "local": "npm run setup && npm run cucumber; npm run takedown",
     "setup": "./lib/docassemble/setup.js",
     "takedown": "./lib/docassemble/takedown.js",
+    "startserver": "./lib/docassemble/startserver.js",
     "unit": "mocha tests/unit_tests/*.test.*"
   },
   "repository": {
@@ -47,6 +48,7 @@
     "uuid": "8.3.2"
   },
   "bin": {
+    "alkiln-startserver": "./lib/docassemble/startserver.js",
     "alkiln-setup": "./lib/docassemble/setup.js",
     "alkiln-takedown": "./lib/docassemble/takedown.js",
     "alkiln-run": "./lib/run_cucumber.js"

package/tmp.bash

@@ -0,0 +1,7 @@
+#!/usr/bin/bash
+
+npm run startserver
+source .tmpenv
+# (cd ../docassemble-EFSPIntegration && npm run setup)
+
+# npm run cucumber