apify-test-tools 0.10.2-beta.2 → 0.10.2-beta.20

package/bin/test-report.ts

@@ -1,158 +1,159 @@
-import fs from 'node:fs/promises';
+import path from 'node:path';
 
 import { logger } from './logger.js';
-import { getSlackClient, sendingLabel, sendSlackMessage } from './slack.js';
-
-interface ReportTestResultsOptions {
-    reportFile: string;
-    dryRun: boolean;
-    reportSlackChannel?: string;
-    jobUrl?: string;
-    workflowName?: string;
-}
 
-export const reportTestResults = async ({
-    dryRun,
-    reportSlackChannel,
-    reportFile: jsonResultsPath,
-    jobUrl,
-    workflowName,
-}: ReportTestResultsOptions) => {
-    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: { message: string; runLink: string; actorId: string }[] = [];
-
-    logger.info();
-    logger.info(`PASSED: ${passed.length}, FAILED: ${failed.length}`);
-    logger.info();
-    logger.info('**************************************************');
-    logger.info('*                   Successes                    *');
-    logger.info('**************************************************');
-    logger.info();
-    for (const [i, aResult] of passed.entries()) {
-        const { fullName } = aResult;
-        logger.info(`${i + 1}) ${fullName} ... ${aResult.meta.runLink}`);
-        logger.info();
-    }
+export type TestStatus = 'passed' | 'failed' | 'skipped';
 
-    logger.info('**************************************************');
-    logger.info('*                   Failures                     *');
-    logger.info('**************************************************');
-    logger.info();
-    for (const [i, aResult] of failed.entries()) {
-        const { failureMessages, fullName, meta } = aResult;
-        if (failureMessages) {
-            failedAssertions.push(
-                ...failureMessages.map((message) => ({
-                    message: message.split('\n')?.[0],
-                    runLink: meta.runLink,
-                    actorId: meta.actorId,
-                })),
-            );
-        }
-        logger.info(`${i + 1}) ${fullName} ... ${meta.runLink}`);
-        logger.info();
-    }
-    logger.info();
-    logger.info(`PASSED: ${passed.length}, FAILED: ${failed.length}`);
-    logger.info();
-
-    if (!reportSlackChannel) {
-        logger.info(
-            `Skipping slack notification. If you want to enable it, add --report-slack-channel flag and make sure SLACK_TOKEN_TESTS_BOT env variable is set.`,
-        );
-        return;
-    }
-    // Checked before knowing if there's anything to send, so a broken token shows up on a green run
-    // (and in dry runs) rather than on the day tests fail
-    const slack = await getSlackClient('SLACK_TOKEN_TESTS_BOT', dryRun);
-
-    if (failedAssertions.length === 0) {
-        return;
-    }
+/** The Actor run a test started, as the lib records it on the test's `meta`. */
+export interface TestRun {
+    actorId: string;
+    runId: string;
+    runLink: string;
+}
 
-    // TODO: add slack profiles
-    const total = failed.length + passed.length;
-    const jobLink = jobUrl ? ` Check <${jobUrl}|the job>.` : '';
-    let slackMessage = `\`${workflowName ?? '-'}\``;
-    slackMessage += `: has ${failedAssertions.length} failed assertions. Failing test suites: ${failed.length}/${total}.${jobLink}`;
-    slackMessage += `\n\n${failedAssertions[0].message} --- <${failedAssertions[0].runLink}|${failedAssertions[0].actorId}>`;
-    const blocks = failedAssertions
-        .slice(1)
-        .map(({ message, runLink, actorId }) => `• ${message} --- <${runLink}|${actorId}>`);
-
-    logger.info(`${sendingLabel(dryRun)} slack message to channel ${reportSlackChannel}:`, slackMessage);
-    logger.info('\tblocks:', blocks.join('\n\t\t'));
-
-    if (!dryRun) {
-        await sendSlackMessage(slack, reportSlackChannel, slackMessage, blocks);
-    }
-};
+export interface TestCaseReport {
+    /** The full test name, including its `describe` blocks, e.g. `owner/name: finishes` */
+    name: string;
+    /** Relative to the directory the tests ran in */
+    file: string;
+    status: TestStatus;
+    durationMs: number | null;
+    /** The first line of each failure, the rest (diffs, stack traces) is in the vitest output */
+    failureMessages: string[];
+    /** Null for tests that didn't start a run: skipped ones, standby tests, or ones that failed before the run */
+    run: TestRun | null;
+}
 
-type Status = 'passed' | 'failed' | 'skipped' | 'pending' | 'todo' | 'disabled';
-type Milliseconds = number;
-interface Callsite {
-    line: number;
-    column: number;
+/**
+ * What `test` writes to stdout and `notify` reads. A contract between the CLI and whoever reads it, so add fields
+ * freely, but renaming or removing one needs a new `version`.
+ */
+export interface TestReport {
+    /** What the document is, so `notify` and others can tell it from other outputs */
+    kind: 'test-report';
+    version: 1;
+    /** False if any test failed, or the run failed in a way no test accounts for (see `errors`) */
+    success: boolean;
+    summary: { total: number; passed: number; failed: number; skipped: number };
+    tests: TestCaseReport[];
+    /** Failures outside any test, e.g. a test file that failed to import, or vitest crashing without a report */
+    errors: string[];
 }
 
-interface JsonAssertionResult {
-    ancestorTitles: string[];
+// Vitest's JSON reporter output, only the parts we read
+type VitestStatus = 'passed' | 'failed' | 'skipped' | 'pending' | 'todo' | 'disabled';
+
+interface VitestAssertionResult {
     fullName: string;
-    status: Status;
-    title: string;
-    meta: {
-        runId: string;
-        runLink: string;
-        actorId: string;
-    };
-    duration?: Milliseconds | null;
+    status: VitestStatus;
+    duration?: number | null;
     failureMessages: string[] | null;
-    location?: Callsite | null;
+    meta?: Partial<TestRun>;
 }
 
-interface JsonTestResult {
-    message: string;
+interface VitestFileResult {
     name: string;
     status: 'failed' | 'passed';
-    startTime: number;
-    endTime: number;
-    assertionResults: JsonAssertionResult[];
-    // summary: string
-    // coverage: unknown
+    message: string;
+    assertionResults: VitestAssertionResult[];
 }
 
-interface JsonTestResults {
-    numFailedTests: number;
-    numFailedTestSuites: number;
-    numPassedTests: number;
-    numPassedTestSuites: number;
-    numPendingTests: number;
-    numPendingTestSuites: number;
-    numTodoTests: number;
-    numTotalTests: number;
-    numTotalTestSuites: number;
-    startTime: number;
+export interface VitestJsonReport {
     success: boolean;
-    testResults: JsonTestResult[];
-    // snapshot: SnapshotSummary
-    // coverageMap?: CoverageMap | null | undefined
-    // numRuntimeErrorTestSuites: number
-    // wasInterrupted: boolean
+    testResults: VitestFileResult[];
 }
+
+const firstLine = (text: string) => text.split('\n')[0];
+
+const toRun = (meta: Partial<TestRun> | undefined): TestRun | null => {
+    const { actorId, runId, runLink } = meta ?? {};
+    return actorId && runId && runLink ? { actorId, runId, runLink } : null;
+};
+
+/**
+ * Turns vitest's JSON report into a `TestReport`. `exitCode` is vitest's: a non-zero exit with every test passing
+ * still fails the report (e.g. an unhandled error between tests), so the report never reads greener than the run.
+ */
+export const toTestReport = (
+    vitest: VitestJsonReport,
+    { cwd, exitCode }: { cwd: string; exitCode: number },
+): TestReport => {
+    const tests: TestCaseReport[] = [];
+    const errors: string[] = [];
+
+    for (const file of vitest.testResults) {
+        const relativeFile = path.relative(cwd, file.name);
+        // A file that fails to load (an import error, a syntax error) has no tests to blame, only its message
+        if (file.status === 'failed' && file.message) {
+            errors.push(`${relativeFile}: ${firstLine(file.message)}`);
+        }
+        for (const assertion of file.assertionResults) {
+            const status: TestStatus =
+                assertion.status === 'passed' || assertion.status === 'failed' ? assertion.status : 'skipped';
+            tests.push({
+                name: assertion.fullName,
+                file: relativeFile,
+                status,
+                durationMs: assertion.duration != null ? Math.round(assertion.duration) : null,
+                failureMessages: (assertion.failureMessages ?? []).map(firstLine),
+                run: toRun(assertion.meta),
+            });
+        }
+    }
+
+    const count = (status: TestStatus) => tests.filter((test) => test.status === status).length;
+    const summary = {
+        total: tests.length,
+        passed: count('passed'),
+        failed: count('failed'),
+        skipped: count('skipped'),
+    };
+    if (exitCode !== 0 && summary.failed === 0 && errors.length === 0) {
+        errors.push(`Vitest exited with code ${exitCode}, see its output above`);
+    }
+
+    return {
+        kind: 'test-report',
+        version: 1,
+        success: vitest.success && exitCode === 0 && summary.failed === 0 && errors.length === 0,
+        summary,
+        tests,
+        errors,
+    };
+};
+
+/** The report of a run that left no vitest report behind, e.g. because vitest crashed or was killed. */
+export const failedRunReport = (error: string): TestReport => ({
+    kind: 'test-report',
+    version: 1,
+    success: false,
+    summary: { total: 0, passed: 0, failed: 0, skipped: 0 },
+    tests: [],
+    errors: [error],
+});
+
+/** Logs the tests with their run links, which vitest's own output doesn't show. */
+export const logTestReport = ({ summary, tests, errors }: TestReport) => {
+    const runLink = ({ run }: TestCaseReport) => (run ? ` ... ${run.runLink}` : '');
+    const totals = `PASSED: ${summary.passed}, FAILED: ${summary.failed}, SKIPPED: ${summary.skipped}`;
+
+    logger.info();
+    logger.info(totals);
+    for (const status of ['passed', 'failed'] as const) {
+        const matching = tests.filter((test) => test.status === status);
+        if (matching.length === 0) continue;
+        logger.info();
+        logger.info(status === 'passed' ? 'Passed:' : 'Failed:');
+        for (const [i, test] of matching.entries()) {
+            logger.info(`${i + 1}) ${test.name}${runLink(test)}`);
+            for (const message of test.failureMessages) logger.info(`    ${message}`);
+        }
+    }
+    if (errors.length > 0) {
+        logger.info();
+        logger.info('Errors outside of tests:');
+        for (const error of errors) logger.info(`- ${error}`);
+    }
+    logger.info();
+    logger.info(totals);
+};

package/bin/types.ts

@@ -1,13 +1,10 @@
 import type { ActorJsonPaths } from './utils/config/actor-json.js';
 import type { ExistingDir, RelativeDir } from './utils/path/repo-relative.js';
 
-export interface Config {
-    targetBranch: string;
-    sourceBranch: string;
-    baseCommit?: string;
-    actors: string[];
-    ignore: string[];
-    testFilesGlob?: string;
+/** The changes from `fromRef` (excluded) to `toRef`, compared as trees like `git diff fromRef toRef`. */
+export interface GitRange {
+    fromRef: string;
+    toRef: string;
 }
 
 export type Commit = {

package/bin/utils/config/load-config.ts

@@ -3,8 +3,8 @@ import type { ActorConfig } from '../../types.js';
 import { safeReadJsonObjectFile } from '../json-file.js';
 import { ExistingFile, type RelativeDir } from '../path/repo-relative.js';
 import { readActorJson } from './actor-json.js';
-import { parseConfigFile } from './parser.js';
-import type { ValidatedActorConfig } from './structures/base.js';
+import { parseConfigFile, parseRepoSettings, parseResolvedConfigFile, type RepoSettings } from './parser.js';
+import type { ResolvedActorConfig, ValidatedActorConfig } from './structures/base.js';
 
 export const CONFIG_FILE_NAME = 'apify-test-tools.config.json';
 
@@ -111,3 +111,21 @@ export const readConfigFile = async (selection: { actors: string[]; ignore: stri
 
     return selectActors(selection, actorConfigs);
 };
+
+type PathlessConfig = Omit<ResolvedActorConfig, 'folder' | 'overrideActorContext'>;
+/** Read settings shared by all commands without initializing or validating local paths. */
+export const readBaseConfigFile = async () => {
+    const rawFileContents = await readConfigFileContents();
+    return parseResolvedConfigFile(rawFileContents).map(
+        ({ actorFullName, tokenEnvVar }) =>
+            // using `satisfies` here instead of return type annotation
+            // so its not shown as `PathlessConfig` type on output or IDE, but the expanded form
+            ({
+                actorFullName,
+                tokenEnvVar,
+            }) satisfies PathlessConfig,
+    );
+};
+
+/** The settings for the whole repository, such as `platformTestsGlob`, with their defaults filled in. */
+export const readRepoSettings = async (): Promise<RepoSettings> => parseRepoSettings(await readConfigFileContents());

package/bin/utils/config/parser.ts

@@ -47,8 +47,8 @@ const ValidatedConfigSchema = z.array(
     }),
 );
 
-/** Normalize and validate paths, then check collisions using their final spelling. */
-function verifyConfiguration(body: ResolvedActorConfig[]): ValidatedActorConfig[] {
+/** Normalize and initialize paths, including checking that actor folders exist. */
+function initializePaths(body: ResolvedActorConfig[]): ValidatedActorConfig[] {
     const normalized = body.map((entry) => ({
         ...entry,
         folder: normalizeFolder(entry.folder),
@@ -56,14 +56,18 @@ function verifyConfiguration(body: ResolvedActorConfig[]): ValidatedActorConfig[
     }));
     const parsed = ValidatedConfigSchema.safeParse(normalized);
     if (!parsed.success) throw new Error(z.prettifyError(parsed.error));
+    return parsed.data;
+}
 
+/** Check rules that involve more than one Actor, using initialized paths for comparisons. */
+function verifyConfiguration(body: ValidatedActorConfig[]): void {
     const seenFolders = new Set<string>();
     const seenActorFullNames = new Set<string>();
     const errors: string[] = [];
-    for (const [index, entry] of parsed.data.entries()) {
+    for (const entry of body) {
         // TODO: drop folder uniqueness (this requires several changes on other places)
         if (seenFolders.has(entry.folder.path)) {
-            errors.push(`Duplicate folder "${body[index].folder}". Each actor must have a unique folder.`);
+            errors.push(`Duplicate folder "${entry.folder.path}". Each actor must have a unique folder.`);
         } else {
             seenFolders.add(entry.folder.path);
         }
@@ -76,19 +80,47 @@ function verifyConfiguration(body: ResolvedActorConfig[]): ValidatedActorConfig[
     }
 
     if (errors.length > 0) throw new Error(errors.join('\n'));
+}
+
+/** Which changed files are platform tests, unless the config sets `platformTestsGlob` */
+const DEFAULT_PLATFORM_TESTS_GLOB = 'test/platform/**';
+
+/** Settings for the whole repository, next to the Actor entries at the top level of the config. */
+export interface RepoSettings {
+    /**
+     * Glob from the repo root of the platform test files and their helpers. A change to a matching file is a test
+     * change: the tests run, but no release is built for it.
+     */
+    platformTestsGlob: string;
+}
+
+const RepoSettingsSchema = z.object({
+    platformTestsGlob: z.string().min(1).default(DEFAULT_PLATFORM_TESTS_GLOB),
+});
+
+export function parseRepoSettings(body: Record<string, unknown>): RepoSettings {
+    const parsed = RepoSettingsSchema.safeParse(body);
+    if (!parsed.success) throw new Error(z.prettifyError(parsed.error));
     return parsed.data;
 }
 
 // eslint-disable-next-line no-underscore-dangle
 export const _privates = {
     selectStrategy,
+    initializePaths,
     verifyConfiguration,
 };
 
-export function parseConfigFile(body: Record<string, unknown>): ValidatedActorConfig[] {
-    const { mode, ...rest } = body;
+export function parseResolvedConfigFile(body: Record<string, unknown>): ResolvedActorConfig[] {
+    // The repo settings are read by parseRepoSettings, the strategies only see the Actor entries
+    const { mode, platformTestsGlob: _platformTestsGlob, ...rest } = body;
     const strategy = selectStrategy({ mode });
+    return strategy.parse(rest);
+}
 
-    const resolved = strategy.parse(rest);
-    return verifyConfiguration(resolved);
+export function parseConfigFile(body: Record<string, unknown>): ValidatedActorConfig[] {
+    const resolved = parseResolvedConfigFile(body);
+    const initialized = initializePaths(resolved);
+    verifyConfiguration(initialized);
+    return initialized;
 }

package/bin/utils/config/structures/grouped.ts

@@ -13,12 +13,12 @@ const schema = z.object({
                             folder: z.string(),
                             actorFullName: z.string().regex(ACTOR_FULL_NAME_REGEX),
                             // these allow overrides from stuff set at the group level
-                            tokenEnvVar: z.string().optional(),
+                            tokenEnvVar: z.string().min(1).optional(),
                             overrideActorContext: z.array(z.string()).optional(),
                         }),
                     )
                     .min(1),
-                tokenEnvVar: z.string(),
+                tokenEnvVar: z.string().min(1),
                 overrideActorContext: z.array(z.string()).optional(),
             }),
         )

package/bin/utils/config/structures/legacy.ts

@@ -8,7 +8,7 @@ const schema = z.object({
             z.object({
                 folder: z.string(),
                 actorFullName: z.string().regex(ACTOR_FULL_NAME_REGEX),
-                tokenEnvVar: z.string(),
+                tokenEnvVar: z.string().min(1),
                 overrideActorContext: z.array(z.string()).optional(),
             }),
         )

package/dist/bin/actor-ids.d.ts

@@ -0,0 +1,15 @@
+import { ApifyClient } from 'apify-client';
+import type { TestTarget } from './stdin-input.js';
+type ActorGetter = Pick<ApifyClient, 'actor'>;
+/**
+ * Adds the ID each target is missing: the raw ID to those listed by full name, e.g. by `get-actor-configs`, and the
+ * full name to those listed by raw ID. The lib matches a test to its Actor by the ID the test names, so a target
+ * without either ID would skip the tests that name its Actor by the other one.
+ *
+ * An Actor the token can't see keeps only the ID it was listed with, with a warning, rather than failing the run:
+ * `get-actor-configs` lists every Actor in the repository, also ones no platform test uses, such as Actors the tester
+ * account was never given access to. A test that names it by the listed ID still runs and fails on its own.
+ */
+export declare const withActorIds: (targets: TestTarget[], client?: ActorGetter) => Promise<TestTarget[]>;
+export {};
+//# sourceMappingURL=actor-ids.d.ts.map

package/dist/bin/actor-ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actor-ids.d.ts","sourceRoot":"","sources":["../../bin/actor-ids.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAG3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,KAAK,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GACrB,SAAS,UAAU,EAAE,EACrB,SAAQ,WAAwE,KACjF,OAAO,CAAC,UAAU,EAAE,CAqBlB,CAAC"}

package/dist/bin/actor-ids.js

@@ -0,0 +1,30 @@
+import { ApifyClient } from 'apify-client';
+import { logger } from './logger.js';
+/**
+ * Adds the ID each target is missing: the raw ID to those listed by full name, e.g. by `get-actor-configs`, and the
+ * full name to those listed by raw ID. The lib matches a test to its Actor by the ID the test names, so a target
+ * without either ID would skip the tests that name its Actor by the other one.
+ *
+ * An Actor the token can't see keeps only the ID it was listed with, with a warning, rather than failing the run:
+ * `get-actor-configs` lists every Actor in the repository, also ones no platform test uses, such as Actors the tester
+ * account was never given access to. A test that names it by the listed ID still runs and fails on its own.
+ */
+export const withActorIds = async (targets, client = new ApifyClient({ token: process.env.TESTER_APIFY_TOKEN })) => Promise.all(targets.map(async (target) => {
+    const { actorFullName, actorRawId } = target;
+    if (actorFullName && actorRawId)
+        return target;
+    // The parser lets no target through without either ID
+    const actorId = (actorFullName ?? actorRawId);
+    const actor = await client.actor(actorId).get();
+    if (!actor) {
+        logger.warn(`Actor ${actorId} not found, or TESTER_APIFY_TOKEN can't access it. Tests that name it by ` +
+            `${actorFullName ? 'its raw ID' : 'its full name'} will be skipped.`);
+        return target;
+    }
+    return {
+        ...target,
+        actorFullName: actorFullName ?? `${actor.username}/${actor.name}`,
+        actorRawId: actorRawId ?? actor.id,
+    };
+}));
+//# sourceMappingURL=actor-ids.js.map

package/dist/bin/actor-ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actor-ids.js","sourceRoot":"","sources":["../../bin/actor-ids.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAKrC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,EAC7B,OAAqB,EACrB,SAAsB,IAAI,WAAW,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC,EAC3D,EAAE,CACvB,OAAO,CAAC,GAAG,CACP,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;IACzB,MAAM,EAAE,aAAa,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;IAC7C,IAAI,aAAa,IAAI,UAAU;QAAE,OAAO,MAAM,CAAC;IAC/C,sDAAsD;IACtD,MAAM,OAAO,GAAG,CAAC,aAAa,IAAI,UAAU,CAAE,CAAC;IAC/C,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC;IAChD,IAAI,CAAC,KAAK,EAAE,CAAC;QACT,MAAM,CAAC,IAAI,CACP,SAAS,OAAO,2EAA2E;YACvF,GAAG,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,eAAe,mBAAmB,CAC3E,CAAC;QACF,OAAO,MAAM,CAAC;IAClB,CAAC;IACD,OAAO;QACH,GAAG,MAAM;QACT,aAAa,EAAE,aAAa,IAAI,GAAG,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,IAAI,EAAE;QACjE,UAAU,EAAE,UAAU,IAAI,KAAK,CAAC,EAAE;KACrC,CAAC;AACN,CAAC,CAAC,CACL,CAAC"}

package/dist/bin/affected-actors.d.ts

@@ -0,0 +1,55 @@
+import type { Commit } from './types.js';
+interface AffectedActorsOptions {
+    /**
+     * Base usually points to the master branch
+     * Only what HEAD changes compared to base counts, like `git diff base...HEAD` or GitHub's "Files changed" tab:
+     * the branch's own changes, not what it merged in from base.
+     */
+    base?: string;
+    /**
+     * With `base` it's the last validated commit of the branch: Actors that didn't change after it are left out.
+     * It's ignored when it is HEAD (a rerun) or isn't in the local history. Without `base` everything after it
+     * counts, and it must be an ancestor of HEAD (e.g. the last release).
+     */
+    since?: string;
+    actors: string[];
+    ignore: string[];
+}
+/** The JSON document `get-affected-actors` prints. Versioned, since other commands and workflows consume it. */
+interface AffectedActors {
+    version: 1;
+    head: string;
+    /** The commits, changed files and changelog describe the whole range, `--since` with `--base` only narrows the Actors. */
+    commits: Commit[];
+    changedFiles: string[];
+    changelog: string | null;
+    /**
+     * Actors with at least one functional change. They need a new build and tests. Only the names: the config file
+     * stays the source of truth for the rest.
+     */
+    functionallyChangedActors: {
+        actorFullName: string;
+    }[];
+    /**
+     * Actors with cosmetic changes (README, CHANGELOG, cosmetic .actor JSON) and no functional one. They only need a
+     * release build.
+     */
+    cosmeticallyChangedActors: {
+        actorFullName: string;
+    }[];
+    /**
+     * Actors whose platform tests (`platformTestsGlob` in the config) changed in their context, whatever else
+     * changed. Their tests need to run, but a test change alone needs no release. An Actor can also be in one of the
+     * lists above.
+     */
+    testChangedActors: {
+        actorFullName: string;
+    }[];
+}
+/**
+ * Finds the Actors whose context changed in the given range. `base` selects the branch's own changes
+ * (a PR), `since` the changes after a known commit (a release, or the last validated commit of a PR).
+ */
+export declare const getAffectedActors: ({ base, since: sinceOption, actors, ignore, }: AffectedActorsOptions) => Promise<AffectedActors>;
+export {};
+//# sourceMappingURL=affected-actors.d.ts.map

package/dist/bin/affected-actors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affected-actors.d.ts","sourceRoot":"","sources":["../../bin/affected-actors.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAe,MAAM,EAAY,MAAM,YAAY,CAAC;AAMhE,UAAU,qBAAqB;IAC3B;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,gHAAgH;AAChH,UAAU,cAAc;IACpB,OAAO,EAAE,CAAC,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,0HAA0H;IAC1H,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;OAGG;IACH,yBAAyB,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACvD;;;OAGG;IACH,yBAAyB,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACvD;;;;OAIG;IACH,iBAAiB,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAClD;AA8FD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAU,+CAKrC,qBAAqB,KAAG,OAAO,CAAC,cAAc,CAiDhD,CAAC"}