

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.

# Einen testgetriebenen Entwicklungsansatz verwenden
<a name="development-best-practices"></a>

Wir empfehlen Ihnen, mit dem einen Test-Driven-Driven-Development-Ansatz (TDD) zu verfolgen. AWS CDK TDD ist ein Softwareentwicklungsansatz, bei dem Sie Testfälle entwickeln, um Ihren Code zu spezifizieren und zu validieren. Einfach ausgedrückt, erstellen Sie zunächst Testfälle für jede Funktionalität. Wenn der Test fehlschlägt, schreiben Sie dann den neuen Code, um den Test zu bestehen und den Code einfach und fehlerfrei zu gestalten.

Sie können TDD verwenden, um zuerst den Testfall zu schreiben. Dies hilft Ihnen bei der Validierung der Infrastruktur mit verschiedenen Design-Einschränkungen in Bezug auf die Durchsetzung von Sicherheitsrichtlinien für die Ressourcen und die Einhaltung einer eindeutigen Namenskonvention für das Projekt. Der Standardansatz zum Testen von AWS CDK Anwendungen besteht darin, das AWS CDK [Assertions-Modul](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.assertions-readme.html) und beliebte Test-Frameworks wie [Jest](https://jestjs.io/) for TypeScript und JavaScript oder [pytest](https://docs.pytest.org/en/6.2.x/) for Python zu verwenden.

Es gibt zwei Kategorien von Tests, die Sie für Ihre Anwendungen schreiben können: AWS CDK 
+ Verwenden **Sie detaillierte Assertionen**, um einen bestimmten Aspekt der generierten CloudFormation Vorlage zu testen, z. B. „Diese Ressource hat diese Eigenschaft mit diesem Wert“. Diese Tests können Regressionen erkennen und sind auch nützlich, wenn Sie neue Feature mit TDD entwickeln (schreiben Sie zuerst einen Test, dann bestehen Sie ihn, indem Sie eine korrekte Implementierung schreiben). Fine-grained assertions sind die Tests, die Sie am häufigsten schreiben werden.
+ Verwenden Sie **Snapshot-Tests**, um die synthetisierte CloudFormation Vorlage anhand einer zuvor gespeicherten Basisvorlage zu testen. Snapshot-Tests ermöglichen einen freien Faktorwechsel, da Sie sicher sein können, dass der umgestaltete Code genauso funktioniert wie das Original. Wenn die Änderungen beabsichtigt waren, können Sie eine neue Ausgangsbasis für zukünftige Tests akzeptieren. AWS CDK Upgrades können jedoch auch dazu führen, dass sich synthetisierte Vorlagen ändern, sodass Sie sich nicht nur auf Snapshots verlassen können, um sicherzustellen, dass Ihre Implementierung korrekt ist.

## Komponententest
<a name="unit-test"></a>

Dieser Leitfaden konzentriert sich TypeScript speziell auf die Integration von Komponententests. Um Tests zu ermöglichen, stellen Sie sicher, dass Ihre `package.json` Datei die folgenden Bibliotheken enthält: `@types/jest``jest`, und `ts-jest` in`devDependencies`. Um diese Pakete hinzuzufügen, führen Sie den `cdk init lib --language=typescript`-Befehl aus. Nachdem Sie den vorherigen Befehl ausgeführt haben, sehen Sie die folgende Struktur.

![\[Unit-Test-Struktur\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/best-practices-cdk-typescript-iac/images/unit_test_structure.png)


Der folgende Code ist ein Beispiel für eine `package.json` Datei, die mit der Jest-Bibliothek aktiviert wurde.

```
{
  ...
  "scripts": {
    "build": "npm run lint && tsc",
    "watch": "tsc -w",
    "test": "jest",
  },
  "devDependencies": {
    ...
    "@types/jest": "27.5.2",
    "jest": "27.5.1",
    "ts-jest": "27.1.5",
    ...
  }
}
```

Unter dem Ordner **Test** können Sie den Testfall schreiben. Das folgende Beispiel zeigt einen Testfall für ein AWS CodePipeline Konstrukt.

```
import { Stack } from 'aws-cdk-lib';
import { Template } from 'aws-cdk-lib/assertions';
import * as CodePipeline from 'aws-cdk-lib/aws-codepipeline';
import * as CodePipelineActions from 'aws-cdk-lib/aws-codepipeline-actions';
import { MyPipelineStack } from '../lib/my-pipeline-stack';
test('Pipeline Created with GitHub Source', () => {
  // ARRANGE
  const stack = new Stack();
  // ACT
  new MyPipelineStack(stack, 'MyTestStack');
  // ASSERT
  const template = Template.fromStack(stack);
  // Verify that the pipeline resource is created
  template.resourceCountIs('AWS::CodePipeline::Pipeline', 1);
  // Verify that the pipeline has the expected stages with GitHub source
  template.hasResourceProperties('AWS::CodePipeline::Pipeline', {
    Stages: [
      {
        Name: 'Source',
        Actions: [
          {
            Name: 'SourceAction',
            ActionTypeId: {
              Category: 'Source',
              Owner: 'ThirdParty',
              Provider: 'GitHub',
              Version: '1'
            },
            Configuration: {
              Owner: {
                'Fn::Join': [
                  '',
                  [
                    '{{resolve:secretsmanager:',
                    {
                      Ref: 'GitHubTokenSecret'
                    },
                    ':SecretString:owner}}'
                  ]
                ]
              },
              Repo: {
                'Fn::Join': [
                  '',
                  [
                    '{{resolve:secretsmanager:',
                    {
                      Ref: 'GitHubTokenSecret'
                    },
                    ':SecretString:repo}}'
                  ]
                ]
              },
              Branch: 'main',
              OAuthToken: {
                'Fn::Join': [
                  '',
                  [
                    '{{resolve:secretsmanager:',
                    {
                      Ref: 'GitHubTokenSecret'
                    },
                    ':SecretString:token}}'
                  ]
                ]
              }
            },
            OutputArtifacts: [
              {
                Name: 'SourceOutput'
              }
            ],
            RunOrder: 1
          }
        ]
      },
      {
        Name: 'Build',
        Actions: [
          {
            Name: 'BuildAction',
            ActionTypeId: {
              Category: 'Build',
              Owner: 'AWS',
              Provider: 'CodeBuild',
              Version: '1'
            },
            InputArtifacts: [
              {
                Name: 'SourceOutput'
              }
            ],
            OutputArtifacts: [
              {
                Name: 'BuildOutput'
              }
            ],
            RunOrder: 1
          }
        ]
      }
      // Add more stage checks as needed
    ]
  });
  // Verify that a GitHub token secret is created
  template.resourceCountIs('AWS::SecretsManager::Secret', 1);
});
);
```

Um einen Test auszuführen, führen Sie den `npm run test`-Befehl in Ihrem Projekt aus. Der Test gibt die folgenden Ergebnisse zurück.

```
PASS  test/codepipeline-module.test.ts (5.972 s)
  ✓ Code Pipeline Created (97 ms)
Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:        6.142 s, estimated 9 s
```

Weitere Informationen zu Testfällen finden Sie unter [Testen von Konstrukten](https://docs.aws.amazon.com/cdk/v2/guide/testing.html) im *AWS Cloud Development Kit (AWS CDK) Entwicklerhandbuch*.

## Integrationstest
<a name="integration-test"></a>

Integrationstests für AWS CDK Konstrukte können auch mithilfe eines `integ-tests` Moduls eingebunden werden. Ein Integrationstest sollte als AWS CDK Anwendung definiert werden. Es sollte eine one-to-one Beziehung zwischen einem Integrationstest und einer AWS CDK Anwendung bestehen. Weitere Informationen finden Sie im [integ-tests-alpha Modul](https://docs.aws.amazon.com/cdk/api/v2/docs/integ-tests-alpha-readme.html) in der *AWS CDK API-Referenz*.