@element-hq/element-web-playwright-common 2.3.0 → 3.0.0

package/lib/testcontainers/synapse.js

@@ -136,6 +136,7 @@ const DEFAULT_CONFIG = {
     },
     room_list_publication_rules: [{ action: "allow" }],
     modules: [],
+    matrix_authentication_service: undefined,
 };
 /**
  * A Synapse testcontainer
@@ -217,7 +218,22 @@ export class SynapseContainer extends GenericContainer {
         return this;
     }
     withMatrixAuthenticationService(mas) {
-        this.mas = mas;
+        if (mas) {
+            this.mas = mas;
+            this.withConfig({
+                matrix_authentication_service: {
+                    enabled: true,
+                    endpoint: `http://${mas.getHostname()}:8080/`,
+                    secret: mas.sharedSecret,
+                },
+                // Must be disabled when using MAS.
+                password_config: {
+                    enabled: false,
+                },
+                // Must be disabled when using MAS.
+                enable_registration: false,
+            });
+        }
         return this;
     }
     async start() {

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@element-hq/element-web-playwright-common",
     "type": "module",
-    "version": "2.3.0",
+    "version": "3.0.0",
     "license": "SEE LICENSE IN README.md",
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/element-hq/element-modules.git",
-        "directory": "packages/element-web-playwright-common"
+        "url": "git+https://github.com/element-hq/element-web.git",
+        "directory": "packages/playwright-common"
     },
     "author": "element-hq",
     "engines": {
@@ -18,15 +18,14 @@
         "playwright-screenshots": "playwright-screenshots.sh"
     },
     "scripts": {
-        "prepare": "tsc",
-        "lint:types": "tsc --noEmit",
-        "lint:codestyle": "echo 'handled by lint:eslint'",
-        "test": "echo No tests for @element-hq/element-web-playwright-common"
+        "prepack": "nx build:playwright",
+        "lint:types": "tsc --noEmit"
     },
     "devDependencies": {
         "@element-hq/element-web-module-api": "*",
         "@types/lodash-es": "^4.17.12",
-        "typescript": "^5.8.2"
+        "typescript": "^5.8.2",
+        "wait-on": "^9.0.4"
     },
     "dependencies": {
         "@axe-core/playwright": "^4.10.1",
@@ -40,7 +39,7 @@
     },
     "peerDependencies": {
         "@element-hq/element-web-module-api": "*",
-        "@playwright/test": "^1.52.0",
-        "playwright-core": "^1.52.0"
+        "@playwright/test": "catalog:",
+        "playwright-core": "catalog:"
     }
 }

package/playwright-screenshots.sh

@@ -6,137 +6,44 @@ set -e
 SCRIPT_PATH=$(readlink -f "$0")
 SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
 
-IMAGE_NAME="element-web-playwright-common"
+function build_image() {
+    local IMAGE_NAME="$1"
 
-if docker --version | grep -q podman; then docker_is_podman=1; fi
-
-build_image() {
-  echo "Building $IMAGE_NAME image in $SCRIPT_DIR"
-
-  # Check the playwright version
-  PM=$(cat package.json | jq -r '.packageManager')
-  if [[ $PM == "pnpm@"* ]]; then
-    PW_VERSION=$(pnpm list @playwright/test --depth=0 --json | jq -r '.[].devDependencies["@playwright/test"].version')
-  else
-    PW_VERSION=$(yarn list --pattern @playwright/test --depth=0 --json --non-interactive --no-progress | jq -r '.data.trees[].name | split("@") | last')
-  fi
-  echo "with Playwright version $PW_VERSION"
-
-  # Build image
-  docker build -t "$IMAGE_NAME" --build-arg "PLAYWRIGHT_VERSION=$PW_VERSION" "$SCRIPT_DIR"
+    echo "Building $IMAGE_NAME image in $SCRIPT_DIR"
+    docker build -t "$IMAGE_NAME" --build-arg "PLAYWRIGHT_VERSION=${IMAGE_NAME#*:}" "$SCRIPT_DIR"
 }
 
-# Find the docker socket on the host
-case "$DOCKER_HOST" in
-    unix://*)
-        docker_sock="${DOCKER_HOST:7}"
-        ;;
-    "")
-        docker_sock="/var/run/docker.sock"
-        ;;
-    *)
-        echo "$0: unsupported DOCKER_HOST setting '${DOCKER_HOST}'" >&2
-        exit 1;
-        ;;
-esac
-
-RUN_ARGS=(
-  --rm
-  --network host
-  # Pass BASE_URL and CI environment variables to the container
-  -e BASE_URL
-  -e CI
-  # Bind mount the working directory into the container
-  -v $(pwd):/work/
-  # Bind mount the docker socket so we can run docker commands from the container
-  -v "${docker_sock}":/var/run/docker.sock
-  # Bind mount /tmp so we can store temporary files
-  -v /tmp/:/tmp/
-  -it
-)
-
-DEFAULT_ARGS=(--grep @screenshot)
-LINK_MODULES=true
-
-# Some arguments to customise behaviour so the same script / image can be
-# re-used for other screenshot generation.
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    # Mounts a separate node_modules directory from a docker volume in the container.
-    # Must be used if executing something that requires native node modules
-    # It's a volume rather than a directory because otherwise things tend to start picking up
-    # files from it in the native environment and break.
-    --with-node-modules)
-      mount_param="type=volume,src=ew-docker-node-modules,dst=/work/node_modules"
-      # podman doesn't support `volume-nocopy`
-      if [ -z "$docker_is_podman" ]; then mount_param+=",volume-nocopy"; fi
-      RUN_ARGS+=(--mount "${mount_param}" -e YARN_INSTALL=true)
-      shift
-      ;;
-    # Disables the automatic detection & linking of node_modules which can clash with developer tooling e.g. pnpm-link
-    --no-link-modules)
-      LINK_MODULES=false
-      shift
-      ;;
-    # Sets a different entrypoint (in which case the default arguments to the script will be ignored)
-    --entrypoint)
-      shift
-      RUN_ARGS+=(--entrypoint "$1")
-      DEFAULT_ARGS=()
-      shift
-      ;;
-    *)
-      break
-      ;;
-  esac
-done
-
-build_image
+WS_PORT=3000
 
-if [[ $LINK_MODULES == true ]]; then
-  # Ensure we pass all symlinked node_modules to the container
-  pushd node_modules > /dev/null
-  SYMLINKS=$(find . -maxdepth 2 -type l -not -path "./.bin/*")
-  popd > /dev/null
-  for LINK in $SYMLINKS; do
-    TARGET=$(readlink -f "node_modules/$LINK") || true
-    if [ -d "$TARGET" ]; then
-       if [ -n "$docker_is_podman" ]; then
-          echo -e "\033[31m" >&2
-          cat <<'EOF' >&2
-WARNING: `node_modules` contains symlinks, and the support for this in
-`playwright-screenshots.sh` is broken under podman due to
-https://github.com/containers/podman/issues/25947.
+# Check the playwright version
+PW_VERSION=$(pnpm --silent -- playwright --version | awk '{print $2}')
+IMAGE_NAME="ghcr.io/element-hq/element-web/playwright-server:$PW_VERSION"
 
-If you get errors such as 'Error: crun: creating `<path>`', then retry this
-having `yarn unlink`ed the relevant node modules.
-EOF
-        echo -e "\033[0m" >&2
-      fi
-      echo "mounting linked package ${LINK:2} in container"
-      RUN_ARGS+=( "-v" "$TARGET:/work/node_modules/${LINK:2}" )
-    fi
-  done
+# If the image exists in the repository, pull it; otherwise, build it.
+#
+# (This explicit test gives the user clearer progress info than just
+# `docker pull 2>/dev/null || build_image`.)
+if docker manifest inspect "$IMAGE_NAME" &>/dev/null; then
+    docker pull "$IMAGE_NAME"
+else
+    build_image "$IMAGE_NAME"
 fi
 
-# Our Playwright fixtures use Testcontainers [1], which uses a docker image
-# called Ryuk [2], which will clean up any dangling containers/networks/etc
-# after a timeout, if the parent process dies unexpectedly.
-#
-# To do this, Ryuk requires access to the docker socket, so Testcontainers
-# starts the Ryuk container with a bind-mount of `/var/run/docker.sock`.
-# However, we're going to be running Playwright (and hence Testcontainers)
-# itself in a container, but talking to the Docker daemon on the *host*, which
-# means that bind mounts will be relative to the *host* filesystem. In short,
-# it will try to bind-mount the *host's* `/var/run/docker.sock` rather than
-# that from inside the element-web-playwright-common container.
-#
-# To solve this problem, we start Ryuk ourselves (with the correct docker
-# socket) rather than waiting for Testcontainers to do so. Testcontainers will
-# find the running Ryuk instance and connect to it rather than start a new one.
-#
-# [1] https://testcontainers.com/
-# [2] https://github.com/testcontainers/moby-ryuk
-docker run -d --rm --label org.testcontainers.ryuk=true -v "${docker_sock}":/var/run/docker.sock -p 8080 --name="playwright-ryuk" testcontainers/ryuk:0.14.0
+# Start the playwright-server in docker
+CONTAINER=$(docker run --network=host -v /tmp:/tmp --rm -d -e PORT="$WS_PORT" "$IMAGE_NAME")
+# Set up an exit trap to clean up the docker container
+clean_up() {
+    ARG=$?
+    echo "Stopping playwright-server"
+    docker stop "$CONTAINER" > /dev/null
+    exit $ARG
+}
+trap clean_up EXIT
+
+# Wait for playwright-server to be ready
+echo "Waiting for playwright-server"
+pnpm --dir "$SCRIPT_DIR" exec wait-on "tcp:$WS_PORT"
 
-docker run "${RUN_ARGS[@]}" "$IMAGE_NAME" "${DEFAULT_ARGS[@]}" "$@"
+# Run the test we were given, setting PW_TEST_CONNECT_WS_ENDPOINT accordingly
+echo "Running '$@'"
+PW_TEST_CONNECT_WS_ENDPOINT="http://localhost:$WS_PORT" "$@"

package/project.json

@@ -0,0 +1,38 @@
+{
+    "$schema": "../../node_modules/nx/schemas/project-schema.json",
+    "projectType": "library",
+    "root": "packages/playwright-common",
+    "targets": {
+        "build:playwright": {
+            "cache": true,
+            "command": "tsc",
+            "inputs": ["src"],
+            "outputs": ["{projectRoot}/lib"],
+            "options": { "cwd": "packages/playwright-common" }
+        },
+        "docker:prebuild": {
+            "cache": true,
+            "command": "echo PLAYWRIGHT_VERSION=$(pnpm --silent -- playwright --version | awk '{print $2}') > .env.docker:build",
+            "inputs": [{ "runtime": "pnpm --silent -- playwright --version" }],
+            "outputs": ["{projectRoot}/.env.docker:build"],
+            "options": { "cwd": "packages/playwright-common" }
+        },
+        "docker:build": {
+            "executor": "@nx-tools/nx-container:build",
+            "dependsOn": ["docker:prebuild"],
+            "options": {
+                "load": true,
+                "engine": "docker",
+                "platforms": ["linux/amd64", "linux/arm64"],
+                "provenance": "true",
+                "sbom": true,
+                "build-args": ["PLAYWRIGHT_VERSION=$PLAYWRIGHT_VERSION"],
+                "context": "{projectRoot}",
+                "metadata": {
+                    "images": ["ghcr.io/element-hq/element-web/playwright-server"],
+                    "tags": ["type=ref,event=branch", "type=raw,enable={{is_default_branch}},value=$PLAYWRIGHT_VERSION"]
+                }
+            }
+        }
+    }
+}

package/src/fixtures/services.ts

@@ -7,7 +7,7 @@ Please see LICENSE files in the repository root for full details.
 
 import { type MailpitClient } from "mailpit-api";
 import { Network, type StartedNetwork } from "testcontainers";
-import { PostgreSqlContainer, type StartedPostgreSqlContainer } from "@testcontainers/postgresql";
+import { type StartedPostgreSqlContainer } from "@testcontainers/postgresql";
 
 import {
     type SynapseConfig,
@@ -22,6 +22,7 @@ import { Logger } from "../utils/logger.js";
 // We want to avoid using `mergeTests` in index.ts because it drops useful type information about the fixtures. Instead,
 // we add `axe` into our fixture suite by using its `test` as a base, so that there is a linear hierarchy.
 import { test as base } from "./axe.js";
+import { makePostgres } from "../testcontainers/postgres.js";
 
 /**
  * Test-scoped fixtures available in the test
@@ -101,27 +102,7 @@ export const test = base.extend<TestFixtures, WorkerOptions & Services>({
     ],
     postgres: [
         async ({ logger, network }, use) => {
-            const container = await new PostgreSqlContainer("postgres:13.3-alpine")
-                .withNetwork(network)
-                .withNetworkAliases("postgres")
-                .withLogConsumer(logger.getConsumer("postgres"))
-                .withTmpFs({
-                    "/dev/shm/pgdata/data": "",
-                })
-                .withEnvironment({
-                    PG_DATA: "/dev/shm/pgdata/data",
-                })
-                .withCommand([
-                    "-c",
-                    "shared_buffers=128MB",
-                    "-c",
-                    `fsync=off`,
-                    "-c",
-                    `synchronous_commit=off`,
-                    "-c",
-                    "full_page_writes=off",
-                ])
-                .start();
+            const container = await makePostgres(network, logger);
             await use(container);
             await container.stop();
         },

package/src/flaky-reporter.ts

@@ -0,0 +1,188 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2024 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+/**
+ * Flaky test reporter, creating & updating GitHub issues
+ * Only intended to run from within GitHub Actions
+ */
+
+import type { Reporter, TestCase } from "@playwright/test/reporter";
+
+const REPO = "element-hq/element-web";
+const LABEL = "Z-Flaky-Test";
+const ISSUE_TITLE_PREFIX = "Flaky playwright test: ";
+
+type PaginationLinks = {
+    prev?: string;
+    next?: string;
+    last?: string;
+    first?: string;
+};
+
+const ANSI_COLOUR_REGEX = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+
+// We see quite a few test flakes which are caused by the app exploding
+// so we have some magic strings we check the logs for to better track the flake with its cause
+const SPECIAL_CASES: Record<string, string> = {
+    "ChunkLoadError": "ChunkLoadError",
+    "Unreachable code should not be executed": "Rust crypto panic",
+    "Out of bounds memory access": "Rust crypto memory error",
+};
+
+class FlakyReporter implements Reporter {
+    private flakes = new Map<string, TestCase[]>();
+
+    public onTestEnd(test: TestCase): void {
+        // Ignores flakes on Dendrite and Pinecone as they have their own flakes we do not track
+        if (["Dendrite", "Pinecone"].includes(test.parent.project()!.name!)) return;
+
+        if (test.outcome() === "flaky") {
+            const failures: string[] = [];
+
+            const timedOutRuns = test.results.filter((result) => result.status === "timedOut");
+            const pageLogs = timedOutRuns.flatMap((result) =>
+                result.attachments.filter((attachment) => attachment.name.startsWith("page-")),
+            );
+
+            // If a test failed due to a systemic fault then the test is not flaky, the app is, record it as such.
+            const specialCases = Object.keys(SPECIAL_CASES).filter((log) =>
+                pageLogs.some((attachment) => attachment.name.startsWith("page-") && attachment.body?.includes(log)),
+            );
+            if (specialCases.length > 0) {
+                failures.push(...specialCases.map((specialCase) => SPECIAL_CASES[specialCase]));
+            }
+
+            // Check for fixtures failing to set up
+            const errorMessages = timedOutRuns
+                .map((r) => r.error?.message?.replace(ANSI_COLOUR_REGEX, ""))
+                .filter(Boolean) as string[];
+            for (const error of errorMessages) {
+                if (error.startsWith("Fixture") && error.endsWith("exceeded during setup.")) {
+                    failures.push(error);
+                }
+            }
+
+            if (failures.length < 1) {
+                failures.push(`${test.location.file.split("playwright/e2e/")[1]}: ${test.title}`);
+            }
+
+            for (const title of failures) {
+                if (!this.flakes.has(title)) {
+                    this.flakes.set(title, []);
+                }
+                this.flakes.get(title)!.push(test);
+            }
+        }
+    }
+
+    /**
+     * Parse link header to retrieve pagination links
+     * @see https://docs.github.com/en/rest/using-the-rest-api/using-pagination-in-the-rest-api?apiVersion=2022-11-28#using-link-headers
+     * @param link link header from response or undefined
+     * @returns an empty object if link is undefined otherwise returns a map from type to link
+     */
+    private parseLinkHeader(link: string): PaginationLinks {
+        /**
+         * link looks like:
+         * <https://api.github.com/repositories/1300192/issues?page=2>; rel="prev", <https://api.github.com/repositories/1300192/issues?page=4>;
+         */
+        const map: PaginationLinks = {};
+        if (!link) return map;
+        const matches = link.matchAll(/(<(?<link>.+?)>; rel="(?<type>.+?)")/g);
+        for (const match of matches) {
+            const { link, type } = match.groups!;
+            map[type as keyof PaginationLinks] = link;
+        }
+        return map;
+    }
+
+    /**
+     * Fetch all flaky test issues that were updated since Jan-1-2024
+     * @returns A promise that resolves to a list of issues
+     */
+    async getAllIssues(): Promise<any[]> {
+        const issues = [];
+        const { GITHUB_TOKEN, GITHUB_API_URL } = process.env;
+        // See https://docs.github.com/en/rest/issues/issues?apiVersion=2022-11-28#list-repository-issues
+        let url = `${GITHUB_API_URL}/repos/${REPO}/issues?labels=${LABEL}&state=all&per_page=100&sort=updated&since=2024-01-01`;
+        const headers = {
+            Authorization: `Bearer ${GITHUB_TOKEN}`,
+            Accept: "application / vnd.github + json",
+        };
+        while (url) {
+            // Fetch issues and add to list
+            const issuesResponse = await fetch(url, { headers });
+            const fetchedIssues = await issuesResponse.json();
+            issues.push(...fetchedIssues);
+
+            // Get the next link for fetching more results
+            const linkHeader = issuesResponse.headers.get("Link")!;
+            const parsed = this.parseLinkHeader(linkHeader);
+            url = parsed.next!;
+        }
+        return issues;
+    }
+
+    public async onExit(): Promise<void> {
+        if (this.flakes.size === 0) {
+            console.log("No flakes found");
+            return;
+        }
+
+        console.log("Found flakes: ");
+        for (const flake of this.flakes) {
+            console.log(flake);
+        }
+
+        const { GITHUB_TOKEN, GITHUB_API_URL, GITHUB_SERVER_URL, GITHUB_REPOSITORY, GITHUB_RUN_ID } = process.env;
+        if (!GITHUB_TOKEN) return;
+
+        const issues = await this.getAllIssues();
+        for (const [flake, results] of this.flakes) {
+            const title = ISSUE_TITLE_PREFIX + "`" + flake + "`";
+            const existingIssue = issues.find((issue) => issue.title === title);
+            const headers = { Authorization: `Bearer ${GITHUB_TOKEN}` };
+            const body = `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}`;
+
+            const labels = [LABEL, ...results.map((test) => `${LABEL}-${test.parent.project()?.name}`)];
+
+            if (existingIssue) {
+                console.log(`Found issue ${existingIssue.number} for ${flake}, adding comment...`);
+                // Ensure that the test is open
+                await fetch(existingIssue.url, {
+                    method: "PATCH",
+                    headers,
+                    body: JSON.stringify({ state: "open" }),
+                });
+                await fetch(`${existingIssue.url}/labels`, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify({ labels }),
+                });
+                await fetch(`${existingIssue.url}/comments`, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify({ body }),
+                });
+            } else {
+                console.log(`Creating new issue for ${flake}...`);
+                await fetch(`${GITHUB_API_URL}/repos/${REPO}/issues`, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify({
+                        title,
+                        body,
+                        labels: [...labels],
+                    }),
+                });
+            }
+        }
+    }
+}
+
+export default FlakyReporter;

package/src/stale-screenshot-reporter.ts

@@ -25,7 +25,7 @@ export const ANNOTATION = "_screenshot";
 class StaleScreenshotReporter implements Reporter {
     private readonly snapshotRoots = new Set<string>();
     private readonly screenshots = new Set<string>();
-    private failing = false;
+    private readonly failing = new Set<string>();
     private success = true;
 
     public onBegin(config: FullConfig): void {
@@ -36,8 +36,11 @@ class StaleScreenshotReporter implements Reporter {
 
     public onTestEnd(test: TestCase): void {
         if (!test.ok()) {
-            this.failing = true;
+            this.failing.add(test.id);
+            return;
         }
+        this.failing.delete(test.id); // delete if passed on re-run
+
         for (const annotation of test.annotations) {
             if (annotation.type === ANNOTATION && annotation.description) {
                 this.screenshots.add(annotation.description);
@@ -53,8 +56,7 @@ class StaleScreenshotReporter implements Reporter {
         this.success = false;
     }
 
-    public async onExit(): Promise<void> {
-        if (this.failing) return;
+    private async checkStaleScreenshots(): Promise<void> {
         if (!this.snapshotRoots.size) {
             this.error("No snapshot directories found, did you set the snapshotDir in your Playwright config?", "");
             return;
@@ -84,6 +86,14 @@ class StaleScreenshotReporter implements Reporter {
                 this.error("Stale screenshot file", screenshot);
             }
         }
+    }
+
+    public async onExit(): Promise<void> {
+        if (this.failing.size) {
+            this.error(`${this.failing.size} tests failed, skipping stale screenshot reporter.`, "");
+        } else {
+            await this.checkStaleScreenshots();
+        }
 
         if (!this.success) {
             process.exit(1);

package/src/testcontainers/index.ts

@@ -6,11 +6,13 @@ Please see LICENSE files in the repository root for full details.
 */
 
 export { PostgreSqlContainer, StartedPostgreSqlContainer } from "@testcontainers/postgresql";
+export { makePostgres } from "./postgres.js";
 export type { HomeserverInstance, HomeserverContainer, StartedHomeserverContainer } from "./HomeserverContainer.js";
 export { type SynapseConfig, SynapseContainer, StartedSynapseContainer } from "./synapse.js";
 export {
     type MasConfig,
     MatrixAuthenticationServiceContainer,
     StartedMatrixAuthenticationServiceContainer,
+    makeMas,
 } from "./mas.js";
 export { type MailpitClient, MailpitContainer, StartedMailpitContainer } from "./mailpit.js";

package/src/testcontainers/mas.ts

@@ -11,6 +11,7 @@ import {
     type StartedTestContainer,
     Wait,
     type ExecResult,
+    type StartedNetwork,
 } from "testcontainers";
 import { type StartedPostgreSqlContainer } from "@testcontainers/postgresql";
 import * as YAML from "yaml";
@@ -23,6 +24,7 @@ import { type Credentials } from "../utils/api.js";
 //   curl -sL https://element-hq.github.io/matrix-authentication-service/config.schema.json \
 //     | npx json-schema-to-typescript -o packages/element-web-playwright-common/src/testconainers/mas-config.ts
 import type { RootConfig as MasConfig } from "./mas-config.js";
+import type { Logger } from "../utils/logger.js";
 
 export { type MasConfig };
 
@@ -156,6 +158,7 @@ export class MatrixAuthenticationServiceContainer extends GenericContainer {
         super(image);
 
         const initialConfig = deepCopy(DEFAULT_CONFIG);
+        initialConfig.database.host = db.getHostname();
         initialConfig.database.username = db.getUsername();
         initialConfig.database.password = db.getPassword();
 
@@ -205,6 +208,7 @@ export class MatrixAuthenticationServiceContainer extends GenericContainer {
             await super.start(),
             `http://localhost:${port}`,
             this.args,
+            this.config.matrix.secret,
         );
     }
 }
@@ -219,6 +223,7 @@ export class StartedMatrixAuthenticationServiceContainer extends AbstractStarted
         container: StartedTestContainer,
         public readonly baseUrl: string,
         private readonly args: string[],
+        public readonly sharedSecret: string,
     ) {
         super(container);
     }
@@ -346,3 +351,19 @@ export class StartedMatrixAuthenticationServiceContainer extends AbstractStarted
         await this.manage("add-email", username, address);
     }
 }
+
+export async function makeMas(
+    postgres: StartedPostgreSqlContainer,
+    network: StartedNetwork,
+    logger: Logger,
+    config: Partial<MasConfig>,
+    name = "mas",
+): Promise<StartedMatrixAuthenticationServiceContainer> {
+    const container = await new MatrixAuthenticationServiceContainer(postgres)
+        .withNetwork(network)
+        .withNetworkAliases(name)
+        .withLogConsumer(logger.getConsumer(name))
+        .withConfig(config)
+        .start();
+    return container;
+}