Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Adoptar un enfoque de desarrollo basado en pruebas
<a name="development-best-practices"></a>

Le recomendamos que siga un enfoque de desarrollo basado en pruebas (TDD) con el. AWS CDK El TDD es un enfoque de desarrollo de software en el que se desarrollan casos de prueba para especificar y validar el código. En pocas palabras, primero se crean casos de prueba para cada funcionalidad y, si la prueba falla, se escribe el código nuevo a fin de pasar la prueba y hacer que el código sea simple y libre de errores.

Puede utilizar el TDD para escribir primero el caso de prueba. Esto lo ayuda a validar la infraestructura con diferentes restricciones de diseño en términos de aplicar la política de seguridad para los recursos y seguir una convención de nomenclatura única para el proyecto. El enfoque estándar para probar AWS CDK aplicaciones es utilizar el módulo de AWS CDK [aserciones](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.assertions-readme.html) y los marcos de prueba más populares, como [Jest](https://jestjs.io/) para JavaScript y/o TypeScript [pytest para Python](https://docs.pytest.org/en/6.2.x/).

Hay dos categorías de pruebas que puedes escribir para tus aplicaciones: AWS CDK 
+ Usa **afirmaciones detalladas para** probar un aspecto específico de la CloudFormation plantilla generada, como «este recurso tiene esta propiedad con este valor». Estas pruebas pueden detectar regresiones y también son útiles cuando se desarrollan características nuevas con el TDD (primero hay que escribir una prueba y, después, hacer que se apruebe al escribir una implementación correcta). Las afirmaciones detalladas son las pruebas que escribirá con más frecuencia.
+ Utilice **pruebas instantáneas para comparar** la CloudFormation plantilla sintetizada con una plantilla de referencia previamente almacenada. Las pruebas de instantáneas permiten refactorizar con libertad, ya que puede estar seguro de que el código refactorizado funciona exactamente de la misma manera que el original. Si los cambios eran intencionales, puede aceptar un punto de referencia nuevo para pruebas futuras. Sin embargo, AWS CDK las actualizaciones también pueden provocar cambios en las plantillas sintetizadas, por lo que no puede confiar únicamente en las instantáneas para asegurarse de que la implementación es correcta.

## Prueba unitaria
<a name="unit-test"></a>

Esta guía se centra TypeScript específicamente en la integración de las pruebas unitarias. Para habilitar las pruebas, asegúrate de que el `package.json` archivo tenga las siguientes bibliotecas: `@types/jest``jest`, y `ts-jest` en`devDependencies`. Para agregar estos paquetes, ejecute el comando `cdk init lib --language=typescript`. Tras ejecutar el comando anterior, verá la siguiente estructura.

![\[Estructura de pruebas unitarias\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/best-practices-cdk-typescript-iac/images/unit_test_structure.png)


El siguiente código es un ejemplo de un `package.json` archivo que está habilitado con la biblioteca Jest.

```
{
  ...
  "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",
    ...
  }
}
```

En la carpeta **Prueba**, puede escribir el caso de prueba. El siguiente ejemplo muestra un caso de prueba para una AWS CodePipeline construcción.

```
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);
});
);
```

Para realizar una prueba, ejecute el comando `npm run test` en su proyecto. La prueba devuelve los siguientes resultados.

```
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
```

Para obtener más información sobre los casos de prueba, consulte [Probar construcciones](https://docs.aws.amazon.com/cdk/v2/guide/testing.html) en la *Guía para AWS Cloud Development Kit (AWS CDK) desarrolladores*.

## Prueba de integración
<a name="integration-test"></a>

Las pruebas de integración para AWS CDK construcciones también se pueden incluir mediante un `integ-tests` módulo. Una prueba de integración debe definirse como una AWS CDK aplicación. Debe haber una one-to-one relación entre una prueba de integración y una AWS CDK aplicación. Para obtener más información, visita el [integ-tests-alpha módulo](https://docs.aws.amazon.com/cdk/api/v2/docs/integ-tests-alpha-readme.html) de la *referencia AWS CDK de la API*.