

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Testen von Versionen
<a name="release-management-release-testing"></a>

Releasetests generieren Testpläne und führen sie aus, um Codeänderungen in realistischen Umgebungen zu validieren. Der Releasetest-Agent führt explorative UAT- und Regressionstests — funktionale Regression, Validierung der Benutzererfahrung, Integrationstests und Edge-Case-Exploration — anhand Ihrer bereitgestellten Webanwendungen und REST-APIs durch.

## Wie funktionieren Release-Tests
<a name="how-release-testing-works"></a>

**Wichtig**  
**Beim Releasetest werden echte Anfragen an Ihre Zielanwendung ausgeführt, einschließlich Schreiboperationen (POST, PUT, DELETE). Der Agent untersucht Endpunkte, sendet Formulare und testet die Fehlerbehandlung. Diese Aktionen können Daten in der Zielanwendung erstellen, ändern oder löschen. Verwenden Sie diese Option nur, wenn Ihr Risikoprofil mutierende Aktionen als Teil der explorativen Tests zulässt. Stellen Sie sicher, dass Ihre Anwendungen explorative Schreibvorgänge ohne unbeabsichtigte Folgen wie das Senden von Kundenbenachrichtigungen, die Verarbeitung von Zahlungen oder das dauerhafte Löschen von Datensätzen tolerieren. Wir empfehlen, Staging-Bereitstellungen zu verwenden. Produktionsanwendungen sollten nur dann ins Visier genommen werden, wenn die Schreibvorgänge Ihrer Anwendung für automatisierte Tests sicher sind.

Wenn der Release-Test-Agent ausgelöst wird:

1. **Generiert einen Testplan** — Erstellt einen Testplan auf der Grundlage von Codeänderungen oder einer vom Benutzer angegebenen Testabsicht. Wenn der Plan durch eine Pull-Anfrage oder einen Branch ausgelöst wird, zielt er auf die betroffene Funktionalität ab. Wenn es manuell oder über den Chat ausgelöst wird, kannst du eine Testabsicht angeben, die beschreibt, was validiert werden soll. Der Plan deckt funktionale Korrektheit, Integrationsverhalten und Szenarien mit Benutzerorientierung ab.

1. **Führt Tests für eine laufende Anwendung** aus — Bei Angabe einer Ziel-URL (Webanwendung oder API-Endpunkt) untersucht der Agent die Anwendung und führt die generierten Tests aus. Bei Webanwendungen umfasst dies browserbasierte Benutzeroberflächeninteraktion und visuelle Inspektion. Bei APIs umfasst dies direkte HTTP-Endpunkttests, Schemavalidierung und Überprüfung der Fehlerbehandlung.

1. **Meldet Ergebnisse** — Die Ergebnisse werden mit bestimmten Fehlern, beeinträchtigten Funktionen, Reproduktionsschritten und empfohlenen Korrekturen zurückgegeben.

Release-Tests unterstützen Webanwendungen (React, Angular, Vue, vom Server gerendert) und REST-APIs.

## Unterstützte Testtypen
<a name="supported-test-types"></a>
+ **UI-Tests** — Browser-based Testen mit visuellen Interaktionen für Webanwendungen
+ **API-Tests** — Direktes Testen von HTTP-Endpunkten für REST-APIs

## Definition von Testprofilen
<a name="defining-test-profiles"></a>

Testprofile definieren die Web- und API-Anwendungen, die Sie testen möchten, sowie die erforderlichen Konfigurationen. Jedes Testprofil spezifiziert eine Zielanwendung und ihren Testtyp.

Um ein Testprofil zu erstellen:

1. Navigieren Sie in der DevOps Agent-Web-App im linken Navigationsbereich zu **Release Manager**.

1. Wählen Sie die Schaltfläche „**Profile testen**“.

1. Wählen **Sie Testprofil hinzufügen**.

1. Füllen Sie das Formular mit den folgenden Angaben aus:
   + **Name** — Ein beschreibender Name für das Testprofil (z. B. „MyApp Staging“)
   + **Ziel-URL** — Die URL einer Staging- oder Testbereitstellung Ihrer Anwendung. Der Agent sendet echten HTTP-Verkehr, einschließlich Schreiboperationen (POST, PUT, DELETE). Verwenden Sie keine Produktions-URLs, es sei denn, Sie verstehen und akzeptieren das Risiko einer Datenänderung.
   + **Testtyp** — Wählen Sie entweder **UI-Tests** (browserbasierte Tests mit visuellen Interaktionen) oder **API-Tests** (direkte HTTP-Endpunkttests)

1. Wählen Sie **Testprofil hinzufügen** aus, um es zu speichern.

**Hinweis:** Die Anwendung muss über das öffentliche Internet zugänglich sein. Private Netzwerkendpunkte werden derzeit nicht unterstützt.

## Tests von einem Testprofil aus ausführen
<a name="running-tests-from-a-test-profile"></a>

Auf der Seite **Testprofile** können Sie manuell einen Testlauf auslösen:

1. Suchen Sie Ihr Testprofil in der Liste.

1. Wählen Sie **Testen starten** aus.

1. (Optional) Geben Sie unter **Testabsicht spezifische Anweisungen an und geben Sie an, was getestet** werden soll. Beispiel: „Stellen Sie sicher, dass der Checkout-Ablauf abgelaufene Coupons korrekt verarbeitet“ oder „Testen Sie das Benutzerregistrierungsformular mit ungültigen Eingaben“.

Der Mitarbeiter erstellt auf der Grundlage Ihrer Absicht einen Testplan (oder sondiert umfassend, falls keine Absicht angegeben wurde), führt Tests durch und meldet die Ergebnisse im Bereich **Release Manager** unter „Vorgeschlagene Änderungen“.

## Tests werden vom DevOps Agenten-Chat aus ausgeführt
<a name="running-tests-from-devops-agent-chat"></a>

Im DevOps Agenten-Chat können Sie Release-Tests anfordern. Bitten Sie den Agenten, Ihre Testprofile aufzulisten oder anzugeben, welches ausgeführt werden soll. Der Mitarbeiter fragt Sie nach allen erforderlichen Folgeinformationen, z. B. was getestet werden soll oder auf welche Bereiche Sie sich konzentrieren sollten.

Beispiele:
+ „Meine Testprofile auflisten“
+ „Testprofil my-test-profile ausführen“
+ „Führe Releasetests für meine Anwendung unter durch https://staging.myapp.com und verifiziere den Zahlungsfluss“

Der Mitarbeiter meldet bei der Erkundung der Anwendung den Fortschritt und gibt Ergebnisse mit spezifischen Ergebnissen, Screenshots (für UI-Tests) und Reproduktionsschritten zurück.

## Tests von Ihrer IDE aus ausführen
<a name="running-tests-from-your-ide"></a>

Von Kiro IDE oder Claude Code aus kann der Coding-Agent Release-Tests aufrufen:

Installieren Sie zunächst das [Kiro Power]() - oder [Claude]() Code-Plugin.
+ Geben Sie eine Testanforderung oder -absicht an, in der beschrieben wird, was überprüft werden soll (z. B. „Überprüfen Sie, ob der Anmeldevorgang nach dem Auth-Refactor funktioniert“)
+ Der Codierungsagent übergibt die Testabsicht und ein Zieltestprofil an den Release-Testagenten
+ Der Release-Test-Agent generiert Tests und führt sie aus und meldet dann die Ergebnisse zurück
+ Wenn Probleme entdeckt werden, bietet der Coding-Agent an, diese an Ort und Stelle zu beheben

**Hinweis:** Tests anhand einer Pull-Anfrage direkt von der IDE werden derzeit nicht unterstützt. Verwenden Sie ein Testprofil mit einer bereitgestellten Anwendungs-URL und geben Sie eine Testanforderung an, um sich auf das Testen zu konzentrieren.

## Release-Tests in CI/CD Pipelines
<a name="release-testing-in-cicd-pipelines"></a>

### GitHub Aktionen
<a name="github-actions"></a>

Die `aws-actions/devops-agent-release-testing@v1` GitHub Aktion löst den Releasetest-Agenten nach der Bereitstellung aus und meldet die Ergebnisse als GitHub Prüflauf für Ihren Commit oder Pull Request.

#### Voraussetzungen
<a name="prerequisites"></a>
+ Ein in Ihrem Agent Space konfiguriertes [Testprofil](#defining-test-profiles)
+ Ein in Ihrem Agent Space [DevOps Agent über Webhook aufrufen](configuring-integrations-and-knowledge-invoking-devops-agent-through-webhook.md) konfiguriertes

#### Schritt 1: Konfigurieren Sie GitHub Repository-Geheimnisse
<a name="step-1-configure-github-repository-secrets"></a>

Gehen Sie in Ihrem GitHub Repository zu **Einstellungen → Geheimnisse und Variablen → Aktionen → Repository-Geheimnisse** und fügen Sie Folgendes hinzu:


| Secret | Description | 
| --- | --- | 
| DEVOPS\_AGENT\_WEBHOOK\_URL | Die Webhook-URL aus Ihrem Agent Space | 
| DEVOPS\_AGENT\_WEBHOOK\_SECRET | Das geheime Webhook-Signaturgeheimnis aus Ihrem Agent Space | 

Informationen zum Erstellen eines Webhook-Endpunkts finden Sie unter. [DevOps Agent über Webhook aufrufen](configuring-integrations-and-knowledge-invoking-devops-agent-through-webhook.md)

#### Schritt 2: Fügen Sie die Aktion zu Ihrem Workflow hinzu
<a name="step-2-add-the-action-to-your-workflow"></a>

Fügen Sie den Release-Testschritt zu Ihrem Workflow hinzu (zum Beispiel`.github/workflows/release-tests.yml`):

```
name: Release Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

permissions:
  checks: write
  contents: read
  pull-requests: read

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Trigger Release Tests
        uses: aws-actions/devops-agent-qa@v1
        with:
          webhook-url: ${{ secrets.DEVOPS_AGENT_WEBHOOK_URL }}
          webhook-secret: ${{ secrets.DEVOPS_AGENT_WEBHOOK_SECRET }}
          test-profile-id: <YOUR_TEST_PROFILE_ID>
          test-requirement: <WHAT_TO_TEST>  # optional
        env:
          GITHUB_TOKEN: ${{ github.token }}
```

`<YOUR_TEST_PROFILE_ID>`Ersetzen Sie es durch die Testprofil-ID aus Ihrem Agent Space (beginnt mit`ki-`). Die `test-requirement` Eingabe ist optional. Verwenden Sie sie, um den Agenten auf bestimmte Bereiche zu konzentrieren (z. B. „Überprüfen Sie den Anmeldeablauf nach dem Auth-Refactor“).

#### Eingaben für Aktionen
<a name="action-inputs"></a>


| Input | Erforderlich | Description | 
| --- | --- | --- | 
| Webhook-URL | Ja | Die Webhook-URL aus Ihrem Agent Space | 
| Webhook-Geheimnis | Ja | Das geheime Webhook-Signaturgeheimnis für die Authentifizierung HMAC-SHA256  | 
| Testprofil-ID | Ja | Die Testprofil-ID, die ausgelöst werden soll (beginnt mit) ki- | 
| Testanforderung | Nein | Optionaler Schwerpunktbereich für Tests | 

#### Erforderliche Workflow-Berechtigungen
<a name="required-workflow-permissions"></a>


| Berechtigung | Grund | 
| --- | --- | 
| Inhalt: gelesen | Erforderlich für actions/checkout private Repos | 
| Pull-Requests: lesen | PR-Nummer aus dem Merge-Commit SHA auflösen | 

#### Funktionsweise
<a name="how-it-works"></a>

1. Ihre Workflow-Auslöser (z. B. nach der Bereitstellung in einer Staging-Umgebung).

1. Die Aktion erstellt einen Prüflauf (`in_progress`) für den Commit oder PR, der als ausstehende Prüfung angezeigt wird.

1. Die Aktion signiert und sendet einen Webhook an Ihren Agent Space.

1. Der Releasetest-Agent übernimmt die Aufgabe und führt Tests für Ihre Anwendung durch.

1. Die Ergebnisse werden als GitHub Prüflauf (pass/fail mit einer detaillierten Zusammenfassung) zurückgemeldet.

Sie können die vollständigen Ausführungsdetails (Zeitplan, Testfälle, Screenshots für UI-Tests) in der DevOps Agent-Web-App einsehen, die von Ihrem Agent-Bereich aus verlinkt ist.

## Überprüfung der Testergebnisse
<a name="reviewing-test-results"></a>

Die Testergebnisse werden im Abschnitt „**Änderungen**“ der DevOps Agent-Web-App unter „Vorgeschlagene Änderungen“ angezeigt. Jeder Testlauf zeigt:
+ **Status** — Abgeschlossen, Fehlgeschlagen oder In Bearbeitung
+ **Kategorie** — Release-Tests
+ **Dauer** — Wie lange hat der Testlauf gedauert
+ **Quelle** — Ob er manuell, über einen Chat oder über eine CI/CD Pipeline ausgelöst wurde

Wählen Sie einen Testlauf aus, um detaillierte Ergebnisse wie spezifische Testfehler, Screenshots (für UI-Tests), Reproduktionsschritte und empfohlene Korrekturen anzuzeigen.