@argos-ci/core 0.1.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2022 Smooth Code
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+<p align="center">
+  <a href="https://argos-ci.com/?utm_source=github&utm_medium=logo" target="_blank">
+    <img src="https://raw.githubusercontent.com/argos-ci/argos/main/resources/logos/logo-github-readme.png" alt="Argos" width="300" height="61">
+  </a>
+</p>
+
+_Argos is a visual testing solution that fits in your workflow to avoid visual regression. Takes screenshots on each commit and be notified if something changes._
+
+# Argos JavaScript SDK Core
+
+Argos Core JavaScript SDK contains interface definitions, base classes and utilities for building Argos JavaScript SDKs, like `@argos-ci/cli` or using it directly with Node.js.
+
+[![npm version](https://img.shields.io/npm/v/@argos-ci/core.svg)](https://www.npmjs.com/package/@argos-ci/core)
+[![npm dm](https://img.shields.io/npm/dm/@argos-ci/core.svg)](https://www.npmjs.com/package/@argos-ci/core)
+[![npm dt](https://img.shields.io/npm/dt/@argos-ci/core.svg)](https://www.npmjs.com/package/@argos-ci/core)
+
+## Links
+
+- [Official SDK Docs](https://docs.argos-ci.com)
+- [API Reference](https://js-sdk-reference.argos-ci.com)

package/dist/index.cjs

@@ -0,0 +1,5 @@
+exports.upload = async (params)=>{
+    // @ts-ignore
+    const { upload  } = await import('./index.mjs');
+    return upload(params);
+};

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+interface UploadParameters {
+    /** Globs matching image file paths to upload */
+    files?: string[];
+    /** Root directory to look for image to upload (default to current directory) */
+    root?: string;
+    /** Globs matching image file paths to ignore (default to "**\/*.{png,jpg,jpeg}") */
+    ignore?: string[];
+    /** Base URL of Argos API (default to "https://api.argos-ci.com/v2/") */
+    apiBaseUrl?: string;
+    /** Git commit */
+    commit?: string;
+    /** Git branch */
+    branch?: string;
+    /** Argos repository token */
+    token?: string;
+    /** Name of the build used to trigger multiple Argos builds on one commit */
+    buildName?: string;
+    /** Parallel test suite mode */
+    parallel?: {
+        /** Unique build ID for this parallel build */
+        nonce: string;
+        /** The number of parallel nodes being ran */
+        total: number;
+    } | false;
+}
+/**
+ * Upload screenshots to argos-ci.com.
+ */
+declare const upload: (params: UploadParameters) => Promise<{
+    build: {
+        id: string;
+        url: string;
+    };
+    screenshots: {
+        optimizedPath: string;
+        hash: any;
+        name: string;
+        path: string;
+    }[];
+}>;
+
+export { UploadParameters, upload };

package/dist/index.mjs

@@ -0,0 +1,363 @@
+import convict from 'convict';
+import envCi from 'env-ci';
+import { execSync } from 'child_process';
+import { resolve } from 'node:path';
+import glob from 'fast-glob';
+import { promisify } from 'node:util';
+import sharp from 'sharp';
+import tmp from 'tmp';
+import { createReadStream } from 'node:fs';
+import { createHash } from 'node:crypto';
+import axios from 'axios';
+import { readFile } from 'node:fs/promises';
+import createDebug from 'debug';
+
+const mustBeApiBaseUrl = (value)=>{
+    const URL_REGEX = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)/;
+    if (!URL_REGEX.test(value)) {
+        throw new Error("Invalid Argos API base URL");
+    }
+};
+const mustBeCommit = (value)=>{
+    const SHA1_REGEX = /^[0-9a-f]{40}$/;
+    if (!SHA1_REGEX.test(value)) {
+        const SHA1_SHORT_REGEX = /^[0-9a-f]{7}$/;
+        if (SHA1_SHORT_REGEX.test(value)) {
+            throw new Error("Short SHA1 is not allowed");
+        }
+        throw new Error("Invalid commit");
+    }
+};
+const mustBeArgosToken = (value)=>{
+    if (value.length !== 40) {
+        throw new Error("Must be a valid Argos repository token");
+    }
+};
+const schema = {
+    apiBaseUrl: {
+        env: "ARGOS_API_BASE_URL",
+        default: "https://api.argos-ci.com/v2/",
+        format: mustBeApiBaseUrl
+    },
+    commit: {
+        env: "ARGOS_COMMIT",
+        default: "",
+        format: mustBeCommit
+    },
+    branch: {
+        env: "ARGOS_BRANCH",
+        default: null,
+        format: String,
+        nullable: true
+    },
+    token: {
+        env: "ARGOS_TOKEN",
+        default: "",
+        format: mustBeArgosToken
+    },
+    buildName: {
+        env: "ARGOS_BUILD_NAME",
+        default: null,
+        format: String,
+        nullable: true
+    },
+    parallel: {
+        env: "ARGOS_PARALLEL",
+        default: false,
+        format: Boolean
+    },
+    parallelNonce: {
+        env: "ARGOS_PARALLEL_NONCE",
+        format: String,
+        default: null,
+        nullable: true
+    },
+    parallelTotal: {
+        env: "ARGOS_PARALLEL_TOTAL",
+        format: "nat",
+        default: null,
+        nullable: true
+    },
+    ciService: {
+        format: String,
+        default: null,
+        nullable: true
+    }
+};
+const createConfig = ()=>{
+    return convict(schema, {
+        args: []
+    });
+};
+
+/**
+ * Omit undefined properties from an object.
+ */ const omitUndefined = (obj)=>{
+    const result = {};
+    Object.keys(obj).forEach((key)=>{
+        if (obj[key] !== undefined) {
+            result[key] = obj[key];
+        }
+    });
+    return result;
+};
+
+const service$1 = {
+    detect: ({ env  })=>Boolean(env.HEROKU_TEST_RUN_ID),
+    config: ({ env  })=>({
+            name: "Heroku",
+            commit: env.HEROKU_TEST_RUN_COMMIT_VERSION || null,
+            branch: env.HEROKU_TEST_RUN_BRANCH || null
+        })
+};
+
+const getSha = ({ env  })=>{
+    const isPr = env.GITHUB_EVENT_NAME === "pull_request" || env.GITHUB_EVENT_NAME === "pull_request_target";
+    if (isPr) {
+        const mergeCommitRegex = /^[a-z0-9]{40} [a-z0-9]{40}$/;
+        const mergeCommitMessage = execSync("git show --no-patch --format=%P").toString().trim();
+        console.log(`Handling PR with parent hash(es) '${mergeCommitMessage}' of current commit.`);
+        if (mergeCommitRegex.exec(mergeCommitMessage)) {
+            const mergeCommit = mergeCommitMessage.split(" ")[1];
+            console.log(`Fixing merge commit SHA ${process.env.GITHUB_SHA} -> ${mergeCommit}`);
+            return mergeCommit;
+        } else if (mergeCommitMessage === "") {
+            console.error(`
+Issue detecting commit SHA. Please run actions/checkout with "fetch-depth: 2":
+
+steps:
+  - uses: actions/checkout@v3
+    with:
+      fetch-depth: 2
+`.trim());
+            process.exit(1);
+        } else {
+            console.error(`Commit with SHA ${process.env.GITHUB_SHA} is not a valid commit`);
+            process.exit(1);
+        }
+    }
+    return process.env.GITHUB_SHA ?? null;
+};
+function getBranch({ env  }) {
+    if (env.GITHUB_HEAD_REF) {
+        return env.GITHUB_HEAD_REF;
+    }
+    const branchRegex = /refs\/heads\/(.*)/;
+    const branchMatches = branchRegex.exec(env.GITHUB_REF || "");
+    if (branchMatches) {
+        return branchMatches[1];
+    }
+    return null;
+}
+const service = {
+    detect: ({ env  })=>Boolean(env.GITHUB_ACTIONS),
+    config: ({ env  })=>({
+            name: "GiHub Actions",
+            commit: getSha({
+                env
+            }),
+            branch: getBranch({
+                env
+            })
+        })
+};
+
+const services = [
+    service$1,
+    service
+];
+const getCiEnvironment = ({ env =process.env  } = {})=>{
+    const ctx = {
+        env
+    };
+    const service = services.find((service)=>service.detect(ctx));
+    // Internal service matched
+    if (service) {
+        return service.config(ctx);
+    }
+    // Fallback on env-ci detection
+    const ciContext = envCi(ctx);
+    const name = ciContext.isCi ? ciContext.name ?? null : ciContext.commit ? "Git" : null;
+    const commit = ciContext.commit ?? null;
+    const branch = ciContext.branch ?? null;
+    return commit ? {
+        name,
+        commit,
+        branch
+    } : null;
+};
+
+const discoverScreenshots = async (patterns, { root =process.cwd() , ignore  } = {})=>{
+    const matches = await glob(patterns, {
+        onlyFiles: true,
+        ignore,
+        cwd: root
+    });
+    return matches.map((match)=>({
+            name: match,
+            path: resolve(root, match)
+        }));
+};
+
+const tmpFile = promisify(tmp.file);
+const optimizeScreenshot = async (filepath)=>{
+    const resultFilePath = await tmpFile();
+    await sharp(filepath).resize(1024, 1024, {
+        fit: "inside",
+        withoutEnlargement: true
+    }).jpeg().toFile(resultFilePath);
+    return resultFilePath;
+};
+
+const hashFile = async (filepath)=>{
+    const fileStream = createReadStream(filepath);
+    const hash = createHash("sha256");
+    await new Promise((resolve, reject)=>{
+        fileStream.on("error", reject);
+        hash.on("error", reject);
+        hash.on("finish", resolve);
+        fileStream.pipe(hash);
+    });
+    return hash.read().toString("hex");
+};
+
+const createArgosApiClient = (options)=>{
+    const axiosInstance = axios.create({
+        baseURL: options.baseUrl,
+        headers: {
+            Authorization: `Bearer ${options.token}`,
+            "Content-Type": "application/json",
+            Accept: "application/json"
+        }
+    });
+    const call = async (method, path, data)=>{
+        try {
+            const response = await axiosInstance.request({
+                method,
+                url: path,
+                data
+            });
+            return response.data;
+        } catch (error) {
+            throw error;
+        }
+    };
+    return {
+        createBuild: async (input)=>{
+            return call("POST", "/builds", input);
+        },
+        updateBuild: async (input)=>{
+            const { buildId , ...body } = input;
+            return call("PUT", `/builds/${buildId}`, body);
+        }
+    };
+};
+
+const upload$1 = async (input)=>{
+    const file = await readFile(input.path);
+    await axios({
+        method: "PUT",
+        url: input.url,
+        data: file,
+        headers: {
+            "Content-Type": "image/png"
+        }
+    });
+};
+
+const debug = createDebug("@argos-ci/core");
+
+const getConfigFromOptions = (options)=>{
+    const { apiBaseUrl , commit , branch , token , buildName , parallel  } = options;
+    const config = createConfig();
+    config.load(omitUndefined({
+        apiBaseUrl,
+        commit,
+        branch,
+        token,
+        buildName,
+        parallel: Boolean(parallel),
+        parallelNonce: parallel ? parallel.nonce : null,
+        parallelTotal: parallel ? parallel.total : null
+    }));
+    if (!config.get("commit")) {
+        const ciEnv = getCiEnvironment();
+        if (ciEnv) {
+            config.load(omitUndefined({
+                commit: ciEnv.commit,
+                branch: ciEnv.branch,
+                ciService: ciEnv.name
+            }));
+        }
+    }
+    config.validate();
+    return config.get();
+};
+/**
+ * Upload screenshots to argos-ci.com.
+ */ const upload = async (params)=>{
+    // Read config
+    const config = getConfigFromOptions(params);
+    const files = params.files ?? [
+        "**/*.{png,jpg,jpeg}"
+    ];
+    // Collect screenshots
+    const foundScreenshots = await discoverScreenshots(files, {
+        root: params.root,
+        ignore: params.ignore
+    });
+    // Optimize & compute hashes
+    const screenshots = await Promise.all(foundScreenshots.map(async (screenshot)=>{
+        const optimizedPath = await optimizeScreenshot(screenshot.path);
+        const hash = await hashFile(optimizedPath);
+        return {
+            ...screenshot,
+            optimizedPath,
+            hash
+        };
+    }));
+    const apiClient = createArgosApiClient({
+        baseUrl: config.apiBaseUrl,
+        token: config.token
+    });
+    // Create build
+    debug("Creating build");
+    const result = await apiClient.createBuild({
+        commit: config.commit,
+        branch: config.branch,
+        name: config.buildName,
+        parallel: config.parallel,
+        parallelNonce: config.parallelNonce,
+        screenshotKeys: screenshots.map((screenshot)=>screenshot.hash)
+    });
+    debug("Got screenshots", result);
+    // Upload screenshots
+    debug("Uploading screenshots");
+    await Promise.all(result.screenshots.map(async ({ key , putUrl  })=>{
+        const screenshot = screenshots.find((s)=>s.hash === key);
+        if (!screenshot) {
+            throw new Error(`Invariant: screenshot with hash ${key} not found`);
+        }
+        await upload$1({
+            url: putUrl,
+            path: screenshot.optimizedPath
+        });
+    }));
+    // Update build
+    debug("Updating build");
+    await apiClient.updateBuild({
+        buildId: result.build.id,
+        screenshots: screenshots.map((screenshot)=>({
+                key: screenshot.hash,
+                name: screenshot.name
+            })),
+        parallel: config.parallel,
+        parallelTotal: config.parallelTotal
+    });
+    return {
+        build: result.build,
+        screenshots
+    };
+};
+
+export { upload };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@argos-ci/core",
+  "description": "Visual testing solution to avoid visual regression. The core component of Argos SDK that handles build creation.",
+  "version": "0.1.0",
+  "scripts": {
+    "prebuild": "rm -rf dist",
+    "build": "rollup -c",
+    "e2e": "node ./e2e/upload.cjs && node ./e2e/upload.mjs"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/argos-ci/argos-javascript.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/argos-ci/argos-javascript/tree/main/packages/core#readme",
+  "bugs": {
+    "url": "https://github.com/argos-ci/argos-javascript/issues"
+  },
+  "engines": {
+    "node": ">=16.14.0"
+  },
+  "license": "MIT",
+  "keywords": [
+    "argos",
+    "automation",
+    "test automation",
+    "testing",
+    "visual testing",
+    "regression",
+    "visual regression"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "axios": "^0.27.2",
+    "convict": "^6.2.3",
+    "debug": "^4.3.4",
+    "env-ci": "^7.3.0",
+    "fast-glob": "^3.2.11",
+    "sharp": "^0.30.7",
+    "tmp": "^0.2.1"
+  },
+  "devDependencies": {
+    "@types/convict": "^6.1.1",
+    "msw": "^0.44.2",
+    "rollup": "^2.78.0",
+    "rollup-plugin-dts": "^4.2.2",
+    "rollup-plugin-swc3": "^0.3.0"
+  },
+  "gitHead": "ff22c7f1ecf8cbbd1468440b3247d10b3b7b7310"
+}