@pipedream/testmo 0.0.1 → 0.2.0

package/actions/append-to-automation-run/append-to-automation-run.mjs

@@ -0,0 +1,99 @@
+import testmo from "../../testmo.app.mjs";
+import constants from "../../common/constants.mjs";
+
+export default {
+  key: "testmo-append-to-automation-run",
+  name: "Append to Automation Run",
+  version: "0.0.1",
+  description: "Appends test artifacts, fields or links to an existing automation run. [See the documentation](https://docs.testmo.com/api/reference/automation-runs#post-automation-runs-automation_run_id-append)",
+  type: "action",
+  props: {
+    testmo,
+    projectId: {
+      propDefinition: [
+        testmo,
+        "projectId",
+      ],
+    },
+    automationRunId: {
+      propDefinition: [
+        testmo,
+        "automationRunId",
+        (c) => ({
+          projectId: c.projectId,
+        }),
+      ],
+    },
+    artifacts: {
+      propDefinition: [
+        testmo,
+        "artifacts",
+      ],
+    },
+    links: {
+      type: "string[]",
+      label: "Links",
+      description: "List of links to attach to the automation run (such as a link back to the build in the CI tool that triggered the tests).",
+      optional: true,
+    },
+    numFields: {
+      type: "integer",
+      label: "Number of Fields",
+      description: "Number of fields to enter name, type, and value for",
+      optional: true,
+      reloadProps: true,
+    },
+  },
+  async additionalProps() {
+    const props = {};
+    for (let i = 1; i <= this.numFields; i++) {
+      props[`name_${i}`] = {
+        type: "string",
+        label: `Field ${i} - Name`,
+      };
+      props[`type_${i}`] = {
+        type: "integer",
+        label: `Field ${i} - Type`,
+        options: constants.FIELD_TYPES,
+      };
+      props[`value_${i}`] = {
+        type: "string",
+        label: `Field ${i} - Value`,
+        optional: true,
+      };
+    }
+    return props;
+  },
+  async run({ $ }) {
+    const artifacts = this.artifacts?.map((artifact) => ({
+      name: artifact,
+      url: artifact,
+    }));
+    const links = this.links?.map((link) => ({
+      name: link,
+      url: link,
+    }));
+    const fields = [];
+    for (let i = 1; i <= this.numFields; i++) {
+      fields.push({
+        name: this[`name_${i}`],
+        type: this[`type_${i}`],
+        value: this[`value_${i}`],
+      });
+    }
+
+    const response = await this.testmo.appendToAutomationRun({
+      automationRunId: this.automationRunId,
+      data: {
+        artifacts,
+        links,
+        fields,
+      },
+      $,
+    });
+
+    $.export("$summary", `Successfully appended data to automation run with ID ${this.automationRunId}.`);
+
+    return response;
+  },
+};

package/actions/append-to-thread/append-to-thread.mjs

@@ -0,0 +1,147 @@
+import testmo from "../../testmo.app.mjs";
+import constants from "../../common/constants.mjs";
+
+export default {
+  key: "testmo-append-to-thread",
+  name: "Append to Thread in Automation Run",
+  version: "0.0.1",
+  description: "Appends test artifacts, fields or test results to an existing thread in an automation run. [See the documentation](https://docs.testmo.com/api/reference/automation-runs#post-automation-runs-threads-automation_run_thread_id-append)",
+  type: "action",
+  props: {
+    testmo,
+    projectId: {
+      propDefinition: [
+        testmo,
+        "projectId",
+      ],
+    },
+    automationRunId: {
+      propDefinition: [
+        testmo,
+        "automationRunId",
+        (c) => ({
+          projectId: c.projectId,
+        }),
+      ],
+    },
+    threadId: {
+      propDefinition: [
+        testmo,
+        "threadId",
+        (c) => ({
+          automationRunId: c.automationRunId,
+        }),
+      ],
+    },
+    elapsedObserved: {
+      type: "integer",
+      label: "Elapsed Observed",
+      description: "Partial observed elapsed (execution time) in microseconds to add to the overall observed time of the thread.",
+      optional: true,
+    },
+    artifacts: {
+      propDefinition: [
+        testmo,
+        "artifacts",
+      ],
+    },
+    numFields: {
+      type: "integer",
+      label: "Number of Fields",
+      description: "Number of fields to append",
+      optional: true,
+      reloadProps: true,
+    },
+    numTests: {
+      type: "integer",
+      label: "Number of Tests",
+      description: "Number of tests to append",
+      optional: true,
+      reloadProps: true,
+    },
+  },
+  async additionalProps() {
+    const props = {};
+    if (this.numFields) {
+      for (let i = 1; i <= this.numFields; i++) {
+        props[`fieldName_${i}`] = {
+          type: "string",
+          label: `Field ${i} - Name`,
+        };
+        props[`type_${i}`] = {
+          type: "integer",
+          label: `Field ${i} - Type`,
+          options: constants.FIELD_TYPES,
+        };
+        props[`value_${i}`] = {
+          type: "string",
+          label: `Field ${i} - Value`,
+          optional: true,
+        };
+      }
+    }
+    if (this.numTests) {
+      for (let i = 1; i <= this.numTests; i++) {
+        props[`key_${i}`] = {
+          type: "string",
+          label: `Test ${i} - Key`,
+          description: "Key used to identify tests across multiple automation runs (in the context of the same source)",
+        };
+        props[`testName_${i}`] = {
+          type: "string",
+          label: `Test ${i} - Name`,
+          description: "Name of the test",
+        };
+        props[`status_${i}`] = {
+          type: "string",
+          label: `Test ${i} - Status`,
+          description: "Alias of the status for the result of the test (for example, `failed` or `passed`). The status aliases can be configured in Testmo's admin area.",
+        };
+        props[`folder_${i}`] = {
+          type: "string",
+          label: `Test ${i} - Folder`,
+          description: "Fully qualified name of the target folder of the test. Folders can be used to group related tests and usually map to class or type names as defined in the test automation suite",
+        };
+      }
+    }
+    return props;
+  },
+  async run({ $ }) {
+    const artifacts = this.artifacts?.map((artifact) => ({
+      name: artifact,
+      url: artifact,
+    }));
+    const fields = [];
+    for (let i = 1; i <= this.numFields; i++) {
+      fields.push({
+        name: this[`fieldName_${i}`],
+        type: this[`type_${i}`],
+        value: this[`value_${i}`],
+      });
+    }
+    const tests = [];
+    for (let i = 1; i <= this.numTests; i++) {
+      tests.push({
+        key: this[`key_${i}`],
+        name: this[`testName_${i}`],
+        status: this[`status_${i}`],
+        folder: this[`folder_${i}`],
+      });
+    }
+
+    const response = await this.testmo.appendToThread({
+      threadId: this.threadId,
+      data: {
+        elapsed_observed: this.elapsedObserved,
+        artifacts,
+        fields,
+        tests,
+      },
+      $,
+    });
+
+    $.export("$summary", `Successfully appended data to automation run thread with ID ${this.threadId}.`);
+
+    return response;
+  },
+};

package/actions/create-automation-run/create-automation-run.mjs

@@ -0,0 +1,113 @@
+import { parseArray } from "../../common/utils.mjs";
+import testmo from "../../testmo.app.mjs";
+
+export default {
+  key: "testmo-create-automation-run",
+  name: "Create Automation Run",
+  version: "0.0.2",
+  description: "Creates a new automation run in a target project in preparation for adding threads and test results. [See the documentation](https://docs.testmo.com/api/reference/automation-runs#post-projects-project_id-automation-runs)",
+  type: "action",
+  props: {
+    testmo,
+    projectId: {
+      propDefinition: [
+        testmo,
+        "projectId",
+      ],
+    },
+    name: {
+      type: "string",
+      label: "Name",
+      description: "Name of the new automation run.",
+    },
+    source: {
+      propDefinition: [
+        testmo,
+        "source",
+        ({ projectId }) => ({
+          projectId,
+        }),
+      ],
+    },
+    config: {
+      type: "string",
+      label: "Config",
+      description: "Name of the configuration for the new automation run.",
+      optional: true,
+    },
+    configId: {
+      type: "string",
+      label: "Config Id",
+      description: "ID of the configuration for the new automation run. If both config and `configId` are specified, `configId` is given precedence.",
+      optional: true,
+    },
+    milestone: {
+      type: "string",
+      label: "Milestone",
+      description: "Name of the milestone for the new automation run.",
+      optional: true,
+    },
+    milestoneId: {
+      propDefinition: [
+        testmo,
+        "milestoneId",
+        ({ projectId }) => ({
+          projectId,
+        }),
+      ],
+      optional: true,
+    },
+    tags: {
+      type: "string[]",
+      label: "Tags",
+      description: "List of tags for the new automation run. If a milestone in the same project has one or more matching automation tags, the new automation run is automatically linked to that milestone (unless `milestone` or `milestoneId` is also specified).",
+      optional: true,
+    },
+    artifacts: {
+      type: "string[]",
+      label: "Artifacts",
+      description: "List of externally stored test artifacts to link to the new automation run (such as log files, screenshots or test data). [See de documentation for details](https://docs.testmo.com/api/reference/automation-runs#post-projects-project_id-automation-runs)",
+      optional: true,
+    },
+    fields: {
+      type: "string[]",
+      label: "Fields",
+      description: "List of fields to attach to the new automation run (such as environment variables, errors or terminal output). [See de documentation for details](https://docs.testmo.com/api/reference/automation-runs#post-projects-project_id-automation-runs)",
+      optional: true,
+    },
+    links: {
+      type: "string[]",
+      label: "Links",
+      description: "List of links to attach to the new automation run (such as a link back to the build in the CI tool that triggered the tests). [See de documentation for details](https://docs.testmo.com/api/reference/automation-runs#post-projects-project_id-automation-runs)",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const {
+      testmo,
+      projectId,
+      configId,
+      milestoneId,
+      artifacts,
+      fields,
+      links,
+      ...data
+    } = this;
+
+    const response = await testmo.createAutomationRun({
+      $,
+      projectId,
+      data: {
+        config_id: configId,
+        milestone_id: milestoneId,
+        artifacts: parseArray(artifacts),
+        fields: parseArray(fields),
+        links: parseArray(links),
+        ...data,
+      },
+    });
+
+    $.export("$summary", `A new automation run with Id: ${response.id} was successfully created!`);
+    return response;
+  },
+};

package/actions/list-automation-runs/list-automation-runs.mjs

@@ -0,0 +1,41 @@
+import testmo from "../../testmo.app.mjs";
+
+export default {
+  key: "testmo-list-automation-runs",
+  name: "List Automation Runs",
+  version: "0.0.2",
+  description: "List all automation runs for a project. [See the documentation](https://docs.testmo.com/api/reference/automation-runs#get-projects-project_id-automation-runs)",
+  type: "action",
+  props: {
+    testmo,
+    projectId: {
+      propDefinition: [
+        testmo,
+        "projectId",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const {
+      testmo,
+      projectId,
+    } = this;
+
+    const items = testmo.paginate({
+      fn: testmo.listAutomationRuns,
+      projectId,
+    });
+
+    const responseArray = [];
+
+    for await (const item of items) {
+      responseArray.push(item);
+    }
+
+    $.export("$summary", `${responseArray.length} automation run${responseArray.length > 1
+      ? "s were"
+      : " was"} successfully fetched!`);
+
+    return responseArray;
+  },
+};

package/actions/list-project-sessions/list-project-sessions.mjs

@@ -0,0 +1,41 @@
+import testmo from "../../testmo.app.mjs";
+
+export default {
+  key: "testmo-list-project-sessions",
+  name: "List Project Sessions",
+  version: "0.0.1",
+  description: "List all sessions for a project. [See the documentation](https://docs.testmo.com/api/reference/sessions#get-projects-project_id-sessions)",
+  type: "action",
+  props: {
+    testmo,
+    projectId: {
+      propDefinition: [
+        testmo,
+        "projectId",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const {
+      testmo,
+      projectId,
+    } = this;
+
+    const items = testmo.paginate({
+      fn: testmo.listSessions,
+      projectId,
+    });
+
+    const responseArray = [];
+
+    for await (const item of items) {
+      responseArray.push(item);
+    }
+
+    $.export("$summary", `${responseArray.length} session${responseArray.length === 1
+      ? " was"
+      : "s were"} successfully retrieved!`);
+
+    return responseArray;
+  },
+};

package/common/constants.mjs

@@ -0,0 +1,26 @@
+const FIELD_TYPES = [
+  {
+    value: 1,
+    label: "Regular string",
+  },
+  {
+    value: 2,
+    label: "Plain text",
+  },
+  {
+    value: 3,
+    label: "HTML text",
+  },
+  {
+    value: 4,
+    label: "Text to display in a terminal/console frame (with a monospaced font)",
+  },
+  {
+    value: 5,
+    label: "URL",
+  },
+];
+
+export default {
+  FIELD_TYPES,
+};

package/common/utils.mjs

@@ -0,0 +1,16 @@
+export const parseArray = (array) => {
+  let parsedArray = array;
+  if (array) {
+    if (!Array.isArray(array)) {
+      parsedArray = JSON.parse(array);
+    }
+
+    parsedArray = parsedArray.map((item) => {
+      if (typeof item != "object") {
+        return JSON.parse(item);
+      }
+      return item;
+    });
+  }
+  return parsedArray;
+};

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@pipedream/testmo",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Pipedream Testmo Components",
-  "main": "dist/app/testmo.app.mjs",
+  "main": "testmo.app.mjs",
   "keywords": [
     "pipedream",
     "testmo"
   ],
-  "files": [
-    "dist"
-  ],
   "homepage": "https://pipedream.com/apps/testmo",
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^1.5.1"
   }
 }

package/testmo.app.mjs

@@ -0,0 +1,236 @@
+import { axios } from "@pipedream/platform";
+
+export default {
+  type: "app",
+  app: "testmo",
+  propDefinitions: {
+    milestoneId: {
+      type: "string",
+      label: "Milestone Id",
+      description: "ID of the milestone for the new automation run. If both milestone and `milestoneId` are specified, `milestoneId` is given precedence.",
+      async options({
+        page, projectId,
+      }) {
+        const { result } = await this.listMilestones({
+          projectId,
+          params: {
+            page: page + 1,
+          },
+        });
+
+        return result.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    projectId: {
+      type: "string",
+      label: "Project Id",
+      description: "The Id of the target project.",
+      async options({ page }) {
+        const { result } = await this.listProjects({
+          params: {
+            page: page + 1,
+          },
+        });
+
+        return result.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    source: {
+      type: "string",
+      label: "Source",
+      description: "Name of the source for the new automation run. If this source does not already exist in the target project, Testmo automatically creates a new one. It is recommended to keep source names short. Good examples are `backend`, `frontend` or `mobile-iphone`.",
+      async options({
+        page, projectId,
+      }) {
+        const { result } = await this.listSources({
+          projectId,
+          params: {
+            page: page + 1,
+          },
+        });
+
+        return result.map(({ name }) => name);
+      },
+    },
+    automationRunId: {
+      type: "string",
+      label: "Automation Run Id",
+      description: "The Id of the automation run.",
+      async options({
+        projectId, page,
+      }) {
+        const { result } = await this.listAutomationRuns({
+          projectId,
+          params: {
+            page: page + 1,
+          },
+        });
+
+        return result.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    threadId: {
+      type: "string",
+      label: "Thread Id",
+      description: "The Id of the thread of the automation run.",
+      async options({ automationRunId }) {
+        const { result } = await this.getAutomationRun({
+          automationRunId,
+        });
+        if (!result || !result?.threads) {
+          return;
+        }
+        return result.threads.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    artifacts: {
+      type: "string[]",
+      label: "Artifacts",
+      description: "List of URLs of externally stored test artifacts to link to the thread (such as log files, screenshots or test data)",
+      optional: true,
+    },
+  },
+  methods: {
+    _apiUrl() {
+      return `https://${this.$auth.sitename}.testmo.net/api/v1`;
+    },
+    _getHeaders() {
+      return {
+        "Authorization": `Bearer ${this.$auth.api_key}`,
+      };
+    },
+    _makeRequest({
+      $ = this, path, ...opts
+    }) {
+      const config = {
+        url: `${this._apiUrl()}/${path}`,
+        headers: this._getHeaders(),
+        ...opts,
+      };
+
+      return axios($, config);
+    },
+    createAutomationRun({
+      projectId, ...args
+    }) {
+      return this._makeRequest({
+        method: "POST",
+        path: `projects/${projectId}/automation/runs`,
+        ...args,
+      });
+    },
+    listAutomationRuns({
+      projectId, ...args
+    }) {
+      return this._makeRequest({
+        path: `projects/${projectId}/automation/runs`,
+        ...args,
+      });
+    },
+    listMilestones({
+      projectId, ...args
+    }) {
+      return this._makeRequest({
+        path: `projects/${projectId}/milestones`,
+        ...args,
+      });
+    },
+    listProjects(args = {}) {
+      return this._makeRequest({
+        path: "projects",
+        ...args,
+      });
+    },
+    listSources({
+      projectId, ...args
+    }) {
+      return this._makeRequest({
+        path: `projects/${projectId}/automation/sources`,
+        ...args,
+      });
+    },
+    getAutomationRun({
+      automationRunId, ...args
+    }) {
+      return this._makeRequest({
+        path: `automation/runs/${automationRunId}`,
+        ...args,
+      });
+    },
+    listSessions({
+      projectId, ...args
+    }) {
+      return this._makeRequest({
+        path: `projects/${projectId}/sessions`,
+        ...args,
+      });
+    },
+    appendToAutomationRun({
+      automationRunId, ...args
+    }) {
+      return this._makeRequest({
+        method: "POST",
+        path: `automation/runs/${automationRunId}/append`,
+        ...args,
+      });
+    },
+    appendToThread({
+      threadId, ...args
+    }) {
+      return this._makeRequest({
+        method: "POST",
+        path: `automation/runs/threads/${threadId}/append`,
+        ...args,
+      });
+    },
+    async *paginate({
+      fn, params = {}, maxResults = null, ...args
+    }) {
+      let hasMore = false;
+      let count = 0;
+      let page = 0;
+
+      do {
+        params.page = ++page;
+        const {
+          result,
+          page: currentPage,
+          last_page: lastPage,
+        } = await fn({
+          params,
+          ...args,
+        });
+        for (const d of result) {
+          yield d;
+
+          if (maxResults && ++count === maxResults) {
+            return count;
+          }
+        }
+
+        hasMore = !(currentPage == lastPage);
+
+      } while (hasMore);
+    },
+  },
+};