apify-test-tools 0.1.0

package/bin/test-report.ts

@@ -0,0 +1,146 @@
+import fs from 'fs/promises';
+import { sendSlackMessage } from './slack.js';
+import { getEnvVar } from './utils.js';
+
+interface ReportTestRestulsOptions {
+    reportFile: string
+    dryRun: boolean
+    jobUrl?: string
+    repository?: string
+    workflowName?: string
+}
+
+export const reportTestRestuls = async ({
+    dryRun,
+    reportFile: jsonResultsPath,
+    jobUrl,
+    workflowName,
+    repository,
+}: ReportTestRestulsOptions) => {
+    const results: JsonTestResults = JSON.parse((await fs.readFile(jsonResultsPath)).toString());
+    const passed: JsonAssertionResult[] = [];
+    const failed: JsonAssertionResult[] = [];
+
+    for (const result of results.testResults) {
+        if (result.status !== 'failed') {
+            passed.push(...result.assertionResults);
+            continue;
+        }
+        for (const aResult of result.assertionResults) {
+            if (aResult.status !== 'failed') {
+                passed.push(aResult);
+            } else {
+                failed.push(aResult);
+            }
+        }
+    }
+
+    const failedAssertions: string[] = [];
+
+    console.error();
+    console.error(`PASSED: ${passed.length}, FAILED: ${failed.length}`);
+    console.error();
+    console.error('**************************************************');
+    console.error('*                   Successes                    *');
+    console.error('**************************************************');
+    console.error();
+    for (const [i, aResult] of passed.entries()) {
+        const { fullName } = aResult;
+        console.error(`${i + 1}) ${fullName} ... ${aResult.meta.runLink}`);
+        console.error();
+    }
+
+    console.error('**************************************************');
+    console.error('*                   Failures                     *');
+    console.error('**************************************************');
+    console.error();
+    for (const [i, aResult] of failed.entries()) {
+        const { failureMessages, fullName } = aResult;
+        if (failureMessages) {
+            failedAssertions.push(...failureMessages.map(message => message.split('\n')?.[0]));
+        }
+        console.error(`${i + 1}) ${fullName} ... ${aResult.meta.runLink}`);
+        console.error();
+    }
+    console.error();
+    console.error(`PASSED: ${passed.length}, FAILED: ${failed.length}`);
+    console.error();
+
+    if (failedAssertions.length === 0) {
+        return;
+    }
+
+    // TODO: add slack profiles
+    const total = failed.length + passed.length;
+    const jobLink = jobUrl ? ` Check <${jobUrl}|the job>.` : '';
+    let slackMessage = `\`${workflowName ?? '-'}\`: *${repository ?? '-'}*`;
+    slackMessage += `: has ${failedAssertions.length} failed assertions. Failing test suites: ${failed.length}/${total}.${jobLink}`;
+    slackMessage += `\n\n${failedAssertions[0]}`;
+    const blocks = failedAssertions.slice(1);
+
+    if (!repository) {
+        console.error(`Repository not provided, not sending slack notification`);
+        return
+    }
+
+    // remove repository-owner part
+    const channel = `#notif-${repository.replace(/[^/]+\//, '')}`;
+    console.error(`Sending a notification to slack channel ${channel}`);
+    console.error('SLACK:', slackMessage);
+    console.error('  blocks:', blocks.join('\n'));
+    if (!dryRun) {
+        const slackToken = getEnvVar('SLACK_TOKEN_TESTS_BOT');
+        await sendSlackMessage(channel, slackMessage, blocks, slackToken);
+    }
+};
+
+type Status = 'passed' | 'failed' | 'skipped' | 'pending' | 'todo' | 'disabled'
+type Milliseconds = number
+interface Callsite {
+    line: number
+    column: number
+}
+
+interface JsonAssertionResult {
+    ancestorTitles: Array<string>
+    fullName: string
+    status: Status
+    title: string
+    meta: {
+        runId: string
+        runLink: string
+    }
+    duration?: Milliseconds | null
+    failureMessages: Array<string> | null
+    location?: Callsite | null
+}
+
+interface JsonTestResult {
+    message: string
+    name: string
+    status: 'failed' | 'passed'
+    startTime: number
+    endTime: number
+    assertionResults: Array<JsonAssertionResult>
+    // summary: string
+    // coverage: unknown
+}
+
+interface JsonTestResults {
+    numFailedTests: number
+    numFailedTestSuites: number
+    numPassedTests: number
+    numPassedTestSuites: number
+    numPendingTests: number
+    numPendingTestSuites: number
+    numTodoTests: number
+    numTotalTests: number
+    numTotalTestSuites: number
+    startTime: number
+    success: boolean
+    testResults: Array<JsonTestResult>
+    // snapshot: SnapshotSummary
+    // coverageMap?: CoverageMap | null | undefined
+    // numRuntimeErrorTestSuites: number
+    // wasInterrupted: boolean
+}

package/bin/types.ts

@@ -0,0 +1,102 @@
+export interface Config {
+    targetBranch: string
+    sourceBranch: string
+    baseCommit?: string
+}
+
+export type Commit = {
+    sha: string
+    author: string
+    date: string
+    message: string
+}
+
+// NOTE: The GitHub types are incomplete, feel free to add fields/complete (not sure how stable GitHub API is)
+export interface GitHubHeadCommit {
+    added: string[]
+    removed: string[]
+    modified: string[],
+    author: {
+        name: string
+    },
+    message: string,
+    id: string,
+}
+
+export interface Repository {
+    full_name: string
+    name: string
+    ssh_url: string
+    owner: {
+        login: string
+    }
+}
+
+export type GitHubEvent = GitHubEventPullRequest | GitHubEventPush;
+
+// All optional type so we check that we have all required fields for each event type
+export type RawGitHubEvent = Partial<Omit<GitHubEventPullRequest, 'type'> & Omit<GitHubEventPush, 'type'>>;
+
+export interface GitHubEventPullRequest {
+    // Type is our own variable we inject to have discriminated union
+    // The rest of the properties are raw from GitHub API
+    type: 'pull_request',
+    pull_request: {
+        number: number
+        base: {
+            ref: string,
+            sha: string
+        }
+        head: {
+            ref: string
+            sha: string
+        }
+    }
+    repository: Repository,
+}
+
+export interface GitHubEventPush {
+    type: 'push',
+    head_commit: GitHubHeadCommit,
+    repository: Repository,
+    ref: string
+    commits: GithubCommit[]
+    before: string
+    after: string
+}
+
+export interface GithubCommit {
+    id: string
+    tree_id: string
+    distinct: boolean
+    message: string
+    timestamp: string
+    url: string
+    author: {
+        name: string
+        email: string
+        username: string
+    }
+    committer: {
+        name: string
+        email: string
+        username: string
+    }
+    added: string[]
+    removed: string[]
+    modified: string[]
+}
+
+export interface BuildData {
+    buildId: string;
+    actorId: string;
+    actorName: string;
+    // folder: string | undefined;
+    buildNumber: string;
+}
+
+export interface ActorConfig {
+    actorName: string;
+    folder: string;
+    isStandalone: boolean
+}

package/bin/utils.ts

@@ -0,0 +1,204 @@
+import fs from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import type {
+    ActorConfig,
+    GitHubEvent,
+} from './types.js';
+
+export const spawnCommandInGhWorkspace = (command: string, args: string[] = []) => {
+    console.error(command, args.join(' '));
+    const ghWorkspace = getEnvVar('GITHUB_WORKSPACE');
+    const commandInGhWorkspace = `cd ${ghWorkspace}; ${command}`;
+    const commandResult = spawnSync(commandInGhWorkspace, args, { shell: true, maxBuffer: 100 * 1024 * 1024 });
+
+    if (commandResult.error) {
+        throw new Error(`[Command failed]: ${commandInGhWorkspace}\n${commandResult.error}`);
+    }
+
+    if (commandResult.stderr.toString().length > 0) {
+        // For some reason 'git' command prints stderr when checking out to detached HEAD state (we only use detached HEAD for testing though)
+        if (!commandResult.stderr.toString().includes(`You are in 'detached HEAD' state`)) {
+            throw new Error(`[Command printed stderr]: ${commandInGhWorkspace}\n${commandResult.stderr.toString()}`);
+        }
+    }
+
+    return commandResult.stdout.toString().trim();
+};
+
+export const getRepoName = (githubEvent: GitHubEvent) => {
+    const [, repoName] = githubEvent.repository.full_name.split('/');
+    return repoName;
+};
+
+export const getEnvVar = (varName: string, defaultValue?: string): string => {
+    const value = process.env[varName] ?? defaultValue;
+    if (!value) {
+        throw new Error(`${varName} not defined`);
+    }
+    return value;
+};
+
+export const getRunUrlKvsKey = (runnerName: string) => {
+    return `RUN_URL-${runnerName}`;
+};
+
+/**
+ * Reads and parses all directories in `actors` directory
+ * This works locally if checkoutRepoLocally is called first
+ */
+export const getRepoActors = async (): Promise<ActorConfig[]> => {
+    const ghWorkspace = getEnvVar('GITHUB_WORKSPACE');
+    let actorDirs: string[];
+    try {
+        actorDirs = (await fs.readdir(`${ghWorkspace}/actors`)).map((dir) => `actors/${dir}`);
+    } catch (err) {
+        console.warn(`No /actors directory found in repo`);
+        actorDirs = [];
+    }
+    let standaloneActorDirs: string[];
+    try {
+        standaloneActorDirs = (await fs.readdir(`${ghWorkspace}/standalone-actors`)).map((dir) => `standalone-actors/${dir}`);
+    } catch (err) {
+        console.warn(`No /standalone-actors directory found in repo`);
+        standaloneActorDirs = [];
+    }
+    const actorConfigs: ActorConfig[] = [];
+    for (const actorDir of [...actorDirs, ...standaloneActorDirs]) {
+        const match = actorDir.match(/^([^/]+)\/(.+)_([^_]+)$/);
+        if (!match) {
+            throw new Error(`Invalid actor directory name. Got "${actorDir}", expected "actor.owner-name_actor-name"`);
+        }
+        const [, folderType, owner, actorName] = match;
+        actorConfigs.push({
+            actorName: `${owner}/${actorName}`,
+            folder: actorDir,
+            isStandalone: folderType === 'standalone-actors',
+        });
+    }
+    console.error(`Actors in repo: ${actorConfigs.filter(({ isStandalone }) => !isStandalone).map(({ actorName }) => actorName).join(', ')}`);
+    console.error(`Standalone actors in repo: ${actorConfigs.filter(({ isStandalone }) => !!isStandalone).map(({ actorName }) => actorName).join(', ')}`);
+    return actorConfigs;
+};
+
+export const getHeadCommitSha = (githubEvent: GitHubEvent) => {
+    return githubEvent.type === 'pull_request'
+        ? githubEvent.pull_request.head.sha
+        : githubEvent.head_commit.id;
+};
+
+export interface GetChangedActorsResult {
+    actorsChanged: ActorConfig[];
+    codeChanged: boolean;
+}
+
+interface ShouldBuildAndTestOptions {
+    filepathsChanged: string[];
+    actorConfigs: ActorConfig[];
+    // Just for logging
+    isLatest?: boolean;
+}
+
+/**
+ * Also works for folders
+ */
+const isIgnoredTopLevelFile = (lowercaseFilePath: string) => {
+    // On top level, we should only have dev-only readme and .actor/ is just for apify push CLI (real Actor configs are in /actors)
+    const IGNORED_TOP_LEVEL_FILES = ['.vscode/', '.gitignore', 'readme.md', '.husky/', '.eslintrc', '.editorconfig', '.actor/'];
+    // Strip out deprecated /code and /shared folders, treat them as top-level code
+    const sanitizedLowercaseFilePath = lowercaseFilePath.replace(/^code\//, '').replace(/^shared\//, '');
+
+    return IGNORED_TOP_LEVEL_FILES.some((ignoredFile) => sanitizedLowercaseFilePath.startsWith(ignoredFile));
+};
+
+const isLatestBuildOnlyFile = (lowercaseFilePath: string) => {
+    if (lowercaseFilePath.endsWith('changelog.md')) {
+        return true;
+    }
+
+    // Either in /actors or /standalone-actors, we need to rebuild readme but we don't rebuild top-level dev-only readme
+    if ((lowercaseFilePath.startsWith('actors/') || lowercaseFilePath.startsWith('standalone-actors/')) && lowercaseFilePath.endsWith('readme.md')) {
+        return true;
+    }
+
+    return false;
+};
+
+/**
+ * Latest and devel are the same except that for latest we also rebuild with README and CHANGELOG files
+ */
+export const getChangedActors = (
+    { filepathsChanged, actorConfigs, isLatest = false }: ShouldBuildAndTestOptions,
+): GetChangedActorsResult => {
+    let codeChanged = false;
+    // folder -> ActorConfig
+    const actorsChangedMap = new Map<string, ActorConfig>();
+
+    const actorConfigsWithoutStandalone = actorConfigs.filter(({ isStandalone }) => !isStandalone);
+
+    const lowercaseFiles = filepathsChanged.map((file) => file.toLowerCase());
+
+    for (const lowercaseFilePath of lowercaseFiles) {
+        if (isIgnoredTopLevelFile(lowercaseFilePath)) {
+            continue;
+        }
+        // First we check for specific actors that have configs in /actors or standalone actors in /standalone-actors
+        // This matches both actors/username_actorName and standalone-actors/username_actorName
+        const changedActorConfigMatch = lowercaseFilePath.match(/^(?:standalone-)?actors\/([^/]+)\/.+/);
+        if (changedActorConfigMatch) {
+            const sanitizedActorName = changedActorConfigMatch[1].replace('_', '/');
+            const actorConfigChanged = actorConfigs.find(({ actorName }) => actorName.toLowerCase() === sanitizedActorName);
+            if (actorConfigChanged === undefined) {
+                console.warn('changes was found in an actor folder which no longer exists in the current commit', {
+                    actorName: sanitizedActorName,
+                    actorFolderName: changedActorConfigMatch[1],
+                });
+                continue;
+            }
+
+            console.error(`actorConfigChanged ${actorConfigChanged.actorName}: sanitizedActorName ${sanitizedActorName} ${lowercaseFilePath} `);
+            // These can be nested at various folders inside the actor folder
+            if (isLatest || !isLatestBuildOnlyFile(lowercaseFilePath)) {
+                // We assume other files will are either actor.json or input_schema.json and those needs to be tested
+                // TODO: Check what changed in schema, we don't need to test description changes
+                actorsChangedMap.set(actorConfigChanged.folder, actorConfigChanged);
+            }
+            continue;
+        }
+
+        // We check top level files (formerly in /code and /shared folders) that are shared among all non-standalone Actors
+        // Standalone actors are always handled separately by name via changedActorConfigMatch
+        if (isLatest || !isLatestBuildOnlyFile(lowercaseFilePath)) {
+            codeChanged = !isLatest; // NOTE: code is changed only in PR
+            for (const actorConfig of actorConfigsWithoutStandalone) {
+                actorsChangedMap.set(actorConfig.folder, actorConfig);
+            }
+        }
+    }
+
+    const actorsChanged = Array.from(actorsChangedMap.values());
+
+    // All below here is just for logging
+    const ignoredFilesChanged = lowercaseFiles.filter((file) => isIgnoredTopLevelFile(file));
+    console.error(`[DIFF]: Top level files changed that we ignore (don't trigger test or build): ${ignoredFilesChanged.join(', ')}`);
+
+    const onlyLatestFilesChanged = lowercaseFiles.filter((file) => isLatestBuildOnlyFile(file));
+    console.error(`[DIFF]: Files changed that only trigger latest build: ${onlyLatestFilesChanged.join(', ')}`);
+
+    if (!isLatest && codeChanged) {
+        console.error(`[DIFF]: All non-standalone Actors need to be built and tested (changes in top-level code)`);
+    }
+
+    if (actorsChanged.length > 0) {
+        const miniactors = actorsChanged.filter((config) => !config.isStandalone).map((config) => config.actorName);
+        const standaloneActors = actorsChanged.filter((config) => config.isStandalone).map((config) => config.actorName);
+        console.error(`[DIFF]: MiniActors to be built and tested: ${miniactors.join(', ')}`);
+        console.error(`[DIFF]: Standalone Actors to be built and tested: ${standaloneActors.join(', ')}`);
+    } else {
+        console.error(`[DIFF]: No relevant files changed, skipping builds and tests`);
+    }
+
+    return {
+        actorsChanged,
+        codeChanged,
+    };
+};

package/dist/bin/build.d.ts

@@ -0,0 +1,18 @@
+import type { ActorConfig, BuildData } from './types.js';
+type BuildPrActorOptions = {
+    buildTag?: string;
+    versionNumber: string;
+    gitRepoUrl: string;
+    actorName: string;
+};
+type RunBuildsOptions = {
+    actorConfigs: ActorConfig[];
+    isLatest?: boolean;
+    repoUrl: string;
+    branch: string;
+    dryRun: boolean;
+};
+export declare const runBuilds: ({ repoUrl, branch, actorConfigs, isLatest, dryRun, }: RunBuildsOptions) => Promise<BuildPrActorOptions[] | BuildData[]>;
+export declare const deleteOldBuilds: (actorConfigs: ActorConfig[]) => Promise<void>;
+export {};
+//# sourceMappingURL=build.d.ts.map

package/dist/bin/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../bin/build.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAGzD,KAAK,mBAAmB,GAAG;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;CACpB,CAAA;AA4KD,KAAK,gBAAgB,GAAG;IACpB,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,eAAO,MAAM,SAAS,yDAMnB,gBAAgB,iDAyClB,CAAC;AAEF,eAAO,MAAM,eAAe,iBAAwB,WAAW,EAAE,kBAIhE,CAAC"}