Migration von ApplitoolsFrüher Zugang

Eine Playwright-Suite von Applitools Eyes zu Delta-QA migrieren

Eine für Applitools Eyes geschriebene Playwright-Suite läuft nach zwei Änderungen auf Delta-QA: ihrem Import und ihren Umgebungsvariablen. Ihre eyes.open, check, close, BatchInfo, addBrowser und Regionen bleiben.

Installieren und den Import ändern

Die Eyes-API von @delta-qa/vision übernimmt die Namen und die Bedeutung von Applitools Eyes für Playwright. Sie erfordert Node.js 22 oder höher und @playwright/test 1.62 oder höher.

Das Vision SDK ist zunächst im frühen Zugang verfügbar: Kontaktieren Sie uns, um es mit Ihrer Suite zu nutzen. Zugang zu Vision anfragen

Applitools	Delta-QA
`import { test } from "@applitools/eyes-playwright/fixture";`	`import { test } from "@delta-qa/vision/eyes/fixture";`
`import type { EyesFixture } from "@applitools/eyes-playwright/fixture";`	`import type { EyesFixture } from "@delta-qa/vision/eyes/fixture";`
`import { Eyes, Target, … } from "@applitools/eyes-playwright";`	`import { Eyes, Target, … } from "@delta-qa/vision/eyes";`

eyesConfig in playwright.config bleibt unverändert. Mit der Fixture ändert ein Test nur seinen Import:

// import { test } from "@applitools/eyes-playwright/fixture";
import { test } from "@delta-qa/vision/eyes/fixture";

test("checkout", async ({ page, eyes }) => {
  await page.goto("https://shop.example/cart");
  await eyes.check("Cart", { fully: true });
}); // opened before the test, closed by the fixture

Die Umgebungsvariablen setzen

Variable	Gelesen für
`DELTAQA_API_KEY`	Der API-Schlüssel Ihres Delta-QA-Arbeitsbereichs (`dqa_…`) mit der Rolle „Can edit“, erstellt unter Settings → Workspace → API keys. Legen Sie ihn als Secret in Ihrer CI ab.
`APPLITOOLS_API_KEY`	Gelesen, wenn `DELTAQA_API_KEY` nicht gesetzt ist: Behalten Sie die Variable und geben Sie ihr einen Delta-QA-Schlüssel.
`DELTAQA_SERVER_URL`	Ihr Delta-QA-Server, bei einer On-Premise-Installation; die Delta-QA-Cloud, wenn nicht gesetzt. `APPLITOOLS_SERVER_URL` wird nie gelesen.
`APPLITOOLS_BATCH_ID`	Die getestete Version — der Commit. Die im Code angegebene Batch-`id` hat Vorrang.
`APPLITOOLS_BRANCH`	Der Branch. `setBranchName` im Code hat Vorrang.
`APPLITOOLS_PARENT_BRANCH` `APPLITOOLS_BASELINE_BRANCH`	Der Basis-Branch, dessen Referenz verwendet wird, solange der Branch keine hat. `APPLITOOLS_BASELINE_BRANCH` hat Vorrang vor `APPLITOOLS_PARENT_BRANCH`; der Code hat Vorrang vor beiden.

Die _NAME-Formen der Branch-Variablen (APPLITOOLS_BRANCH_NAME, APPLITOOLS_PARENT_BRANCH_NAME, APPLITOOLS_BASELINE_BRANCH_NAME) werden ebenfalls gelesen. Eine leere Variable zählt als nicht gesetzt. Ohne Schlüssel schlägt das Öffnen eines Tests fehl und nennt die zu setzende Variable.

Diese Applitools-Variablen werden nicht gelesen und lösen keine Warnung aus: APPLITOOLS_SERVER_URL, APPLITOOLS_BATCH_NAME, APPLITOOLS_DONT_CLOSE_BATCHES, APPLITOOLS_SHOW_LOGS.

Ihre CI konfigurieren

Das SDK liest weder Git noch die Variablen Ihrer CI: Die folgenden Zeilen setzen daraus Branch, Basis-Branch und Commit in die drei Applitools-Variablen.

GitHub Actions

Bei einem Push ist github.head_ref leer: Der Branch ist dann github.ref_name. Bei einem Pull Request ist github.sha der Merge-Commit, den GitHub erzeugt, nicht der gepushte Commit: Der Head-Commit hat Vorrang.

env:
  APPLITOOLS_BRANCH: ${{ github.head_ref || github.ref_name }}
  APPLITOOLS_PARENT_BRANCH: ${{ github.base_ref || github.event.repository.default_branch }}
  APPLITOOLS_BATCH_ID: ${{ github.event.pull_request.head.sha || github.sha }}

GitLab CI

In einer Merge-Request-Pipeline ist CI_MERGE_REQUEST_TARGET_BRANCH_NAME der Ziel-Branch; in einer Branch-Pipeline ist sie leer.

script:
  - export APPLITOOLS_BRANCH="${CI_MERGE_REQUEST_SOURCE_BRANCH_NAME:-$CI_COMMIT_REF_NAME}"
  - export APPLITOOLS_PARENT_BRANCH="${CI_MERGE_REQUEST_TARGET_BRANCH_NAME:-$CI_DEFAULT_BRANCH}"
  - export APPLITOOLS_BATCH_ID="$CI_COMMIT_SHA"
  - npx playwright test

Bitbucket Pipelines

BITBUCKET_PR_DESTINATION_BRANCH ist nur in einer Pull-Request-Pipeline gesetzt.

script:
  - export APPLITOOLS_BRANCH="$BITBUCKET_BRANCH"
  - export APPLITOOLS_PARENT_BRANCH="$BITBUCKET_PR_DESTINATION_BRANCH"
  - export APPLITOOLS_BATCH_ID="$BITBUCKET_COMMIT"
  - npx playwright test

Azure Pipelines

Die System.PullRequest-Variablen sind nur bei einem Pull-Request-Build gesetzt, für Azure Repos als refs/heads/…. Build.SourceBranchName behält nur das letzte Segment eines Branches (feature/cart ergibt cart), daher wird der Branch aus der vollständigen Ref gelesen.

- script: |
    branch="${SYSTEM_PULLREQUEST_SOURCEBRANCH:-$BUILD_SOURCEBRANCH}"
    base="${SYSTEM_PULLREQUEST_TARGETBRANCH:-}"
    export APPLITOOLS_BRANCH="${branch#refs/heads/}"
    export APPLITOOLS_PARENT_BRANCH="${base#refs/heads/}"
    export APPLITOOLS_BATCH_ID="${SYSTEM_PULLREQUEST_SOURCECOMMITID:-$BUILD_SOURCEVERSION}"
    npx playwright test

Ein Basis-Branch, der dem Branch entspricht, wird nicht verwendet: Auf dem Standard-Branch ergeben diese Zeilen keine Basis.

Im Teardown schließen, nie im Testkörper

Mit der Fixture wird eyes im Teardown des Tests geschlossen. Ohne sie rufen Sie eyes.close() in einem afterEach auf und runner.getAllTestResults() in einem afterAll.

Schließen Sie nie im Körper des Tests: Das Warten auf das Urteil kostet die Zeit des Tests — standardmäßig 30 Sekunden in Playwright Test —, und ein Schritt, der vor close() fehlschlägt, lässt den Test offen. Der Teardown hat sein eigenes Timeout.

import { test } from "@playwright/test";
import { Eyes, Target, VisualGridRunner } from "@delta-qa/vision/eyes";

const runner = new VisualGridRunner();
let eyes: Eyes;

test.beforeEach(async ({ page }) => {
  eyes = new Eyes(runner);
  await eyes.open(page, "Shop", test.info().title);
});
test("checkout", async ({ page }) => {
  await page.goto("https://shop.example/cart");
  await eyes.check("Cart", Target.window().fully());
});
test.afterEach(async () => {
  await eyes.close(); // throws DiffsFoundError when a difference awaits a judgment
});
test.afterAll(async () => {
  await runner.getAllTestResults();
});

Jede Applitools-Einstellung und was aus ihr wird

Jede Einstellung von Applitools Eyes wird akzeptiert: Die Suite kompiliert und läuft. Jede wird entweder von Delta-QA angewendet oder ohne Wirkung akzeptiert, mit einer Warnung. Einige wenige Aufrufe gibt es nicht.

Angewendet

Einstellung	In Delta-QA
`appName`	Die Anwendung des Tests; zusammen mit dem Testnamen identifiziert sie den Test. In `eyesConfig` `My App`, wenn nicht gesetzt, wie bei der Fixture von Applitools.
`testName`	Der Name des Tests, sein Schlüssel: Ein geänderter Name ist ein neuer Test. In `eyesConfig` kann er auch eine Funktion des Tests sein; ohne ihn der Titelpfad des Tests ohne seine Datei (`describe > test`), wie bei der Fixture von Applitools.
`apiKey` `setApiKey`	Der Schlüssel, anstelle von `DELTAQA_API_KEY` oder `APPLITOOLS_API_KEY` — ein Delta-QA-Schlüssel. Er erscheint nie in einer Meldung, einem Log oder einem Link.
`branchName`	Der Branch des Laufs; ohne ihn `APPLITOOLS_BRANCH`, dann `APPLITOOLS_BRANCH_NAME`.
`parentBranchName` `baselineBranchName`	Der Basis-Branch, `baselineBranchName` vor `parentBranchName`; ohne sie ihre Variablen, in derselben Reihenfolge.
`batch`	Seine `id` ist die getestete Version — der Commit; ohne sie `APPLITOOLS_BATCH_ID`; ohne beide eine Version pro Prozess (siehe die Abweichungen unten).
`saveNewTests`	Ob die Seiten eines neuen Tests zu seiner Referenz werden; `true`, wenn nicht gesetzt.
`viewportSize`	Die Größe, die der Seite beim Öffnen des Tests gegeben wird.
`browsersInfo` `addBrowser(width, height)`	Jede Größe ist eine Umgebung, für Chrome oder ohne Browsernamen. Sprache, Zeitzone, Theme und Bildschirmdichte werden im Browser des Tests gelesen.
`fully` `fully(true)`	Die ganze Seite — das, was Delta-QA ohnehin prüft.
`withName` `name`	Der Name des Checks.
`Target.window`	Die Seite des Tests.
`Target.region` `CheckSettings.region` `checkRegion` `checkRegionBy` `checkRegionByElement` `checkElement` `checkElementBy`	Der einzige verglichene Teil der Seite: das erste Element, das ein Locator, ein Selektor oder ein Element-Handle bezeichnet, wie bei Applitools; die zuletzt angegebene Region gewinnt. Die darin enthaltenen zu ignorierenden Regionen werden ausgelassen.
`ignoreRegions` `ignoreRegion` `ignore` `ignores`	Jedes Element, das eine Region bezeichnet — ein Locator, ein Selektor, `{ selector, type }`, ein Element-Handle —, wird vom Vergleich ausgenommen: jedes Element eines Locators, wie bei Applitools. Ebenso die Form `{ region }` und der Schlüssel `ignoreRegions` der Objektform.
`eyesConfig.failTestsOnDiff`	Wann ein Urteil, das nicht `PASSED` ist, in der Fixture scheitern lässt: `'afterEach'` lässt den Test in seinem Teardown scheitern; `'afterAll'` lässt den Worker scheitern, sobald seine Tests fertig sind; `false` lässt nichts scheitern, das Urteil wird trotzdem abgewartet. Ohne die Einstellung `'afterAll'`, wenn die Variable `CI` gesetzt ist, sonst `'afterEach'`, wie es der Code der Fixture von Applitools entscheidet.
`eyesConfig.afterAll`	Aufgerufen, sobald die Tests eines Workers fertig sind, mit dem Ergebnis jedes Tests.

Die Aufrufe

Aufruf	In Delta-QA
`open(page, appName, testName, viewportSize?)`	Der Test wird durch seine Anwendung und seinen Namen identifiziert: Ein geänderter Name ist ein neuer Test. Die Viewport-Größe wird der Seite gegeben.
`check(name?, Target.window())` `checkWindow(tag?)`	Prüft die Seite, wie sie ist, in jeder Umgebung. Ein Check ohne Namen wird über die Adresse seiner Seite zugeordnet; zwei Checks mit demselben Namen werden akzeptiert. Er antwortet mit einem `MatchResult` ohne Urteil, wie `check` bei Applitools: Das Urteil kommt beim Schließen.
`close(throwErr = true)`	Wartet auf das Urteil: `DiffsFoundError` bei einem zu beurteilenden Unterschied, `NewTestError` bei einem zu beurteilenden neuen Test (`saveNewTests(false)`), `TestFailedError` bei einem als Bug beurteilten Unterschied oder bei einem Fehlschlag. Die Meldung nennt den Link der Version in Delta-QA.
`closeAsync()` `runner.getAllTestResults(throwErr = true)`	`closeAsync()` schließt, ohne zu warten; der Runner wartet auf jedes Urteil, schließt einen offen gebliebenen Test und wirft bei einem, der nicht bestanden hat — der Fehler eines `closeAsync()` wird dafür aufbewahrt.
`abort()` `abortIfNotClosed()` `abortAsync()`	Schließt, ohne auf das Urteil zu warten, und lässt nichts scheitern: Die Ergebnisse werden als abgebrochen markiert, ohne Ergebnis; `null`, wenn kein Test offen ist. Delta-QA vergleicht die Läufe trotzdem, und die Version zeigt ihr Ergebnis.

Ohne Wirkung akzeptiert

Eine Einstellung, die Delta-QA nicht anwendet, lässt den Test nicht scheitern: Der Test läuft ohne sie. Ihre erste Verwendung in einem Prozess gibt eine Node.js-Warnung mit dem Code DELTAQA_IGNORED_SETTING aus, die sie nennt; spätere Verwendungen melden nichts mehr, und node --disable-warning=DELTAQA_IGNORED_SETTING schaltet sie stumm. Ein leerer Wert — setX(process.env.VARIABLE) außerhalb der CI — ist eine nicht angegebene Einstellung und löst keine Warnung aus. Die folgenden Namen sind die, die die Warnung nennt.

Vergleichseinstellungen

Match-Levels, Regionen nach Match-Level, Floating-Regionen und Verschiebungen justieren den Vergleich von Applitools. Delta-QA vergleicht die Seite so, wie es das menschliche Auge tun würde, ohne Toleranzstufe, die einzustellen wäre: Jeder Unterschied wird angezeigt, und eine Person beurteilt ihn in Delta-QA.

matchLevel
defaultMatchSettings
enablePatterns
ignoreDisplacements
ignoreCaret
useDom
sendDom
CheckSettings.matchLevel
CheckSettings.layout
CheckSettings.exact
CheckSettings.strict
CheckSettings.content
CheckSettings.ignoreColors
CheckSettings.dynamic
CheckSettings.enablePatterns
CheckSettings.ignoreDisplacements
CheckSettings.ignoreCaret
CheckSettings.ignoreMismatch
CheckSettings.useDom
CheckSettings.sendDom
CheckSettings.layoutRegion
CheckSettings.layoutRegions
CheckSettings.strictRegion
CheckSettings.strictRegions
CheckSettings.contentRegion
CheckSettings.contentRegions
CheckSettings.floating
CheckSettings.floatings
CheckSettings.floatingRegion
CheckSettings.floatingRegions
CheckSettings.dynamicRegion
CheckSettings.dynamicRegions

Screenshot-Einstellungen

Stitching, Scrollen, Zuschneiden, Warten und Debug-Screenshots formen den Screenshot von Applitools. Delta-QA prüft die ganze Seite so, wie der Test sie beim Aufruf von check hinterlassen hat: Um auf Inhalte zu warten oder einen per Lazy Loading geladenen Abschnitt zu laden, tun Sie das im Test, vor dem Check.

hideCaret
hideScrollbars
forceFullPageScreenshot
stitchMode
stitchOverlap
scrollRootElement
cut
rotation
waitBeforeScreenshots
waitBeforeCapture
matchTimeout
saveDebugScreenshots
debugScreenshotsPath
debugScreenshotsPrefix
fully(false)
CheckSettings.fully(false)
CheckSettings.scrollRootElement
CheckSettings.stitchMode
CheckSettings.timeout
CheckSettings.waitBeforeCapture
CheckSettings.lazyLoad
CheckSettings.useSystemScreenshot

Browser, Geräte und Umgebungen

Delta-QA rendert in Chromium: Es zählt die an addBrowser übergebene Größe, nicht der genannte Browser, daher sind zwei Browser derselben Größe eine Umgebung. Ein Gerät aus dem Grid von Applitools (DeviceName, IosDeviceName, Emulation, Multi-Device) fügt keine Umgebung hinzu. Sprache, Zeitzone, Theme und Bildschirmdichte werden im Browser des Tests gelesen, und Umgebungsbezeichnungen ändern nichts. ClassicRunner und VisualGridRunner verhalten sich gleich.

addBrowser(chrome-one-version-back)
addBrowser(chrome-two-versions-back)
addBrowser(firefox)
addBrowser(firefox-one-version-back)
addBrowser(firefox-two-versions-back)
addBrowser(safari)
addBrowser(safari-one-version-back)
addBrowser(safari-two-versions-back)
addBrowser(edgechromium)
addBrowser(edgechromium-one-version-back)
addBrowser(edgechromium-two-versions-back)
addBrowser(edgelegacy)
addBrowser(ie)
addBrowser(ie10)
addBrowser(device)
addDeviceEmulation
addMultiDeviceTarget
mobileOptions
captureStatusBar
layoutBreakpoints
CheckSettings.layoutBreakpoints
environmentName
envName
baselineEnvName
deviceInfo
hostApp
hostAppInfo
hostOS
hostOSInfo
scaleRatio
CheckSettings.densityMetrics
eyesConfig.type

Das Rendering-Grid von Applitools

Rendering-Optionen, Hooks, Abrufe, Caches und Parallelität des Grids von Applitools haben keine Entsprechung: Die Seite wird so geprüft, wie der Test sie hinterlassen hat. Ein Skript, das Sie in einem Hook ausgeführt haben, läuft im Test, vor dem Check.

visualGridOptions
CheckSettings.ufgOption
CheckSettings.ufgOptions
CheckSettings.visualGridOption
CheckSettings.visualGridOptions
CheckSettings.variationGroupId
CheckSettings.hook
CheckSettings.beforeRenderScreenshotHook
CheckSettings.webHook
disableBrowserFetching
CheckSettings.disableBrowserFetching
disableNMLUrlCache
autProxy
bypassCSP
skipRootHtmlResource
concurrentSessions
RunnerOptions.testConcurrency
RunnerOptions.fetchConcurrency
RunnerOptions.removeDuplicateTests

Batches, Referenzen und Ergebnisse

Eine Version trägt den Commit: Sie hat keinen Namen, keine Sequenz, keine Eigenschaften, keine Benachrichtigung und nichts zu schließen. Eine Referenz ändert sich nur, wenn eine Person einen Unterschied in Delta-QA beurteilt; ein Test ohne Referenz ist „Neu“. Checks werden über ihren Namen zugeordnet, sonst über die Adresse ihrer Seite. isDisabled: Ein Test, der ohne Check laufen soll, öffnet kein Eyes.

BatchInfo.name
BatchInfo.sequenceName
BatchInfo.startedAt
BatchInfo.notifyOnCompletion
BatchInfo.properties
BatchInfo.buildId
dontCloseBatches
BatchClose
properties
removeSession
saveDiffs
saveFailedTests
ignoreBaseline
displayName
sessionType
CheckSettings.pageId
isDisabled

Git

Das SDK liest kein Git: Geben Sie den Basis-Branch über parentBranchName oder baselineBranchName an und den Commit über die Batch-id oder APPLITOOLS_BATCH_ID.

compareWithParentBranch
ignoreGitMergeBase
gitMergeBaseTimestamp
latestCommitInfo

Server, Verbindung und Logs

Sie betreffen den Server von Applitools, seine Verbindung und seine Logs. Der Delta-QA-Server wird aus DELTAQA_SERVER_URL gelesen; das SDK schreibt kein Applitools-Log und sendet kein Applitools-Ereignis.

serverUrl
proxy
agentId
httpVersion
connectionTimeout
Eyes.on
Eyes.setLogHandler
Eyes.addSessionEventHandler
eyesConfig.logConfig
RunnerOptions.maskLog

Funktionen außerhalb von Delta-QA

Delta-QA validiert keine Barrierefreiheit, liest kein Figma und hat keinen Check in natürlicher Sprache; eine Playwright-Seite hat keine Web-View.

accessibilityValidation
CheckSettings.accessibilityRegion
CheckSettings.accessibilityRegions
figmaBaselines
figmaOptions
nlpOptions
Target.webview
CheckSettings.webview

Regionen ohne Element

Delta-QA erkennt die Elemente, die sich unterscheiden: Eine per Koordinaten angegebene Region ({ x, y, width, height }, { left, top, width, height }) hat keine Entsprechung: Die Seite wird ohne sie verglichen — vollständig bei Target.region. Die Zone ist das Element, ohne Padding; eine regionId benennt eine Region im Dashboard von Applitools. Mit Target.frame oder Target.shadow wird die Seite vollständig verglichen, und eine danach per Selektor angegebene Region lässt den Check mit einem TypeError scheitern: Eine Zone ist ein Element der Seite selbst.

CheckSettings.ignoreRegions(coordinates)
Target.region(coordinates)
CodedRegion.padding
CodedRegion.regionId
Target.frame
Target.shadow
CheckSettings.frame
CheckSettings.shadow

Ein unbekannter Schlüssel in der Objektform einer Konfiguration oder eines Checks löst eine Warnung unter seinem Namen aus (CheckSettings.<key> bei einem Check).

Nicht vorhanden: was nicht kompiliert

Das sind keine Einstellungen: Sie liefern Daten, die Delta-QA nicht hat, oder prüfen ein Bild statt einer Seite. Eine Suite, die sie verwendet, kompiliert nicht, statt einen erfundenen Wert zu erhalten.

Nicht vorhanden	Warum
`eyes.locate` `eyes.extractText` `eyes.extractTextRegions`	Sie liefern Regionen oder Text, die Applitools in seinem Screenshot liest.
`eyes.checkImage` `Target.image` `Target.buffer` `Target.base64` `Target.path` `Target.url`	Delta-QA prüft Seiten, keine Bilder.
`eyes.getLogger` `eyes.logger`	Das Log von Applitools.
`eyes.run`	In der Fixture von Applitools deren Check in natürlicher Sprache.

Was sich von Applitools unterscheidet

Bewusste Entscheidungen von Delta-QA, die Sie vor dem ersten Lauf kennen sollten.

Situation	Delta-QA
Zuordnung eines Checks zu seiner Referenz	Über den Namen des Checks, wenn jeder Name im Test eindeutig ist; sonst nach Reihenfolge, über den Namen, ersatzweise über die Seitenadresse: Ein eingefügter oder entfernter Check verschiebt die anderen nicht.
Eine auf einem Branch akzeptierte Änderung	Kein automatisches Zusammenführen von Referenzen eines Branches in einen anderen. Erscheint derselbe Unterschied auf einem anderen Branch, bietet Delta-QA „Already intended on … — apply?“ an.
Einen Unterschied akzeptieren	„Gewollt“ gilt für die Branches, die Sie ankreuzen.
Weder `APPLITOOLS_BATCH_ID` noch Batch-`id`	Eine Version pro Prozess: Jeder Worker von Playwright Test ist ein Prozess, mehrere Worker ergeben also mehrere Versionen — auch mit der Fixture. Setzen Sie `APPLITOOLS_BATCH_ID` auf den Commit Ihrer CI, um eine Version zu teilen.
Eine zu ignorierende Region, die keinem Element entspricht	Ausgelassen, und der Check wird ohne sie gesendet, wie bei Applitools — und eine Node.js-Warnung mit dem Code `DELTAQA_IGNORED_REGION` nennt sie, einmal pro Region und Prozess (`node --disable-warning=DELTAQA_IGNORED_REGION` schaltet sie stumm). Eine zu prüfende Region, die nichts trifft, lässt den Check mit `ZoneNotFoundError` scheitern, wie bei Applitools.
`runner.getAllTestResults()` und ein offen gebliebener Test	Der Test wird geschlossen und sein Urteil gefällt; Applitools bricht ihn ab.
Fixture: `eyesConfig` auf oberster Ebene von `playwright.config` und in einem Projekt	Die des Projekts ersetzt die der obersten Ebene, so wie Playwright Test eine Option vergibt; `test.use` fügt seine Schlüssel denen des Projekts hinzu. Die Fixture von Applitools führt beide Schlüssel für Schlüssel zusammen.
Fixture: `type: 'classic'` mit `browsersInfo`	Jede Größe ist eine Umgebung, wie mit `ClassicRunner` außerhalb der Fixture; die Fixture von Applitools verwirft die Größen. `type` löst eine Warnung aus.
Fixture: `expect(page).toHaveScreenshot()`	Das von Playwright Test selbst: `expect` ist das von `@playwright/test`. Die Fixture von Applitools macht daraus einen Eyes-Check.
Ein Test, der 30 Minuten ohne Check bleibt	Delta-QA schließt ihn; `close()` liest dann sein Urteil.

Die Daten, die Sie senden

Was das SDK sendet — die Seiten, die Ihre Tests prüfen, und die Dateien, die sie verwenden —, dient nur dazu, sie zu vergleichen. Das Testen mit personenbezogenen Produktionsdaten liegt in Ihrer Verantwortung: Lassen Sie die Suite mit Testdaten laufen.

Das Vision SDK: Delta-QA-Checks in Ihren Playwright-Tests

Applitools, Applitools Eyes und Eyes sind Marken der Applitools Ltd. Delta-QA ist nicht mit Applitools verbunden und wird von Applitools weder unterstützt noch gesponsert.

Lassen Sie Ihre Eyes-Suite auf Delta-QA laufen

Um Vision zu nutzen, kontaktieren Sie uns: Es ist zunächst im frühen Zugang verfügbar. Sagen Sie uns, welche Tests Sie prüfen lassen möchten, und wir schalten Ihren Zugang frei.

Zugang zu Vision anfragen Kostenloses Konto erstellen