squally-reporter 0.6.0 → 0.8.0

package/README.md

@@ -1,189 +1,278 @@
-# squally-reporter
-
-Playwright reporter that sends test results to your Squally dashboard.
-
-Learn more at [squally-app.vercel.app](https://squally-app.vercel.app).
-
-## Requirements
-
-- Node.js >= 22.19.0 (required by the `undici` dependency)
-- `@playwright/test` >= 1.30.0
-
-## Install
-
-```bash
-npm install -D squally-reporter
-```
-
-## Config
-
-Set two env vars (e.g. in CI secrets or `.env`):
-
-```bash
-SQUALLY_API_URL=https://squally-app.vercel.app
-SQUALLY_API_KEY=your-project-api-key
-```
-
-Find your API key on your project's Settings page in the Squally dashboard.
-
-Then add the reporter to `playwright.config.ts`:
-
-```ts
-import { defineConfig } from "@playwright/test";
-
-export default defineConfig({
-  reporter: [
-    ["list"],
-    ["squally-reporter"],
-  ],
-});
-```
-
-Alternatively, pass config explicitly instead of using env vars - **only if
-`apiKey` itself comes from an env var or secret store at runtime, never as a
-literal string in a committed file:**
-
-```ts
-reporter: [
-  ["squally-reporter", { apiUrl: "https://squally-app.vercel.app", apiKey: process.env.SQUALLY_API_KEY }],
-],
-```
-
-That's it - run your tests as usual (`npx playwright test`) and results will
-be sent to Squally after the run finishes.
-
-## Screenshot/trace upload
-
-If your `playwright.config.ts` captures screenshots or traces, the reporter
-uploads them to Squally so they show up next to the failing test in the
-dashboard - no separate setup beyond the two env vars above.
-
-**Only from attempts worth looking at:** screenshots/traces are uploaded
-only for attempts that **failed**, or that **needed a retry** (even if that
-retry then passed) - never for an attempt that passed on its first try,
-regardless of how `screenshot`/`trace` are configured. Nobody looks at a
-screenshot of a test that just passed, and uploading one anyway would only
-eat into your organization's storage for no benefit.
-
-**You need to actually enable capture in `playwright.config.ts`** - without
-it, Playwright doesn't produce any attachments, so there's nothing for the
-reporter to find or upload (no error either way, it's a silent no-op):
-
-```ts
-export default defineConfig({
-  use: {
-    screenshot: "only-on-failure",
-    trace: "retain-on-failure",
-  },
-  // ...
-});
-```
-
-**Limits:**
-- 50 MB per individual file. Larger files are skipped (logged as a
-  `console.warn`, the test result itself is still reported as usual).
-- A total storage cap per organization, depending on your Squally plan.
-  Once reached, further uploads are skipped the same way until you either
-  free up space or upgrade.
-- Two minutes per upload, and 30 seconds for the calls that surround it. An
-  unreachable or very slow server means a skipped upload and a `console.warn`,
-  not a CI job waiting indefinitely.
-
-Upload is best-effort and fully non-blocking, same principle as the rest of
-this reporter - a failed or skipped upload never fails your test run or
-changes its exit code, it only logs a `console.warn` explaining what
-happened.
-
-## How results reach Squally
-
-Results stream to Squally as your suite runs, not all at once at the end:
-each test's result is sent in a small batch (at most every 25 results or 2
-seconds, whichever comes first), so the "running" view in the dashboard stays
-close to real time even for a long suite. There is no longer a single-request
-size limit that could discard a whole run - a very large suite simply takes
-more, smaller requests. As a courtesy the reporter still warns if a run's
-result count climbs well past 5,000, since that usually means retries are
-configured higher than intended rather than a suite that's actually that
-large.
-
-If Squally is unreachable partway through, results already sent stay in the
-dashboard; only what could not be delivered is lost, and your test run's exit
-code is never affected either way.
-
-**Only actual test runs appear.** A run shows up in Squally once your first
-test starts, so commands that never run a test create nothing: `--list`,
-a `globalSetup` or `webServer` that fails to start, a `--grep` that matches
-nothing. A run that *does* execute and legitimately contains no tests — an
-empty shard, `--only-changed` with no changed test file, `--pass-with-no-tests`
-— is still reported, as a run with zero results.
-
-## Sharding
-
-**Handled automatically - no extra setup needed.** Each shard is still a
-separate process with its own reporter instance, but Squally now correlates
-them itself: all shards of one CI run are grouped together and shown as one
-run once every shard has finished, with the flip side of that guarantee being
-that the run only completes once every shard *has* reported.
-
-Correlation is based on an id read from your CI provider's own environment,
-so it costs you nothing on GitHub Actions, GitLab CI or CircleCI. If your
-provider is not one of those (or you shard locally across several separate
-`--shard` invocations), set `SQUALLY_CI_RUN_ID` to the same value for every
-shard of one run - anything unique per CI run and shared by its shards works,
-e.g. a build number your CI system already exposes.
-
-**`playwright merge-reports` is not part of this and is not recommended** for
-getting a single run in Squally - the automatic correlation above is the
-supported path, and produces correct per-shard timing/branch/commit
-information that a merge job cannot (see the historical note below). Nothing
-stops you from using `merge-reports` for Playwright's own HTML report if you
-want that separately; just don't point this reporter at the merged result
-expecting Squally to treat it specially.
-
-<details>
-<summary>Why not just use `merge-reports`, historically</summary>
-
-An earlier version of this reporter recommended `playwright merge-reports` as
-the way to get one Squally run out of a sharded job. That path has a real
-problem: branch, commit, commit message and author are all read on whichever
-machine the reporter actually runs on - during a merge that is the merge job,
-not the shards - and without a checkout there (and without the CI provider's
-own commit variables) they all come out empty. A run with no branch is never
-counted as a run on your stable branch, which is what Squally's broken/healthy
-verdicts are based on - so a "merged" run could exist in the dashboard while
-silently contributing nothing to flakiness detection. The automatic
-correlation above reads that information from each shard's own environment
-instead, so this problem does not arise.
-
-</details>
-
-## Tested revision (optional)
-
-If your test-automation code lives in the same repo as the application it
-tests, Squally can already tell which commit was tested from the CI
-provider's own commit env vars. If they're **separate repos** (e.g. a
-dedicated E2E-test repo pointed at a deployed app), set one of the following
-so Squally knows which application state was actually tested:
-
-```bash
-# Same repo as the application under test - Squally will trust this CI
-# job's own commit (GITHUB_SHA / CI_COMMIT_SHA) as the tested revision.
-SAME_REPO_AS_APP=true
-
-# Separate repos - pass the tested revision explicitly (a commit SHA, tag,
-# or branch name/ref).
-TESTED_REVISION=v1.2.0
-```
-
-Neither variable is required - without them, test results are still sent
-and stored exactly as before.
-
-## Support
-
-Found a bug or have a question? Please open an issue on
-[GitHub Issues](https://github.com/squallydev-admin/squally-reporter/issues) -
-that's the primary way to report problems or ask questions.
-
-## License
-
-MIT - see [LICENSE](./LICENSE).
+# squally-reporter
+
+Playwright reporter that sends test results to your Squally dashboard.
+
+Learn more at [app.squally.dev](https://app.squally.dev).
+
+## Requirements
+
+- Node.js >= 22.19.0 (required by the `undici` dependency)
+- `@playwright/test` >= 1.30.0
+
+## Install
+
+```bash
+npm install -D squally-reporter
+```
+
+## Config
+
+Set two env vars (e.g. in CI secrets or `.env`):
+
+```bash
+SQUALLY_API_URL=https://app.squally.dev
+SQUALLY_API_KEY=your-project-api-key
+```
+
+Find your API key on your project's Settings page in the Squally dashboard.
+
+Then add the reporter to `playwright.config.ts`:
+
+```ts
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  reporter: [
+    ["list"],
+    ["squally-reporter"],
+  ],
+});
+```
+
+Alternatively, pass config explicitly instead of using env vars - **only if
+`apiKey` itself comes from an env var or secret store at runtime, never as a
+literal string in a committed file:**
+
+```ts
+reporter: [
+  ["squally-reporter", { apiUrl: "https://app.squally.dev", apiKey: process.env.SQUALLY_API_KEY }],
+],
+```
+
+That's it - run your tests as usual (`npx playwright test`) and results will
+be sent to Squally after the run finishes.
+
+## Artifact upload (screenshot, trace, browser console)
+
+If your `playwright.config.ts` captures screenshots or traces, the reporter
+uploads them to Squally so they show up next to the failing test in the
+dashboard - no separate setup beyond the two env vars above.
+
+Three kinds are uploaded:
+
+| Kind | Where it comes from |
+| --- | --- |
+| **Screenshot** | the file Playwright writes for a failed attempt |
+| **Trace** | the trace zip Playwright writes |
+| **Browser console** | read out of that trace zip by this reporter |
+
+**The browser console needs a trace.** It is not something Playwright hands a
+reporter: `result.stdout`/`stderr` are the output of the *Node* process - what
+your test file printed - while what the *page* printed only exists inside the
+trace. So the reporter opens the trace and reads it out, which means an
+attempt with no trace has no browser console, and nothing can change that but
+turning tracing on. Squally's attempt page says which of the two it is rather
+than showing an empty section.
+
+Supported trace schema versions: **5 to 10**, which covers Playwright 1.30
+through 1.62 (1.62 writes version 8). A trace outside that range is left alone
+and the reporter prints one warning naming the version - it never uploads an
+empty console file, because "no messages" and "this reporter could not read
+it" must not look the same in the dashboard.
+
+**Only from attempts worth looking at:** artifacts are uploaded only for
+attempts that **failed**, or that **needed a retry** (even if that retry then
+passed) - never for an attempt that passed on its first try, regardless of how
+`screenshot`/`trace` are configured. Nobody looks at a screenshot of a test
+that just passed, and uploading one anyway would only eat into your
+organization's storage for no benefit.
+
+**You need to actually enable capture in `playwright.config.ts`** - without
+it, Playwright doesn't produce any attachments, so there's nothing for the
+reporter to find or upload (no error either way, it's a silent no-op):
+
+```ts
+export default defineConfig({
+  use: {
+    screenshot: "only-on-failure",
+    trace: "retain-on-failure",
+  },
+  // ...
+});
+```
+
+**Limits.** None of these are enforced by the reporter - Squally applies them
+when the upload is requested and answers with a reason, which is what the
+reporter prints. The numbers below are therefore Squally's current ones rather
+than anything this package guarantees, and can change server-side without a new
+release of it:
+
+- **50 MB per individual file**, the same on every plan. A larger screenshot or
+  trace is rejected before any bytes are uploaded; the reporter logs a
+  `console.warn` naming the file and moves on. The test result itself is
+  reported as usual, and the run's outcome and exit code are untouched. In the
+  dashboard that artifact is shown as skipped, with the reason, rather than
+  silently missing.
+- **A total storage cap per organization, depending on your Squally plan.**
+  Once it is reached, further uploads are rejected the same way until you free
+  up space or upgrade. Note that a fully instrumented suite now produces up to
+  three artifacts per failed attempt rather than two.
+- The browser console is a text file of a few KB - it is extracted from the
+  trace you are already uploading, so it adds no capture cost to your run.
+- **Your test's own `stdout`/`stderr` is cut at 16 KB** before it is sent. That
+  is this reporter's own limit, not Squally's, and it applies whether or not
+  you capture artifacts at all.
+- Two minutes per upload, and 30 seconds for the calls that surround it. An
+  unreachable or very slow server means a skipped upload and a `console.warn`,
+  not a CI job waiting indefinitely.
+
+Upload is best-effort and fully non-blocking, same principle as the rest of
+this reporter - a failed or skipped upload never fails your test run or
+changes its exit code, it only logs a `console.warn` explaining what
+happened.
+
+## How results reach Squally
+
+Results stream to Squally as your suite runs, not all at once at the end:
+each test's result is sent in a small batch, so the "running" view in the
+dashboard stays close to real time even for a long suite. A batch goes out on
+whichever of these comes first:
+
+- **25 results.** Fixed, and the same whether you shard or not.
+- **A timer, 2 seconds × the number of shards, capped at 30 seconds.** An
+  unsharded run flushes every 2 seconds; four shards every 8; eight shards
+  every 16; fifteen shards and above every 30, where the cap holds it.
+
+Only the timer scales. All shards of a run share one rate budget on Squally's
+side, so without this a sixteen-shard suite would send sixteen times the
+requests of an unsharded one and throttle itself. The 25-result threshold is
+left alone deliberately: it bounds how long a *fast* suite waits, and
+stretching it would delay results without bounding the burst any better.
+
+There is no longer a single-request size limit that could discard a whole run -
+a very large suite simply takes more, smaller requests. As a courtesy the
+reporter still warns if a run's result count climbs well past 5,000, since that
+usually means retries are configured higher than intended rather than a suite
+that's actually that large.
+
+If Squally is unreachable partway through, results already sent stay in the
+dashboard; only what could not be delivered is lost, and your test run's exit
+code is never affected either way.
+
+**Only actual test runs appear.** A run shows up in Squally once your first
+test starts, so commands that never run a test create nothing: `--list`,
+a `globalSetup` or `webServer` that fails to start, a `--grep` that matches
+nothing. A run that *does* execute and legitimately contains no tests — an
+empty shard, `--only-changed` with no changed test file, `--pass-with-no-tests`
+— is still reported, as a run with zero results.
+
+## Tests marked with `test.fail()`
+
+Playwright's `test.fail()` marks a test as *expected to fail*: it guards a bug
+you already know about, and Playwright runs the test anyway to check that it
+does still fail. The interesting moment is the opposite one - when someone
+fixes the bug, the test starts passing and Playwright turns it red so you
+remember to delete the marker.
+
+The reporter passes that marker on, so Squally reads such a test the same way
+Playwright does:
+
+- **Marked and still failing** - shown as passing, with an "expected failure"
+  label. It does not count toward your failure numbers, your flakiness
+  verdicts, or Squally's pull-request check.
+- **Marked and now passing** - shown as a failure, because the marker is out of
+  date and should be removed.
+
+Both ways of marking a test are recognised: the `test.fail()` modifier and a
+`testInfo.fail()` call inside the test body. `test.skip()` and `test.fixme()`
+are a different statement and are not affected.
+
+Nothing is reported for an unmarked test, so an ordinary suite is unchanged.
+Note also that Playwright itself treats a marked, failing test as expected, so
+with `screenshot: "only-on-failure"` it captures nothing for it - there is no
+artifact for the reporter to upload, which is consistent rather than missing.
+
+## Sharding
+
+**Handled automatically - no extra setup needed.** Each shard is still a
+separate process with its own reporter instance, but Squally now correlates
+them itself: all shards of one CI run are grouped together and shown as one
+run once every shard has finished, with the flip side of that guarantee being
+that the run only completes once every shard *has* reported.
+
+Correlation is based on an id read from your CI provider's own environment,
+so it costs you nothing on GitHub Actions, GitLab CI or CircleCI. If your
+provider is not one of those (or you shard locally across several separate
+`--shard` invocations), set `SQUALLY_CI_RUN_ID` to the same value for every
+shard of one run - anything unique per CI run and shared by its shards works,
+e.g. a build number your CI system already exposes.
+
+**`playwright merge-reports` is not part of this and is not recommended** for
+getting a single run in Squally - the automatic correlation above is the
+supported path, and produces correct per-shard timing/branch/commit
+information that a merge job cannot (see the historical note below). Nothing
+stops you from using `merge-reports` for Playwright's own HTML report if you
+want that separately; just don't point this reporter at the merged result
+expecting Squally to treat it specially.
+
+<details>
+<summary>Why not just use `merge-reports`, historically</summary>
+
+An earlier version of this reporter recommended `playwright merge-reports` as
+the way to get one Squally run out of a sharded job. That path has a real
+problem: branch, commit, commit message and author are all read on whichever
+machine the reporter actually runs on - during a merge that is the merge job,
+not the shards - and without a checkout there (and without the CI provider's
+own commit variables) they all come out empty. A run with no branch is never
+counted as a run on your stable branch, which is what Squally's broken/healthy
+verdicts are based on - so a "merged" run could exist in the dashboard while
+silently contributing nothing to flakiness detection. The automatic
+correlation above reads that information from each shard's own environment
+instead, so this problem does not arise.
+
+</details>
+
+## Tested revision (optional)
+
+If your test-automation code lives in the same repo as the application it
+tests, Squally can already tell which commit was tested from the CI
+provider's own commit env vars. If they're **separate repos** (e.g. a
+dedicated E2E-test repo pointed at a deployed app), set one of the following
+so Squally knows which application state was actually tested:
+
+```bash
+# Same repo as the application under test - Squally will trust this CI
+# job's own commit (GITHUB_SHA / CI_COMMIT_SHA) as the tested revision.
+SAME_REPO_AS_APP=true
+
+# Separate repos - pass the tested revision explicitly (a commit SHA, tag,
+# or branch name/ref).
+TESTED_REVISION=v1.2.0
+```
+
+Neither variable is required - without them, test results are still sent
+and stored exactly as before.
+
+**The value is normalised before it is stored**, so that the same revision
+written two ways still compares equal: it is lowercased, and a leading `v` or a
+`refs/heads/` prefix is removed. The example above is exactly such a case -
+`v1.2.0` is stored as `1.2.0`. The reporter says so once per run when it
+happens, so a value that looks different in the dashboard is not a mystery.
+
+## Troubleshooting
+
+Set `SQUALLY_DEBUG=1` to print detail that is otherwise kept quiet - currently
+the browser-console extraction: how many messages were found, or that an
+attempt's trace held none. Everything that is *not* ordinary (a trace that
+cannot be read, an unsupported schema version, a rejected upload) is printed
+without it.
+
+## Support
+
+Found a bug or have a question? Please open an issue on
+[GitHub Issues](https://github.com/squallydev-admin/squally-reporter/issues) -
+that's the primary way to report problems or ask questions.
+
+## License
+
+MIT - see [LICENSE](./LICENSE).

package/dist/index.d.ts

@@ -19,6 +19,12 @@ interface AppendResultEntry {
     status: "passed" | "failed" | "skipped";
     retryCount: number;
     repeatIndex: number;
+    /**
+     * Playwright's `test.fail()` marker (spec section 1.3.1). OPTIONAL on the
+     * wire and omitted when false, so the field costs nothing on the overwhelming
+     * majority of results.
+     */
+    expectedFailure?: boolean;
     durationMs: number | null;
     errors?: AppendErrorEntry[];
     consoleOutput: string | null;
@@ -26,7 +32,7 @@ interface AppendResultEntry {
     browserName: string | null;
     errorContext: string | null;
 }
-type ArtifactType = "screenshot" | "trace";
+type ArtifactType = "screenshot" | "trace" | "console";
 declare function truncate(value: string, max: number): string;
 declare function truncateOrNull(value: string | null, max: number): string | null;
 /**
@@ -58,10 +64,35 @@ declare function resolveTestedRevision(): ResolvedRevision | null;
 declare function toPosixPath(p: string): string;
 declare function stripAnsi(value: string): string;
 declare function maskSecrets(value: string): string;
-declare function prepareConsoleOutput(value: string | null): string | null;
+/**
+ * The console output to send, and the size it had before the cut.
+ *
+ * RETURNS A PAIR SINCE 17.09., the same shape squally-app's own
+ * prepareConsoleOutput returns (lib/ingest-v2-core.ts). The reason is a gap
+ * nobody could see from either side alone: the app records
+ * consoleOutputOriginalBytes so a truncated capture says so on the page, and
+ * it derives that number from the text it RECEIVES - which this reporter has
+ * already cut to 16 KiB. The app therefore records NULL for every
+ * reporter-sent row and the page says nothing was cut, while something was.
+ *
+ * `truncatedFromBytes` is the masked size before the cut, null when nothing
+ * was cut - the optional-field shape the wire uses for expectedFailure.
+ *
+ * NOT SENT YET, and deliberately not: squally-app's v2 result schema has no
+ * field for it (checked in lib/ingest-v2-contract.ts, resultSchema), and that
+ * schema does not use .strict(), so zod would silently STRIP an unknown key.
+ * Sending it today would look done and change nothing. The receiving side goes
+ * first in this project - that is how the console artifact itself shipped -
+ * so the value is computed and available here, and the wire field is a
+ * squally-app change this release reports rather than pre-empts.
+ */
+declare function prepareConsoleOutput(value: string | null): {
+    text: string | null;
+    truncatedFromBytes: number | null;
+};
 declare function mapErrors(errors: readonly TestError[]): AppendErrorEntry[] | undefined;
 declare function attemptQualifiesForArtifacts(mappedStatus: AppendResultEntry["status"], retryCount: number): boolean;
-declare function artifactKey(testName: string, filePath: string, retryCount: number, type: ArtifactType): string;
+declare function artifactKey(testName: string, filePath: string, retryCount: number, repeatIndex: number, type: ArtifactType): string;
 declare function parseRetryAfterMs(headerValue: string | null, nowMs: number): number | null;
 declare function computeBackoffMs(retryNumber: number): number;
 export default class SquallyReporter implements Reporter {
@@ -78,6 +109,11 @@ export default class SquallyReporter implements Reporter {
     private runConfig;
     private buffer;
     private artifacts;
+    /** Trace schema versions already warned about - ONCE per run, not per
+     *  attempt. A suite failing 200 tests under a Playwright this reporter does
+     *  not know would otherwise print 200 identical paragraphs and teach the
+     *  reader to scroll past the one thing worth reading. */
+    private warnedTraceVersions;
     /**
      * Every result this shard produced, counted where it is produced (0.6.0).
      *
@@ -160,3 +196,4 @@ export declare const __internal: {
     artifactKey: typeof artifactKey;
 };
 export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}