Testen

Documentation Index

Fetch the complete documentation index at: https://docs2.openclaw.ai/llms.txt

Use this file to discover all available pages before exploring further.

• Wat elke suite dekt (en wat deze bewust niet dekt).
• Welke opdrachten je uitvoert voor veelvoorkomende workflows (lokaal, pre-push, debuggen).
• Hoe live-tests inloggegevens ontdekken en modellen/providers selecteren.
• Hoe je regressies toevoegt voor echte model-/providerproblemen.

​

Snel aan de slag

• Volledige gate (verwacht vóór push): pnpm build && pnpm check && pnpm check:test-types && pnpm test
• Snellere lokale volledige suite-run op een ruime machine: pnpm test:max
• Directe Vitest-watch-loop: pnpm test:watch
• Directe bestandsdoelen routeren nu ook extensie-/kanaalpaden: pnpm test extensions/discord/src/monitor/message-handler.preflight.test.ts
• Geef eerst de voorkeur aan gerichte runs wanneer je aan één fout werkt.
• Docker-ondersteunde QA-site: pnpm qa:lab:up
• Door Linux-VM ondersteunde QA-lane: pnpm openclaw qa suite --runner multipass --scenario channel-chat-baseline

• Coverage-gate: pnpm test:coverage
• E2E-suite: pnpm test:e2e

• Live-suite (modellen + Gateway-tool-/image-probes): pnpm test:live
• Richt stil op één live-bestand: pnpm test:live -- src/agents/models.profiles.live.test.ts
• Runtime-prestatierapporten: dispatch OpenClaw Performance met live_gpt54=true voor een echte openai/gpt-5.4-agentbeurt of deep_profile=true voor Kova CPU-/heap-/trace-artefacten. Dagelijkse geplande runs publiceren mock-provider-, deep-profile- en GPT 5.4-lane-artefacten naar openclaw/clawgrit-reports wanneer CLAWGRIT_REPORTS_TOKEN is geconfigureerd. Het mock-provider-rapport bevat ook source-level Gateway-boot-, geheugen-, plugin-pressure-, herhaalde fake-model hello-loop- en CLI-opstartcijfers.
• Docker live model sweep: pnpm test:docker:live-models
  • Elk geselecteerd model voert nu een tekstbeurt uit plus een kleine file-read-achtige probe. Modellen waarvan de metadata image-invoer adverteert, voeren ook een kleine image-beurt uit. Schakel de extra probes uit met OPENCLAW_LIVE_MODEL_FILE_PROBE=0 of OPENCLAW_LIVE_MODEL_IMAGE_PROBE=0 wanneer je providerfouten isoleert.
  • CI-dekking: dagelijkse OpenClaw Scheduled Live And E2E Checks en handmatige OpenClaw Release Checks roepen beide de herbruikbare live/E2E-workflow aan met include_live_suites: true, inclusief aparte Docker live model-matrixjobs die per provider zijn geshard.
  • Voor gerichte CI-reruns dispatch je OpenClaw Live And E2E Checks (Reusable) met include_live_suites: true en live_models_only: true.
  • Voeg nieuwe providersecrets met hoog signaal toe aan scripts/ci-hydrate-live-auth.sh plus .github/workflows/openclaw-live-and-e2e-checks-reusable.yml en de geplande/release-callers daarvan.
• Native Codex bound-chat-smoke: pnpm test:docker:live-codex-bind
  • Voert een Docker live-lane uit tegen het Codex app-server-pad, bindt een synthetische Slack-DM met /codex bind, oefent /codex fast en /codex permissions, en verifieert vervolgens dat een gewone reply en een image-attachment via de native plugin-binding routeren in plaats van ACP.
• Codex app-server harness-smoke: pnpm test:docker:live-codex-harness
  • Voert Gateway-agentbeurten uit via de Plugin-beheerde Codex app-server harness, verifieert /codex status en /codex models, en oefent standaard image, cron MCP, sub-agent en Guardian-probes. Schakel de sub-agent-probe uit met OPENCLAW_LIVE_CODEX_HARNESS_SUBAGENT_PROBE=0 wanneer je andere Codex app-server-fouten isoleert. Voor een gerichte sub-agent-check schakel je de andere probes uit: OPENCLAW_LIVE_CODEX_HARNESS_IMAGE_PROBE=0 OPENCLAW_LIVE_CODEX_HARNESS_MCP_PROBE=0 OPENCLAW_LIVE_CODEX_HARNESS_GUARDIAN_PROBE=0 OPENCLAW_LIVE_CODEX_HARNESS_SUBAGENT_PROBE=1 pnpm test:docker:live-codex-harness. Dit stopt na de sub-agent-probe tenzij OPENCLAW_LIVE_CODEX_HARNESS_SUBAGENT_ONLY=0 is ingesteld.
• Codex on-demand install-smoke: pnpm test:docker:codex-on-demand
  • Installeert de verpakte OpenClaw-tarball in Docker, voert OpenAI API-key-onboarding uit, en verifieert dat de Codex-Plugin plus @openai/codex-dependency on demand naar de beheerde npm-root zijn gedownload.
• Live plugin tool dependency-smoke: pnpm test:docker:live-plugin-tool
  • Pakt een fixture-Plugin met een echte slugify-dependency, installeert deze via npm-pack:, verifieert de dependency onder de beheerde npm-root, en vraagt daarna een live OpenAI-model om de plugin-tool aan te roepen en de verborgen slug terug te geven.
• Crestodian rescue command-smoke: pnpm test:live:crestodian-rescue-channel
  • Opt-in belt-and-suspenders-check voor het message-channel rescue command-oppervlak. Deze oefent /crestodian status, zet een persistente modelwijziging in de wachtrij, antwoordt /crestodian yes, en verifieert het audit-/config-write-pad.
• Crestodian planner Docker-smoke: pnpm test:docker:crestodian-planner
  • Voert Crestodian uit in een configloze container met een fake Claude CLI op PATH en verifieert dat de fuzzy planner fallback wordt vertaald naar een geaudite typed config write.
• Crestodian first-run Docker-smoke: pnpm test:docker:crestodian-first-run
  • Start vanuit een lege OpenClaw-state-dir, routeert kale openclaw naar Crestodian, past setup/model/agent/Discord Plugin + SecretRef-writes toe, valideert config, en verifieert auditvermeldingen. Hetzelfde Ring 0-setup-pad wordt ook gedekt in QA Lab door pnpm openclaw qa suite --scenario crestodian-ring-zero-setup.
• Moonshot/Kimi cost-smoke: met MOONSHOT_API_KEY ingesteld, voer openclaw models list --provider moonshot --json uit, en voer daarna een geïsoleerde openclaw agent --local --session-id live-kimi-cost --message 'Reply exactly: KIMI_LIVE_OK' --thinking off --json uit tegen moonshot/kimi-k2.6. Verifieer dat de JSON Moonshot/K2.6 rapporteert en dat het assistenttranscript genormaliseerde usage.cost opslaat.

​

QA-specifieke runners

• pnpm openclaw qa suite
  • Voert repo-ondersteunde QA-scenario’s rechtstreeks op de host uit.
  • Voert standaard meerdere geselecteerde scenario’s parallel uit met geïsoleerde Gateway-workers. qa-channel gebruikt standaard concurrency 4 (begrensd door het aantal geselecteerde scenario’s). Gebruik --concurrency <count> om het aantal workers af te stemmen, of --concurrency 1 voor de oudere seriële lane.
  • Eindigt met een niet-nul exitcode wanneer een scenario faalt. Gebruik --allow-failures wanneer je artefacten wilt zonder een falende exitcode.
  • Ondersteunt providermodi live-frontier, mock-openai en aimock. aimock start een lokale AIMock-ondersteunde providerserver voor experimentele fixture- en protocol-mockdekking zonder de scenariobewuste mock-openai-lane te vervangen.
• pnpm test:plugins:kitchen-sink-live
  • Voert de live OpenAI Kitchen Sink-pluginproef uit via QA Lab. Het installeert het externe Kitchen Sink-pakket, verifieert de inventaris van het plugin SDK-oppervlak, test /healthz en /readyz, registreert Gateway CPU/RSS- bewijs, voert een live OpenAI-beurt uit en controleert vijandige diagnostiek. Vereist live OpenAI-authenticatie zoals OPENAI_API_KEY. In gehydrateerde Testbox- sessies gebruikt het automatisch het Testbox live-authprofiel wanneer de openclaw-testbox-env-helper aanwezig is.
• pnpm test:gateway:cpu-scenarios
  • Voert de Gateway-opstartbenchmark uit plus een klein mock-QA Lab-scenariopakket (channel-chat-baseline, memory-failure-fallback, gateway-restart-inflight-run) en schrijft een gecombineerde CPU-observatie- samenvatting onder .artifacts/gateway-cpu-scenarios/.
  • Markeert standaard alleen aanhoudende hete CPU-observaties (--cpu-core-warn plus --hot-wall-warn-ms), zodat korte opstartpieken als metrieken worden geregistreerd zonder te lijken op de minutenlange Gateway-pegregressie.
  • Gebruikt gebouwde dist-artefacten; voer eerst een build uit wanneer de checkout nog geen verse runtime-uitvoer heeft.
• pnpm openclaw qa suite --runner multipass
  • Voert dezelfde QA-suite uit binnen een wegwerpbare Multipass Linux-VM.
  • Behoudt hetzelfde scenariokeuzegedrag als qa suite op de host.
  • Hergebruikt dezelfde provider-/modelkeuzevlaggen als qa suite.
  • Live-runs geven de ondersteunde QA-authinvoer door die praktisch is voor de guest: env-gebaseerde providersleutels, het QA live-providerconfiguratiepad en CODEX_HOME wanneer aanwezig.
  • Uitvoermappen moeten onder de repo-root blijven zodat de guest via de gemounte workspace kan terugschrijven.
  • Schrijft het normale QA-rapport + samenvatting plus Multipass-logs onder .artifacts/qa-e2e/....
• pnpm qa:lab:up
  • Start de Docker-ondersteunde QA-site voor operatorachtige QA-werkzaamheden.
• pnpm test:docker:npm-onboard-channel-agent
  • Bouwt een npm-tarball vanuit de huidige checkout, installeert die globaal in Docker, voert niet-interactieve OpenAI API-sleutel-onboarding uit, configureert standaard Telegram, verifieert dat de verpakte plugin-runtime laadt zonder afhankelijkheidsherstel bij het opstarten, voert doctor uit en voert één lokale agentbeurt uit tegen een gemockt OpenAI-eindpunt.
  • Gebruik OPENCLAW_NPM_ONBOARD_CHANNEL=discord om dezelfde packaged-install- lane met Discord uit te voeren.
• pnpm test:docker:session-runtime-context
  • Voert een deterministische Docker-smoketest van de gebouwde app uit voor ingebedde runtimecontext- transcripties. Het verifieert dat verborgen OpenClaw-runtimecontext wordt opgeslagen als een niet-weergegeven aangepast bericht in plaats van te lekken in de zichtbare gebruikersbeurt, seedt vervolgens een getroffen kapotte sessie-JSONL en verifieert dat openclaw doctor --fix die herschrijft naar de actieve branch met een back-up.
• pnpm test:docker:npm-telegram-live
  • Installeert een kandidaat-OpenClaw-pakket in Docker, voert installed-package- onboarding uit, configureert Telegram via de geïnstalleerde CLI en hergebruikt daarna de live Telegram QA-lane met dat geïnstalleerde pakket als de SUT Gateway.
  • De wrapper mount alleen de qa-lab-harnessbron vanuit de checkout; het geïnstalleerde pakket bezit dist, openclaw/plugin-sdk en gebundelde plugin- runtime, zodat de lane geen huidige checkout-plugins mengt in het pakket dat wordt getest.
  • Gebruikt standaard OPENCLAW_NPM_TELEGRAM_PACKAGE_SPEC=openclaw@beta; stel OPENCLAW_NPM_TELEGRAM_PACKAGE_TGZ=/path/to/openclaw-current.tgz of OPENCLAW_CURRENT_PACKAGE_TGZ in om in plaats van installatie uit het registry een opgeloste lokale tarball te testen.
  • Gebruikt dezelfde Telegram-envreferenties of Convex-referentiebron als pnpm openclaw qa telegram. Stel voor CI-/releaseautomatisering OPENCLAW_NPM_TELEGRAM_CREDENTIAL_SOURCE=convex in plus OPENCLAW_QA_CONVEX_SITE_URL en het rolgeheim. Als OPENCLAW_QA_CONVEX_SITE_URL en een Convex-rolgeheim aanwezig zijn in CI, selecteert de Docker-wrapper automatisch Convex.
  • De wrapper valideert Telegram- of Convex-referentie-env op de host voordat Docker-build-/installatiewerk begint. Stel OPENCLAW_NPM_TELEGRAM_SKIP_CREDENTIAL_PREFLIGHT=1 alleen in wanneer je bewust pre-credential setup debugt.
  • OPENCLAW_NPM_TELEGRAM_CREDENTIAL_ROLE=ci|maintainer overschrijft de gedeelde OPENCLAW_QA_CREDENTIAL_ROLE alleen voor deze lane.
  • GitHub Actions stelt deze lane beschikbaar als de handmatige maintainerworkflow NPM Telegram Beta E2E. Deze draait niet bij merge. De workflow gebruikt de qa-live-shared-omgeving en Convex CI-referentieleases.
• GitHub Actions stelt ook Package Acceptance beschikbaar voor productbewijs als side-run tegen één kandidaatpakket. Het accepteert een vertrouwde ref, gepubliceerde npm-specificatie, HTTPS-tarball-URL plus SHA-256, of tarball-artefact uit een andere run, uploadt de genormaliseerde openclaw-current.tgz als package-under-test en voert daarna de bestaande Docker E2E-scheduler uit met smoke-, package-, product-, full- of aangepaste lane-profielen. Stel telegram_mode=mock-openai of live-frontier in om de Telegram QA-workflow uit te voeren tegen hetzelfde package-under-test-artefact.
  • Nieuwste beta-productbewijs:

gh workflow run package-acceptance.yml --ref main \
  -f source=npm \
  -f package_spec=openclaw@beta \
  -f suite_profile=product \
  -f telegram_mode=mock-openai

• Bewijs met exacte tarball-URL vereist een digest:

gh workflow run package-acceptance.yml --ref main \
  -f source=url \
  -f package_url=https://registry.npmjs.org/openclaw/-/openclaw-VERSION.tgz \
  -f package_sha256=<sha256> \
  -f suite_profile=package

• Artefactbewijs downloadt een tarball-artefact uit een andere Actions-run:

gh workflow run package-acceptance.yml --ref main \
  -f source=artifact \
  -f artifact_run_id=<run-id> \
  -f artifact_name=<artifact-name> \
  -f suite_profile=smoke

• pnpm test:docker:plugins
  • Pakt en installeert de huidige OpenClaw-build in Docker, start de Gateway met OpenAI geconfigureerd en schakelt daarna gebundelde channels/plugins in via configuratie- bewerkingen.
  • Verifieert dat setup-detectie ongeconfigureerde downloadbare plugins afwezig laat, dat de eerste geconfigureerde doctor-reparatie elke ontbrekende downloadbare plugin expliciet installeert en dat een tweede herstart geen verborgen afhankelijkheids- herstel uitvoert.
  • Installeert ook een bekende oudere npm-baseline, schakelt Telegram in voordat openclaw update --tag <candidate> wordt uitgevoerd en verifieert dat de doctor na de update van de kandidaat oude plugin-afhankelijkheidsresten opruimt zonder een harness-side postinstall-reparatie.
• pnpm test:parallels:npm-update
  • Voert de native packaged-install update-smoke uit over Parallels-guests. Elk geselecteerd platform installeert eerst het aangevraagde baselinepakket, voert daarna de geïnstalleerde openclaw update-opdracht uit in dezelfde guest en verifieert de geïnstalleerde versie, updatestatus, Gateway-gereedheid en één lokale agent- beurt.
  • Gebruik --platform macos, --platform windows of --platform linux tijdens iteratie op één guest. Gebruik --json voor het samenvattingsartefactpad en de status per lane.
  • De OpenAI-lane gebruikt standaard openai/gpt-5.5 voor het live agentbeurtbewijs. Geef --model <provider/model> door of stel OPENCLAW_PARALLELS_OPENAI_MODEL in wanneer je bewust een ander OpenAI-model valideert.
  • Wikkel lange lokale runs in een host-time-out zodat vastgelopen Parallels-transport niet de rest van het testvenster kan verbruiken:
    timeout --foreground 150m pnpm test:parallels:npm-update -- --json
    timeout --foreground 90m pnpm test:parallels:npm-update -- --platform windows --json
    
  • Het script schrijft geneste lane-logs onder /tmp/openclaw-parallels-npm-update.*. Inspecteer windows-update.log, macos-update.log of linux-update.log voordat je aanneemt dat de buitenste wrapper vastloopt.
  • Windows-update kan op een koude guest 10 tot 15 minuten besteden aan post-update doctor en pakket- updatewerk; dat is nog steeds gezond wanneer de geneste npm- debuglog voortgang laat zien.
  • Voer deze aggregaatwrapper niet parallel uit met individuele Parallels- macOS-, Windows- of Linux-smokelanes. Ze delen VM-status en kunnen botsen bij snapshotherstel, pakketservering of Gateway-status van de guest.
  • Het post-updatebewijs gebruikt het normale gebundelde plugin-oppervlak, omdat capability-facades zoals spraak, beeldgeneratie en media- begrip worden geladen via gebundelde runtime-API’s, zelfs wanneer de agentbeurt zelf alleen een eenvoudige tekstreactie controleert.
• pnpm openclaw qa aimock
  • Start alleen de lokale AIMock-providerserver voor directe protocol-smoke- tests.
• pnpm openclaw qa matrix
  • Voert de Matrix live QA-lane uit tegen een wegwerpbare Docker-ondersteunde Tuwunel-homeserver. Alleen source-checkout - packaged installs leveren qa-lab niet mee.
  • Volledige CLI, profiel-/scenariocatalogus, env-vars en artefactindeling: Matrix QA.
• pnpm openclaw qa telegram
  • Voert de Telegram live QA-lane uit tegen een echte privégroep met de driver- en SUT-bottokens uit env.
  • Vereist OPENCLAW_QA_TELEGRAM_GROUP_ID, OPENCLAW_QA_TELEGRAM_DRIVER_BOT_TOKEN en OPENCLAW_QA_TELEGRAM_SUT_BOT_TOKEN. De groeps-id moet de numerieke Telegram-chat-id zijn.
  • Ondersteunt --credential-source convex voor gedeelde gepoolde referenties. Gebruik standaard env-modus, of stel OPENCLAW_QA_CREDENTIAL_SOURCE=convex in om pooled leases te gebruiken.
  • Standaarden dekken canary, mention-gating, command-adressering, /status, bot-naar-bot genoemde antwoorden en core native command-antwoorden. mock-openai-standaarden dekken ook deterministische reply-chain- en Telegram final-message streaming-regressies. Gebruik --list-scenarios voor optionele probes zoals session_status.
  • Eindigt met een niet-nul exitcode wanneer een scenario faalt. Gebruik --allow-failures wanneer je artefacten wilt zonder een falende exitcode.
  • Vereist twee afzonderlijke bots in dezelfde privégroep, waarbij de SUT-bot een Telegram-gebruikersnaam exposeert.
  • Schakel voor stabiele bot-naar-botobservatie Bot-to-Bot Communication Mode in @BotFather in voor beide bots en zorg dat de driverbot groepsbotverkeer kan observeren.
  • Schrijft een Telegram QA-rapport, samenvatting en observed-messages-artefact onder .artifacts/qa-e2e/.... Antwoordscenario’s bevatten RTT vanaf het verzendverzoek van de driver tot het geobserveerde SUT-antwoord.

@Mantis telegram
@Mantis telegram scenario=telegram-status-command
@Mantis telegram scenarios=telegram-status-command,telegram-mentioned-message-reply

@Mantis telegram desktop proof

• pnpm openclaw qa mantis telegram-desktop-builder
  • Least of hergebruikt een Crabbox Linux-desktop, installeert native Telegram Desktop, configureert OpenClaw met een geleased Telegram SUT-bottoken, start de Gateway en neemt screenshot-/MP4-bewijs op vanaf de zichtbare VNC-desktop.
  • Standaardwaarde is --credential-source convex, zodat workflows alleen het Convex-brokergeheim nodig hebben. Gebruik --credential-source env met dezelfde OPENCLAW_QA_TELEGRAM_*-variabelen als pnpm openclaw qa telegram.
  • Telegram Desktop heeft nog steeds een gebruikerslogin/-profiel nodig. Het bottoken configureert alleen OpenClaw. Gebruik --telegram-profile-archive-env <name> voor een base64 .tgz-profielarchief, of gebruik --keep-lease en log eenmalig handmatig in via VNC.
  • Schrijft mantis-telegram-desktop-builder-report.md, mantis-telegram-desktop-builder-summary.json, telegram-desktop-builder.png en telegram-desktop-builder.mp4 onder de uitvoermap.

​

Gedeelde Telegram-inloggegevens via Convex (v1)

• qa/convex-credential-broker/

• OPENCLAW_QA_CONVEX_SITE_URL (bijvoorbeeld https://your-deployment.convex.site)
• Eén geheim voor de geselecteerde rol:
  • OPENCLAW_QA_CONVEX_SECRET_MAINTAINER voor maintainer
  • OPENCLAW_QA_CONVEX_SECRET_CI voor ci
• Selectie van inloggegevensrol:
  • CLI: --credential-role maintainer|ci
  • Env-standaard: OPENCLAW_QA_CREDENTIAL_ROLE (standaard ci in CI, anders maintainer)

• OPENCLAW_QA_CREDENTIAL_LEASE_TTL_MS (standaard 1200000)
• OPENCLAW_QA_CREDENTIAL_HEARTBEAT_INTERVAL_MS (standaard 30000)
• OPENCLAW_QA_CREDENTIAL_ACQUIRE_TIMEOUT_MS (standaard 90000)
• OPENCLAW_QA_CREDENTIAL_HTTP_TIMEOUT_MS (standaard 15000)
• OPENCLAW_QA_CONVEX_ENDPOINT_PREFIX (standaard /qa-credentials/v1)
• OPENCLAW_QA_CREDENTIAL_OWNER_ID (optionele trace-id)
• OPENCLAW_QA_ALLOW_INSECURE_HTTP=1 staat loopback-http://-Convex-URL’s toe voor uitsluitend lokale ontwikkeling.

pnpm openclaw qa credentials doctor
pnpm openclaw qa credentials add --kind telegram --payload-file qa/telegram-credential.json
pnpm openclaw qa credentials list --kind telegram
pnpm openclaw qa credentials remove --credential-id <credential-id>

• POST /acquire
  • Aanvraag: { kind, ownerId, actorRole, leaseTtlMs, heartbeatIntervalMs }
  • Geslaagd: { status: "ok", credentialId, leaseToken, payload, leaseTtlMs?, heartbeatIntervalMs? }
  • Uitgeput/opnieuw te proberen: { status: "error", code: "POOL_EXHAUSTED" | "NO_CREDENTIAL_AVAILABLE", ... }
• POST /payload-chunk
  • Aanvraag: { kind, ownerId, actorRole, credentialId, leaseToken, index }
  • Geslaagd: { status: "ok", index, data }
• POST /heartbeat
  • Aanvraag: { kind, ownerId, actorRole, credentialId, leaseToken, leaseTtlMs }
  • Geslaagd: { status: "ok" } (of lege 2xx)
• POST /release
  • Aanvraag: { kind, ownerId, actorRole, credentialId, leaseToken }
  • Geslaagd: { status: "ok" } (of lege 2xx)
• POST /admin/add (alleen maintainergeheim)
  • Aanvraag: { kind, actorId, payload, note?, status? }
  • Geslaagd: { status: "ok", credential }
• POST /admin/remove (alleen maintainergeheim)
  • Aanvraag: { credentialId, actorId }
  • Geslaagd: { status: "ok", changed, credential }
  • Actieve-leasebeveiliging: { status: "error", code: "LEASE_ACTIVE", ... }
• POST /admin/list (alleen maintainergeheim)
  • Aanvraag: { kind?, status?, includePayload?, limit? }
  • Geslaagd: { status: "ok", credentials, count }

• { groupId: string, driverToken: string, sutToken: string }
• groupId moet een numerieke Telegram-chat-id-string zijn.
• admin/add valideert deze vorm voor kind: "telegram" en wijst verkeerd gevormde payloads af.

• { groupId: string, sutToken: string, testerUserId: string, testerUsername: string, telegramApiId: string, telegramApiHash: string, tdlibDatabaseEncryptionKey: string, tdlibArchiveBase64: string, tdlibArchiveSha256: string, desktopTdataArchiveBase64: string, desktopTdataArchiveSha256: string }
• groupId, testerUserId en telegramApiId moeten numerieke strings zijn.
• tdlibArchiveSha256 en desktopTdataArchiveSha256 moeten SHA-256-hexstrings zijn.
• kind: "telegram-user" vertegenwoordigt één Telegram-burneraccount. Behandel de lease als accountbreed: de TDLib CLI-driver en de visuele getuige van Telegram Desktop herstellen vanuit dezelfde payload, en slechts één job mag de lease tegelijk hebben.

tmp=$(mktemp -d /tmp/openclaw-telegram-user.XXXXXX)
node --import tsx scripts/e2e/telegram-user-credential.ts lease-restore \
  --user-driver-dir "$tmp/user-driver" \
  --desktop-workdir "$tmp/desktop" \
  --lease-file "$tmp/lease.json"
TELEGRAM_USER_DRIVER_STATE_DIR="$tmp/user-driver" \
  uv run ~/.codex/skills/custom/telegram-e2e-bot-to-bot/scripts/user-driver.py status --json
node --import tsx scripts/e2e/telegram-user-credential.ts release --lease-file "$tmp/lease.json"

pnpm qa:telegram-user:crabbox -- start \
  --tdlib-url http://artifacts.openclaw.ai/tdlib-v1.8.0-linux-x64.tgz \
  --output-dir .artifacts/qa-e2e/telegram-user-crabbox/pr-review
pnpm qa:telegram-user:crabbox -- send \
  --session .artifacts/qa-e2e/telegram-user-crabbox/pr-review/session.json \
  --text /status
pnpm qa:telegram-user:crabbox -- finish \
  --session .artifacts/qa-e2e/telegram-user-crabbox/pr-review/session.json

• send --session <file> --text <message> verzendt via de echte TDLib-gebruiker en wacht op het SUT-antwoord.
• run --session <file> -- <remote command> voert een willekeurige opdracht uit op de Crabbox en slaat de uitvoer op, bijvoorbeeld bash -lc 'source /tmp/openclaw-telegram-user-crabbox/env.sh && python3 /tmp/openclaw-telegram-user-crabbox/user-driver.py transcript --limit 20 --json'.
• screenshot --session <file> legt de huidige zichtbare desktop vast.
• status --session <file> drukt de lease en WebVNC-opdracht af.
• finish --session <file> stopt de recorder, legt screenshot-/video-/motion-trim-artefacten vast, geeft de Convex-inloggegevens vrij, stopt lokale SUT-processen en stopt de Crabbox-lease tenzij --keep-box is meegegeven.
• publish --session <file> --pr <number> publiceert standaard een PR-commentaar met alleen GIF’s. Geef --full-artifacts alleen mee wanneer logs of JSON-artefacten bewust nodig zijn.

pnpm qa:telegram-user:crabbox -- --text /status

• Discord: { guildId: string, channelId: string, driverBotToken: string, sutBotToken: string, sutApplicationId: string, voiceChannelId?: string }
• WhatsApp: { driverPhoneE164: string, sutPhoneE164: string, driverAuthArchiveBase64: string, sutAuthArchiveBase64: string, groupJid?: string }

​

Een kanaal toevoegen aan QA

​

Testsuites (wat waar draait)

​

Unit / integratie (standaard)

• Opdracht: pnpm test
• Config: ongerichte runs gebruiken de vitest.full-*.config.ts-shardset en kunnen multi-project-shards uitbreiden naar per-project-configs voor parallelle planning
• Bestanden: core-/unitinventarissen onder src/**/*.test.ts, packages/**/*.test.ts en test/**/*.test.ts; UI-unittests draaien in de toegewezen unit-ui-shard
• Scope:
  • Zuivere unittests
  • In-process integratietests (Gateway-auth, routering, tooling, parsing, config)
  • Deterministische regressies voor bekende bugs
• Verwachtingen:
  • Draait in CI
  • Geen echte sleutels vereist
  • Moet snel en stabiel zijn
  • Resolver- en public-surface-loadertests moeten breed fallbackgedrag van api.js en runtime-api.js bewijzen met gegenereerde kleine Plugin-fixtures, niet met echte gebundelde Plugin-bron-API’s. Echte Plugin-API-loads horen thuis in door de Plugin beheerde contract-/integratiesuites.

• Standaard testinstallaties slaan optionele native Discord opus-builds over. Discord-spraakontvangst gebruikt de pure-JS opusscript-decoder, en @discordjs/opus blijft uitgeschakeld in allowBuilds, zodat lokale tests en Testbox-banen de native add-on niet compileren.
• Gebruik een speciale Discord-spraakprestatiebaan of live-baan als je bewust een native opus-build moet vergelijken. Zet @discordjs/opus niet op true in de standaard allowBuilds; daardoor gaan niet-gerelateerde installatie-/testlussen native code compileren.

​

Stabiliteit (Gateway)

• Commando: pnpm test:stability:gateway
• Configuratie: vitest.gateway.config.ts, geforceerd naar één worker
• Scope:
  • Start standaard een echte loopback-Gateway met diagnostiek ingeschakeld
  • Stuurt synthetische gatewaybericht-, geheugen- en grote-payload-churn door het diagnostische eventpad
  • Vraagt diagnostics.stability op via de Gateway WS RPC
  • Dekt persistentiehelpers voor diagnostische stabiliteitsbundels
  • Assert dat de recorder begrensd blijft, synthetische RSS-samples onder het drukbudget blijven en wachtrijdiepten per sessie terug naar nul leeglopen
• Verwachtingen:
  • CI-veilig en zonder sleutels
  • Smalle baan voor opvolging van stabiliteitsregressies, geen vervanging voor de volledige Gateway-suite

​

E2E (Gateway-smoke)

• Commando: pnpm test:e2e
• Configuratie: vitest.e2e.config.ts
• Bestanden: src/**/*.e2e.test.ts, test/**/*.e2e.test.ts en E2E-tests voor gebundelde plugins onder extensions/
• Runtime-standaarden:
  • Gebruikt Vitest threads met isolate: false, passend bij de rest van de repo.
  • Gebruikt adaptieve workers (CI: maximaal 2, lokaal: standaard 1).
  • Draait standaard in stille modus om console-I/O-overhead te verminderen.
• Handige overrides:
  • OPENCLAW_E2E_WORKERS=<n> om het aantal workers te forceren (afgetopt op 16).
  • OPENCLAW_E2E_VERBOSE=1 om uitgebreide console-uitvoer opnieuw in te schakelen.
• Scope:
  • End-to-end-gedrag van gateways met meerdere instanties
  • WebSocket-/HTTP-oppervlakken, nodekoppeling en zwaardere netwerking
• Verwachtingen:
  • Draait in CI (wanneer ingeschakeld in de pipeline)
  • Geen echte sleutels vereist
  • Meer bewegende delen dan unit-tests (kan trager zijn)

​

E2E: OpenShell-backend-smoke

• Commando: pnpm test:e2e:openshell
• Bestand: extensions/openshell/src/backend.e2e.test.ts
• Scope:
  • Start een geïsoleerde OpenShell-gateway op de host via Docker
  • Maakt een sandbox vanuit een tijdelijk lokaal Dockerfile
  • Oefent OpenClaw’s OpenShell-backend via echte sandbox ssh-config + SSH exec
  • Verifieert remote-canoniek bestandssysteemgedrag via de sandbox-fs-bridge
• Verwachtingen:
  • Alleen opt-in; geen onderdeel van de standaard pnpm test:e2e-run
  • Vereist een lokale openshell-CLI plus een werkende Docker-daemon
  • Gebruikt geïsoleerde HOME / XDG_CONFIG_HOME en vernietigt daarna de testgateway en sandbox
• Handige overrides:
  • OPENCLAW_E2E_OPENSHELL=1 om de test in te schakelen wanneer je de bredere e2e-suite handmatig draait
  • OPENCLAW_E2E_OPENSHELL_COMMAND=/path/to/openshell om naar een niet-standaard CLI-binary of wrapperscript te wijzen

​

Live (echte providers + echte modellen)

• Opdracht: pnpm test:live
• Configuratie: vitest.live.config.ts
• Bestanden: src/**/*.live.test.ts, test/**/*.live.test.ts en livetests voor gebundelde Plugins onder extensions/
• Standaard: ingeschakeld door pnpm test:live (stelt OPENCLAW_LIVE_TEST=1 in)
• Scope:
  • “Werkt deze provider/dit model vandaag echt met echte referenties?”
  • Vang providerformaatwijzigingen, eigenaardigheden bij tool-calling, authenticatieproblemen en gedrag rond snelheidslimieten op
• Verwachtingen:
  • Niet CI-stabiel naar ontwerp (echte netwerken, echt providerbeleid, quota, storingen)
  • Kost geld / gebruikt snelheidslimieten
  • Geef de voorkeur aan beperkte subsets in plaats van “alles”
• Live-runs sourcen ~/.profile om ontbrekende API-sleutels op te halen.
• Standaard isoleren live-runs nog steeds HOME en kopiëren ze configuratie-/authenticatiemateriaal naar een tijdelijke test-home, zodat unit-fixtures je echte ~/.openclaw niet kunnen muteren.
• Stel OPENCLAW_LIVE_USE_REAL_HOME=1 alleen in wanneer je bewust wilt dat livetests je echte home-directory gebruiken.
• pnpm test:live gebruikt nu standaard een stillere modus: het behoudt [live] ...-voortgangsuitvoer, maar onderdrukt de extra ~/.profile-melding en dempt Gateway-bootstraplogs/Bonjour-ruis. Stel OPENCLAW_LIVE_TEST_QUIET=0 in als je de volledige opstartlogs terug wilt.
• API-sleutelrotatie (provider-specifiek): stel *_API_KEYS in met komma-/puntkommaformaat of *_API_KEY_1, *_API_KEY_2 (bijvoorbeeld OPENAI_API_KEYS, ANTHROPIC_API_KEYS, GEMINI_API_KEYS) of per-live-override via OPENCLAW_LIVE_*_KEY; tests proberen opnieuw bij snelheidslimietreacties.
• Voortgangs-/Heartbeat-uitvoer:
  • Livesuites sturen nu voortgangsregels naar stderr, zodat lange providercalls zichtbaar actief zijn, zelfs wanneer Vitest-consolecapturing stil is.
  • vitest.live.config.ts schakelt Vitest-console-interceptie uit, zodat provider-/Gateway-voortgangsregels tijdens live-runs direct streamen.
  • Stem direct-model-Heartbeats af met OPENCLAW_LIVE_HEARTBEAT_MS.
  • Stem Gateway-/probe-Heartbeats af met OPENCLAW_LIVE_GATEWAY_HEARTBEAT_MS.

​

Welke suite moet ik draaien?

• Logica/tests bewerken: draai pnpm test (en pnpm test:coverage als je veel hebt gewijzigd)
• Gateway-netwerken / WS-protocol / koppeling aanraken: voeg pnpm test:e2e toe
• “mijn bot is offline” / provider-specifieke fouten / tool-calling debuggen: draai een beperkte pnpm test:live

​

Live (netwerk aanrakende) tests

​

Docker-runners (optionele controles “werkt in Linux”)

• Live-model-runners: test:docker:live-models en test:docker:live-gateway draaien alleen hun bijpassende profile-key-livebestand binnen de repo-Docker-image (src/agents/models.profiles.live.test.ts en src/gateway/gateway-models.profiles.live.test.ts), waarbij je lokale configdirectory en workspace worden gemount (en ~/.profile wordt gesourced als die is gemount). De bijpassende lokale entrypoints zijn test:live:models-profiles en test:live:gateway-profiles.
• Docker-live-runners gebruiken standaard een kleinere smoke-limiet, zodat een volledige Docker-sweep praktisch blijft: test:docker:live-models gebruikt standaard OPENCLAW_LIVE_MAX_MODELS=12, en test:docker:live-gateway gebruikt standaard OPENCLAW_LIVE_GATEWAY_SMOKE=1, OPENCLAW_LIVE_GATEWAY_MAX_MODELS=8, OPENCLAW_LIVE_GATEWAY_STEP_TIMEOUT_MS=45000 en OPENCLAW_LIVE_GATEWAY_MODEL_TIMEOUT_MS=90000. Overschrijf die env-vars wanneer je expliciet de grotere uitputtende scan wilt.
• test:docker:all bouwt de live Docker-image eenmaal via test:docker:live-build, verpakt OpenClaw eenmaal als npm-tarball via scripts/package-openclaw-for-docker.mjs en bouwt/hergebruikt daarna twee scripts/e2e/Dockerfile-images. De kale image is alleen de Node/Git-runner voor install/update/plugin-dependency-lanes; die lanes mounten de vooraf gebouwde tarball. De functionele image installeert dezelfde tarball in /app voor built-app-functionaliteitslanes. Docker-lanedefinities staan in scripts/lib/docker-e2e-scenarios.mjs; plannerlogica staat in scripts/lib/docker-e2e-plan.mjs; scripts/test-docker-all.mjs voert het geselecteerde plan uit. De aggregatie gebruikt een gewogen lokale scheduler: OPENCLAW_DOCKER_ALL_PARALLELISM beheert processlots, terwijl resourceplafonds voorkomen dat zware live-, npm-install- en multi-service-lanes allemaal tegelijk starten. Als één lane zwaarder is dan de actieve plafonds, kan de scheduler die alsnog starten wanneer de pool leeg is en hem daarna alleen laten draaien totdat er weer capaciteit beschikbaar is. Standaarden zijn 10 slots, OPENCLAW_DOCKER_ALL_LIVE_LIMIT=9, OPENCLAW_DOCKER_ALL_NPM_LIMIT=10 en OPENCLAW_DOCKER_ALL_SERVICE_LIMIT=7; stem OPENCLAW_DOCKER_ALL_WEIGHT_LIMIT of OPENCLAW_DOCKER_ALL_DOCKER_LIMIT alleen af wanneer de Docker-host meer ruimte heeft. De runner voert standaard een Docker-preflight uit, verwijdert verouderde OpenClaw E2E-containers, print elke 30 seconden status, slaat timings van succesvolle lanes op in .artifacts/docker-tests/lane-timings.json en gebruikt die timings om bij latere runs langere lanes eerst te starten. Gebruik OPENCLAW_DOCKER_ALL_DRY_RUN=1 om het gewogen lanemanifest te printen zonder Docker te bouwen of te draaien, of node scripts/test-docker-all.mjs --plan-json om het CI-plan voor geselecteerde lanes, pakket-/imagebehoeften en referenties te printen.
• Package Acceptance is de GitHub-native pakketpoort voor “werkt deze installeerbare tarball als product?” Het lost één kandidaatpakket op uit source=npm, source=ref, source=url of source=artifact, uploadt dit als package-under-test en draait daarna de herbruikbare Docker E2E-lanes tegen exact die tarball in plaats van de geselecteerde ref opnieuw te verpakken. Profielen zijn geordend op breedte: smoke, package, product en full. Zie Updates en Plugins testen voor het pakket-/update-/Plugin-contract, de published-upgrade-survivor-matrix, release-standaarden en fouttriage.
• Build- en releasecontroles draaien scripts/check-cli-bootstrap-imports.mjs na tsdown. De guard doorloopt de statische gebouwde graph vanaf dist/entry.js en dist/cli/run-main.js en faalt als pre-dispatch-opstart pakketdependencies zoals Commander, prompt-UI, undici of logging vóór commandodispatch importeert; hij houdt ook de gebundelde Gateway-run-chunk binnen budget en wijst statische imports van bekende koude Gateway-paden af. Packaged CLI-smoke dekt ook root help, onboard help, doctor help, status, config-schema en een model-list-opdracht.
• Legacy-compatibiliteit van Package Acceptance is begrensd op 2026.4.25 (2026.4.25-beta.* inbegrepen). Tot en met die grens tolereert de harness alleen metadatahiaten van verzonden pakketten: weggelaten privé-QA-inventarisitems, ontbrekende gateway install --wrapper, ontbrekende patchbestanden in de van tarball afgeleide git-fixture, ontbrekende persistente update.channel, verouderde locaties voor Plugin-install-records, ontbrekende persistente marketplace-install-records en configuratiemetadata-migratie tijdens plugins update. Voor pakketten na 2026.4.25 zijn die paden strikte fouten.
• Container-smoke-runners: test:docker:openwebui, test:docker:onboard, test:docker:npm-onboard-channel-agent, test:docker:skill-install, test:docker:update-channel-switch, test:docker:upgrade-survivor, test:docker:published-upgrade-survivor, test:docker:session-runtime-context, test:docker:agents-delete-shared-workspace, test:docker:gateway-network, test:docker:browser-cdp-snapshot, test:docker:mcp-channels, test:docker:pi-bundle-mcp-tools, test:docker:cron-mcp-cleanup, test:docker:plugins, test:docker:plugin-update, test:docker:plugin-lifecycle-matrix en test:docker:config-reload starten een of meer echte containers en verifiëren integratiepaden op hoger niveau.

• Directe modellen: pnpm test:docker:live-models (script: scripts/test-live-models-docker.sh)
• ACP-bind-smoke: pnpm test:docker:live-acp-bind (script: scripts/test-live-acp-bind-docker.sh; dekt standaard Claude, Codex en Gemini, met strikte Droid/OpenCode-dekking via pnpm test:docker:live-acp-bind:droid en pnpm test:docker:live-acp-bind:opencode)
• CLI-backend-smoke: pnpm test:docker:live-cli-backend (script: scripts/test-live-cli-backend-docker.sh)
• Codex app-server-harness-smoke: pnpm test:docker:live-codex-harness (script: scripts/test-live-codex-harness-docker.sh)
• Gateway + dev-agent: pnpm test:docker:live-gateway (script: scripts/test-live-gateway-models-docker.sh)
• Observability-smoke: pnpm qa:otel:smoke is een private QA-broncheckout-lane. Deze maakt bewust geen deel uit van Docker-release-lanes voor pakketten, omdat de npm-tarball QA Lab weglaat.
• Open WebUI live-smoke: pnpm test:docker:openwebui (script: scripts/e2e/openwebui-docker.sh)
• Onboardingwizard (TTY, volledige scaffolding): pnpm test:docker:onboard (script: scripts/e2e/onboard-docker.sh)
• Npm-tarball onboarding/kanaal/agent-smoke: pnpm test:docker:npm-onboard-channel-agent installeert de ingepakte OpenClaw-tarball globaal in Docker, configureert OpenAI via env-ref-onboarding plus standaard Telegram, voert doctor uit en voert één gemockte OpenAI-agentbeurt uit. Hergebruik een vooraf gebouwde tarball met OPENCLAW_CURRENT_PACKAGE_TGZ=/path/to/openclaw-*.tgz, sla de host-rebuild over met OPENCLAW_NPM_ONBOARD_HOST_BUILD=0, of wissel van kanaal met OPENCLAW_NPM_ONBOARD_CHANNEL=discord of OPENCLAW_NPM_ONBOARD_CHANNEL=slack.
• Skill-install-smoke: pnpm test:docker:skill-install installeert de ingepakte OpenClaw-tarball globaal in Docker, schakelt geüploade archiefinstallaties uit in de configuratie, lost de huidige live ClawHub-skill-slug op vanuit zoeken, installeert deze met openclaw skills install en verifieert de geïnstalleerde skill plus .clawhub-origin/lock-metadata.
• Updatekanaalwissel-smoke: pnpm test:docker:update-channel-switch installeert de ingepakte OpenClaw-tarball globaal in Docker, schakelt over van pakket stable naar git dev, verifieert dat het vastgelegde kanaal en Plugin-post-update werken, schakelt daarna terug naar pakket stable en controleert de updatestatus.
• Upgrade-survivor-smoke: pnpm test:docker:upgrade-survivor installeert de ingepakte OpenClaw-tarball over een vervuilde old-user-fixture met agents, kanaalconfiguratie, Plugin-allowlists, verouderde Plugin-afhankelijkheidsstatus en bestaande workspace-/sessiebestanden. Het voert package update plus niet-interactieve doctor uit zonder live provider- of kanaalsleutels, start daarna een loopback-Gateway en controleert behoud van configuratie/status plus startup-/statusbudgetten.
• Published upgrade survivor-smoke: pnpm test:docker:published-upgrade-survivor installeert standaard openclaw@latest, seedt realistische existing-user-bestanden, configureert die baseline met een ingebakken opdrachtrecept, valideert de resulterende configuratie, werkt die gepubliceerde installatie bij naar de kandidaat-tarball, voert niet-interactieve doctor uit, schrijft .artifacts/upgrade-survivor/summary.json, start daarna een loopback-Gateway en controleert geconfigureerde intents, statusbehoud, startup, /healthz, /readyz en RPC-statusbudgetten. Overschrijf één baseline met OPENCLAW_UPGRADE_SURVIVOR_BASELINE_SPEC, vraag de aggregate scheduler om exacte lokale baselines uit te vouwen met OPENCLAW_UPGRADE_SURVIVOR_BASELINE_SPECS zoals openclaw@2026.5.2 openclaw@2026.4.23 openclaw@2026.4.15, en vouw issue-vormige fixtures uit met OPENCLAW_UPGRADE_SURVIVOR_SCENARIOS zoals reported-issues; de set reported-issues bevat configured-plugin-installs voor automatische reparatie van externe OpenClaw-Plugin-installaties. Package Acceptance stelt deze beschikbaar als published_upgrade_survivor_baseline, published_upgrade_survivor_baselines en published_upgrade_survivor_scenarios, lost meta-baseline-tokens op zoals last-stable-4 of all-since-2026.4.23, en Full Release Validation breidt de release-soak package-gate uit naar last-stable-4 2026.4.23 2026.5.2 2026.4.15 plus reported-issues.
• Session runtime context-smoke: pnpm test:docker:session-runtime-context verifieert transcriptpersistentie van verborgen runtimecontext plus doctor-reparatie van getroffen gedupliceerde prompt-rewrite-branches.
• Bun globale installatie-smoke: bash scripts/e2e/bun-global-install-smoke.sh pakt de huidige tree in, installeert deze met bun install -g in een geïsoleerde home en verifieert dat openclaw infer image providers --json gebundelde image providers retourneert in plaats van te blijven hangen. Hergebruik een vooraf gebouwde tarball met OPENCLAW_BUN_GLOBAL_SMOKE_PACKAGE_TGZ=/path/to/openclaw-*.tgz, sla de host-build over met OPENCLAW_BUN_GLOBAL_SMOKE_HOST_BUILD=0, of kopieer dist/ uit een gebouwde Docker-image met OPENCLAW_BUN_GLOBAL_SMOKE_DIST_IMAGE=openclaw-dockerfile-smoke:local.
• Installer Docker-smoke: bash scripts/test-install-sh-docker.sh deelt één npm-cache tussen de root-, update- en direct-npm-containers. Update-smoke gebruikt standaard npm latest als de stable baseline voordat naar de kandidaat-tarball wordt geüpgraded. Overschrijf lokaal met OPENCLAW_INSTALL_SMOKE_UPDATE_BASELINE=2026.4.22, of met de update_baseline_version-input van de Install Smoke-workflow op GitHub. Niet-root-installercontroles houden een geïsoleerde npm-cache aan, zodat root-eigendom-cache-items lokaal installatiegedrag van gebruikers niet maskeren. Stel OPENCLAW_INSTALL_SMOKE_NPM_CACHE_DIR=/path/to/cache in om de root/update/direct-npm-cache opnieuw te gebruiken bij lokale reruns.
• Install Smoke CI slaat de dubbele direct-npm globale update over met OPENCLAW_INSTALL_SMOKE_SKIP_NPM_GLOBAL=1; voer het script lokaal uit zonder die env wanneer directe npm install -g-dekking nodig is.
• Agents verwijderen gedeelde workspace CLI-smoke: pnpm test:docker:agents-delete-shared-workspace (script: scripts/e2e/agents-delete-shared-workspace-docker.sh) bouwt standaard de root-Dockerfile-image, seedt twee agents met één workspace in een geïsoleerde container-home, voert agents delete --json uit en verifieert geldige JSON plus behoud van workspace-gedrag. Hergebruik de install-smoke-image met OPENCLAW_AGENTS_DELETE_SHARED_WORKSPACE_E2E_IMAGE=openclaw-dockerfile-smoke:local OPENCLAW_AGENTS_DELETE_SHARED_WORKSPACE_E2E_SKIP_BUILD=1.
• Gateway-netwerken (twee containers, WS-auth + health): pnpm test:docker:gateway-network (script: scripts/e2e/gateway-network-docker.sh)
• Browser CDP-snapshot-smoke: pnpm test:docker:browser-cdp-snapshot (script: scripts/e2e/browser-cdp-snapshot-docker.sh) bouwt de source E2E-image plus een Chromium-laag, start Chromium met raw CDP, voert browser doctor --deep uit en verifieert dat CDP-rolsnapshots link-URL’s, cursor-gepromote clickables, iframe-refs en frame-metadata dekken.
• OpenAI Responses web_search minimal reasoning-regressie: pnpm test:docker:openai-web-search-minimal (script: scripts/e2e/openai-web-search-minimal-docker.sh) voert een gemockte OpenAI-server via Gateway uit, verifieert dat web_search reasoning.effort verhoogt van minimal naar low, forceert daarna de provider schema reject en controleert dat de ruwe details in Gateway-logs verschijnen.
• MCP-kanaalbrug (geseedde Gateway + stdio-brug + raw Claude notification-frame-smoke): pnpm test:docker:mcp-channels (script: scripts/e2e/mcp-channels-docker.sh)
• Pi-bundel MCP-tools (echte stdio MCP-server + ingebed Pi-profiel allow/deny-smoke): pnpm test:docker:pi-bundle-mcp-tools (script: scripts/e2e/pi-bundle-mcp-tools-docker.sh)
• Cron/subagent MCP-cleanup (echte Gateway + teardown van stdio MCP-child na geïsoleerde Cron- en eenmalige subagent-runs): pnpm test:docker:cron-mcp-cleanup (script: scripts/e2e/cron-mcp-cleanup-docker.sh)
• Plugins (install/update-smoke voor lokaal pad, file:, npm-registry met gehoiste afhankelijkheden, git moving refs, ClawHub kitchen-sink, marketplace-updates en Claude-bundel enable/inspect): pnpm test:docker:plugins (script: scripts/e2e/plugins-docker.sh) Stel OPENCLAW_PLUGINS_E2E_CLAWHUB=0 in om het ClawHub-blok over te slaan, of overschrijf het standaard kitchen-sink package/runtime-paar met OPENCLAW_PLUGINS_E2E_CLAWHUB_SPEC en OPENCLAW_PLUGINS_E2E_CLAWHUB_ID. Zonder OPENCLAW_CLAWHUB_URL/CLAWHUB_URL gebruikt de test een hermetische lokale ClawHub-fixture-server.
• Plugin-update ongewijzigd-smoke: pnpm test:docker:plugin-update (script: scripts/e2e/plugin-update-unchanged-docker.sh)
• Plugin-lifecycle-matrix-smoke: pnpm test:docker:plugin-lifecycle-matrix installeert de ingepakte OpenClaw-tarball in een bare container, installeert een npm-Plugin, schakelt enable/disable, upgrade en downgrade deze via een lokale npm-registry, verwijdert de geïnstalleerde code en verifieert daarna dat uninstall nog steeds verouderde status verwijdert terwijl RSS/CPU-metrics voor elke lifecycle-fase worden gelogd.
• Config reload metadata-smoke: pnpm test:docker:config-reload (script: scripts/e2e/config-reload-source-docker.sh)
• Plugins: pnpm test:docker:plugins dekt install/update-smoke voor lokaal pad, file:, npm-registry met gehoiste afhankelijkheden, git moving refs, ClawHub-fixtures, marketplace-updates en Claude-bundel enable/inspect. pnpm test:docker:plugin-update dekt ongewijzigd updategedrag voor geïnstalleerde plugins. pnpm test:docker:plugin-lifecycle-matrix dekt resource-getrackte npm-Plugin-installatie, enable, disable, upgrade, downgrade en missing-code uninstall.

OPENCLAW_DOCKER_E2E_IMAGE=openclaw-docker-e2e-functional:local pnpm test:docker:e2e-build
OPENCLAW_DOCKER_E2E_IMAGE=openclaw-docker-e2e-functional:local OPENCLAW_SKIP_DOCKER_BUILD=1 pnpm test:docker:mcp-channels

• bun scripts/dev/discord-acp-plain-language-smoke.ts --channel <discord-channel-id> ...
• Bewaar dit script voor regressie-/debugworkflows. Het kan opnieuw nodig zijn voor ACP-threadrouteringsvalidatie, dus verwijder het niet.

• OPENCLAW_CONFIG_DIR=... (standaard: ~/.openclaw) gekoppeld aan /home/node/.openclaw
• OPENCLAW_WORKSPACE_DIR=... (standaard: ~/.openclaw/workspace) gekoppeld aan /home/node/.openclaw/workspace
• OPENCLAW_PROFILE_FILE=... (standaard: ~/.profile) gekoppeld aan /home/node/.profile en gesourced voordat tests worden uitgevoerd
• OPENCLAW_DOCKER_PROFILE_ENV_ONLY=1 om alleen env vars te verifiëren die uit OPENCLAW_PROFILE_FILE worden gesourced, met tijdelijke config-/workspacedirectories en zonder externe CLI-auth-mounts
• OPENCLAW_DOCKER_CLI_TOOLS_DIR=... (standaard: ~/.cache/openclaw/docker-cli-tools) gekoppeld aan /home/node/.npm-global voor gecachte CLI-installaties binnen Docker
• Externe CLI-authdirs/-bestanden onder $HOME worden read-only gekoppeld onder /host-auth..., en daarna naar /home/node/... gekopieerd voordat tests starten
  • Standaarddirs: .minimax
  • Standaardbestanden: ~/.codex/auth.json, ~/.codex/config.toml, .claude.json, ~/.claude/.credentials.json, ~/.claude/settings.json, ~/.claude/settings.local.json
  • Beperkte providerruns koppelen alleen de benodigde dirs/bestanden die worden afgeleid uit OPENCLAW_LIVE_PROVIDERS / OPENCLAW_LIVE_GATEWAY_PROVIDERS
  • Handmatig overschrijven met OPENCLAW_DOCKER_AUTH_DIRS=all, OPENCLAW_DOCKER_AUTH_DIRS=none, of een kommagescheiden lijst zoals OPENCLAW_DOCKER_AUTH_DIRS=.claude,.codex
• OPENCLAW_LIVE_GATEWAY_MODELS=... / OPENCLAW_LIVE_MODELS=... om de run te beperken
• OPENCLAW_LIVE_GATEWAY_PROVIDERS=... / OPENCLAW_LIVE_PROVIDERS=... om providers in de container te filteren
• OPENCLAW_SKIP_DOCKER_BUILD=1 om een bestaande openclaw:local-live-image opnieuw te gebruiken voor reruns die geen rebuild nodig hebben
• OPENCLAW_LIVE_REQUIRE_PROFILE_KEYS=1 om te garanderen dat credentials uit de profielstore komen (niet uit env)
• OPENCLAW_OPENWEBUI_MODEL=... om het model te kiezen dat door de Gateway voor de Open WebUI-smoke wordt geëxposeerd
• OPENCLAW_OPENWEBUI_PROMPT=... om de nonce-checkprompt te overschrijven die door de Open WebUI-smoke wordt gebruikt
• OPENWEBUI_IMAGE=... om de gepinde Open WebUI-imagetag te overschrijven

​

Docs-sanity

​

Offline regressie (CI-veilig)

• Gateway-toolaanroepen (mock OpenAI, echte Gateway + agentloop): src/gateway/gateway.test.ts (case: “runs a mock OpenAI tool call end-to-end via gateway agent loop”)
• Gateway-wizard (WS wizard.start/wizard.next, schrijft config + auth afgedwongen): src/gateway/gateway.test.ts (case: “runs wizard over ws and writes auth token config”)

​

Agent-betrouwbaarheidsevals (Skills)

• Mock-toolaanroepen via de echte Gateway + agentloop (src/gateway/gateway.test.ts).
• End-to-end wizardflows die sessiebedrading en configeffecten valideren (src/gateway/gateway.test.ts).

• Besluitvorming: wanneer Skills in de prompt worden vermeld, kiest de agent dan de juiste skill (of vermijdt hij irrelevante)?
• Naleving: leest de agent SKILL.md vóór gebruik en volgt hij de vereiste stappen/args?
• Workflowcontracten: multi-turnscenario’s die toolvolgorde, overdracht van sessiegeschiedenis en sandboxgrenzen afdwingen.

• Een scenariorunner die mockproviders gebruikt om toolaanroepen + volgorde, skillbestandsreads en sessiebedrading te controleren.
• Een kleine suite van skillgerichte scenario’s (gebruiken vs vermijden, gating, promptinjectie).
• Optionele live-evals (opt-in, env-gated) pas nadat de CI-veilige suite aanwezig is.

​

Contracttests (Plugin- en channelvorm)

​

Commando’s

• Alle contracten: pnpm test:contracts
• Alleen channelcontracten: pnpm test:contracts:channels
• Alleen providercontracten: pnpm test:contracts:plugins

​

Channelcontracten

• plugin - Basis-Pluginvorm (id, naam, capabilities)
• setup - Setupwizardcontract
• session-binding - Gedrag van sessiebinding
• outbound-payload - Berichtpayloadstructuur
• inbound - Afhandeling van inkomende berichten
• actions - Channel-actionhandlers
• threading - Afhandeling van thread-ID’s
• directory - Directory/roster-API
• group-policy - Handhaving van groepsbeleid

​

Providerstatuscontracten

• status - Channelstatusprobes
• registry - Vorm van Pluginregistry

​

Providercontracten

• auth - Auth-flowcontract
• auth-choice - Auth-keuze/selectie
• catalog - Modelcatalogus-API
• discovery - Pluginontdekking
• loader - Pluginladen
• runtime - Providerruntime
• shape - Pluginvorm/interface
• wizard - Setupwizard

​

Wanneer uitvoeren

• Na het wijzigen van plugin-sdk-exports of subpaths
• Na het toevoegen of wijzigen van een channel- of provider-Plugin
• Na het refactoren van Pluginregistratie of -ontdekking

​

Regressies toevoegen (richtlijn)

• Voeg indien mogelijk een CI-veilige regressie toe (mock-/stubprovider, of leg de exacte transformatie van de requestvorm vast)
• Als het inherent live-only is (rate limits, authbeleid), houd de livetest dan smal en opt-in via env vars
• Richt je bij voorkeur op de kleinste laag die de bug vangt:
  • provider-requestconversie-/replaybug → directe modeltest
  • Gateway-sessie-/geschiedenis-/toolpipelinebug → Gateway-live-smoke of CI-veilige Gateway-mocktest
• SecretRef-traversalguardrail:
  • src/secrets/exec-secret-ref-id-parity.test.ts leidt één gesampled target per SecretRef-klasse af uit registrymetadata (listSecretTargetRegistryEntries()), en assert daarna dat exec-id’s met traversal-segmenten worden geweigerd.
  • Als je een nieuwe includeInPlan SecretRef-targetfamilie toevoegt in src/secrets/target-registry-data.ts, werk dan classifyTargetClass in die test bij. De test faalt bewust op niet-geclassificeerde target-id’s, zodat nieuwe klassen niet stilzwijgend kunnen worden overgeslagen.

​

Gerelateerd

• Live testen
• Updates en plugins testen
• CI