🚀 Socket Launch Week Day 5:Introducing Repository Access Permissions and Custom Roles.Learn more →
@aws-cdk/integ-runner
Advanced tools
@aws-cdk/integ-runner - npm Package Compare versions
| import type { TestCase, DefaultCdkOptions } from '@aws-cdk/cloud-assembly-schema'; | ||
| import { IntegTestSuite, LegacyIntegTestSuite } from './integ-test-suite'; | ||
| import type { IntegTest } from './integration-tests'; | ||
| import type { ICdk } from '../engines/cdk-interface'; | ||
| import type { DestructiveChange } from '../workers/common'; | ||
| /** | ||
| * Options for creating an integ helper | ||
| */ | ||
| export interface CdkIntegHelperOptions { | ||
| /** | ||
| * Information about the test to run | ||
| */ | ||
| readonly test: IntegTest; | ||
| /** | ||
| * The region where the test should be deployed | ||
| */ | ||
| readonly region: string; | ||
| /** | ||
| * The AWS profile to use when invoking the CDK CLI | ||
| * | ||
| * @default - no profile is passed, the default profile is used | ||
| */ | ||
| readonly profile?: string; | ||
| /** | ||
| * Additional environment variables that will be available | ||
| * to the CDK CLI | ||
| * | ||
| * @default - no additional environment variables | ||
| */ | ||
| readonly env?: { | ||
| [name: string]: string; | ||
| }; | ||
| /** | ||
| * tmp cdk.out directory | ||
| * | ||
| * @default - directory will be `cdk-integ.out.${testName}` | ||
| */ | ||
| readonly integOutDir?: string; | ||
| /** | ||
| * Instance of the CDK Toolkit Engine to use | ||
| * | ||
| * @default - based on `engine` option | ||
| */ | ||
| readonly cdk?: ICdk; | ||
| /** | ||
| * Show output from running integration tests | ||
| * | ||
| * @default false | ||
| */ | ||
| readonly showOutput?: boolean; | ||
| /** | ||
| * Use the indicated proxy | ||
| * | ||
| * @default - no proxy | ||
| */ | ||
| readonly proxy?: string; | ||
| /** | ||
| * Path to CA certificate to use when validating HTTPS requests | ||
| * | ||
| * @default - no additional CA bundle | ||
| */ | ||
| readonly caBundlePath?: string; | ||
| } | ||
| /** | ||
| * Whether to synthesize the actual snapshot with lookups enabled or not. | ||
| * | ||
| * If either `true` or `false`, we send context in or not while synthesizing, | ||
| * and if the generated snapshot test definition requests a different value we | ||
| * will synth again. | ||
| * | ||
| * For `dont-care`, we do send in the context but we never resynth. | ||
| */ | ||
| export type LegacyEnableLookups = true | false | 'dont-care'; | ||
| /** | ||
| * Class with some helper routines for running CDK snapshots and integration tests. | ||
| * | ||
| * A "golden snapshot" is the snapshot that is stored permanently in version | ||
| * control, that new runs are compared against (stored in a directory named | ||
| * `<test-name>.snapshot`). | ||
| * | ||
| * This is as opposed to other snapshots, which can be generated for example | ||
| * temporarily in a temporary directory, to compare agains the golden snapshot. | ||
| */ | ||
| export declare class CdkIntegHelper { | ||
| /** | ||
| * Factory method to create an instance of the CdkIntegHelper. | ||
| * | ||
| * Hiding the constructor to prevent inheritance. | ||
| */ | ||
| static create(options: CdkIntegHelperOptions): CdkIntegHelper; | ||
| /** | ||
| * The directory where the golden snapshot will be stored | ||
| */ | ||
| readonly goldenSnapshotDir: string; | ||
| /** | ||
| * An instance of the CDK CLI | ||
| */ | ||
| readonly cdk: ICdk; | ||
| /** | ||
| * Pretty name of the test | ||
| */ | ||
| readonly testName: string; | ||
| /** | ||
| * The value used in the '--app' CLI parameter | ||
| * | ||
| * Path to the integ test source file, relative to `this.directory`. | ||
| */ | ||
| readonly cdkApp: string; | ||
| /** | ||
| * The path where the `cdk.context.json` file | ||
| * will be created | ||
| */ | ||
| readonly cdkContextPath: string; | ||
| /** | ||
| * The working directory that the integration tests will be | ||
| * executed from | ||
| */ | ||
| readonly directory: string; | ||
| /** | ||
| * The test to run | ||
| */ | ||
| private readonly test; | ||
| /** | ||
| * Default options to pass to the CDK CLI | ||
| */ | ||
| readonly defaultArgs: DefaultCdkOptions; | ||
| /** | ||
| * The directory where the CDK will be synthed to | ||
| * | ||
| * Relative to cwd. | ||
| */ | ||
| readonly cdkOutDir: string; | ||
| /** | ||
| * The profile to use for the CDK CLI calls | ||
| */ | ||
| readonly profile?: string; | ||
| /** | ||
| * Show output from the integ test run. | ||
| */ | ||
| private readonly showOutput; | ||
| _destructiveChanges?: DestructiveChange[]; | ||
| private legacyContext?; | ||
| private _expectedTestSuite?; | ||
| private _actualSnapshot?; | ||
| private _legacyEnableLookups?; | ||
| /** | ||
| * Private constructor to prevent inheritance. | ||
| */ | ||
| private constructor(); | ||
| /** | ||
| * Configure the legacy enableLookups value to use when generating the actual snapshot. | ||
| * | ||
| * Must be set before using snapshot methods. | ||
| */ | ||
| configureLegacyEnableLookups(enableLookups: LegacyEnableLookups): void; | ||
| /** | ||
| * Return the list of actual (i.e. new) test cases for this integration test | ||
| */ | ||
| actualTests(): Promise<{ | ||
| [testName: string]: TestCase; | ||
| } | undefined>; | ||
| /** | ||
| * Generate a new "actual" snapshot which will be compared to the | ||
| * existing "expected" snapshot | ||
| * This will synth and then load the integration test manifest | ||
| */ | ||
| private generateActualSnapshot; | ||
| /** | ||
| * Synth the actual application to the given directory, for purposes of generating/validating a snapshot | ||
| * | ||
| * `legacyEnableLookups` is to preserve historical behavior for a while: | ||
| * traditionally, the application would only be seeded with context if | ||
| * `enableLookups` was true, and this information would come from the test | ||
| * definition. | ||
| * | ||
| * - Since the test definition comes from inside the app, this requires a | ||
| * synth just to get the test definition, and then another synth to generate | ||
| * the actual snapshot with the correct context, which is time consuming. | ||
| * - Given that the context is fixed and fake, it could always have been passed. | ||
| * | ||
| * However, the snapshot contents themselves depend on the context flag, and changing | ||
| * this behavior now invalidates all snapshots everywhere, which is annoying for upgrading. | ||
| * | ||
| * So we will use the behavior from the GOLDEN SNAPSHOT's test definition to | ||
| * determine whether to pass the context, and if the new actual snapshot has a | ||
| * different value for `enableLookups`, we will throw away the old snapshot and synth again. | ||
| */ | ||
| private synthActualSnapshot; | ||
| actualSynthReproCommand(): string[]; | ||
| /** | ||
| * Returns true if a snapshot already exists for this test | ||
| */ | ||
| hasSnapshot(): boolean; | ||
| /** | ||
| * The test suite from the existing snapshot | ||
| */ | ||
| expectedTestSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite | undefined>; | ||
| actualSnapshot(): Promise<SnapshotAndTestDefinition>; | ||
| /** | ||
| * The test suite from the new "actual" snapshot | ||
| */ | ||
| private actualTestSuite; | ||
| /** | ||
| * Load the integ manifest which contains information | ||
| * on how to execute the tests | ||
| * First we try and load the manifest from the integ manifest (i.e. integ.json) | ||
| * from the cloud assembly. If it doesn't exist, then we fallback to the | ||
| * "legacy mode" and create a manifest from pragma | ||
| */ | ||
| loadManifest(dir?: string): Promise<IntegTestSuite | LegacyIntegTestSuite>; | ||
| cleanup(): void; | ||
| /** | ||
| * If there are any destructive changes to a stack then this will record | ||
| * those in the manifest.json file | ||
| */ | ||
| private renderTraceData; | ||
| /** | ||
| * In cases where we do not want to retain the assets, | ||
| * for example, if the assets are very large. | ||
| * | ||
| * Since it is possible to disable the update workflow for individual test | ||
| * cases, this needs to first get a list of stacks that have the update workflow | ||
| * disabled and then delete assets that relate to that stack. It does that | ||
| * by reading the asset manifest for the stack and deleting the asset source | ||
| */ | ||
| private removeAssetsFromSnapshot; | ||
| /** | ||
| * Remove the asset cache (.cache/) files from the snapshot. | ||
| * These are a cache of the asset zips, but we are fine with | ||
| * re-zipping on deploy | ||
| */ | ||
| private removeAssetsCacheFromSnapshot; | ||
| /** | ||
| * Create the new snapshot. | ||
| * | ||
| * If lookups are enabled, then we need create the snapshot by synth'ing again | ||
| * with the dummy context so that each time the test is run on different machines | ||
| * (and with different context/env) the diff will not change. | ||
| * | ||
| * If lookups are disabled (which means the stack is env agnostic) then just copy | ||
| * the assembly that was output by the deployment | ||
| */ | ||
| createSnapshot(): Promise<void>; | ||
| /** | ||
| * Perform some cleanup steps after the snapshot is created | ||
| * Anytime the snapshot needs to be modified after creation | ||
| * the logic should live here. | ||
| */ | ||
| private cleanupGoldenSnapshot; | ||
| getContext(additionalContext?: Record<string, any>): Record<string, any>; | ||
| } | ||
| export declare const DEFAULT_SYNTH_OPTIONS: { | ||
| context: { | ||
| "aws:cdk:availability-zones:fallback": string[]; | ||
| 'availability-zones:account=12345678:region=test-region': string[]; | ||
| 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2:region=test-region': string; | ||
| 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2:region=test-region': string; | ||
| 'ssm:account=12345678:parameterName=/aws/service/ecs/optimized-ami/amazon-linux/recommended:region=test-region': string; | ||
| 'ami:account=12345678:filters.image-type.0=machine:filters.name.0=amzn-ami-vpc-nat-*:filters.state.0=available:owners.0=amazon:region=test-region': string; | ||
| 'vpc-provider:account=12345678:filter.isDefault=true:region=test-region:returnAsymmetricSubnets=true': { | ||
| vpcId: string; | ||
| subnetGroups: { | ||
| type: string; | ||
| name: string; | ||
| subnets: { | ||
| subnetId: string; | ||
| availabilityZone: string; | ||
| routeTableId: string; | ||
| }[]; | ||
| }[]; | ||
| }; | ||
| }; | ||
| env: { | ||
| CDK_INTEG_ACCOUNT: string; | ||
| CDK_INTEG_REGION: string; | ||
| CDK_INTEG_HOSTED_ZONE_ID: string; | ||
| CDK_INTEG_HOSTED_ZONE_NAME: string; | ||
| CDK_INTEG_DOMAIN_NAME: string; | ||
| CDK_INTEG_CERT_ARN: string; | ||
| CDK_INTEG_SUBNET_ID: string; | ||
| }; | ||
| }; | ||
| /** | ||
| * Return the currently recommended flags for `aws-cdk-lib`. | ||
| * | ||
| * These have been built into the CLI at build time. If this ever gets changed | ||
| * back to a dynamic load, remember that this source file may be bundled into | ||
| * a JavaScript bundle, and `__dirname` might not point where you think it does. | ||
| */ | ||
| export declare function currentlyRecommendedAwsCdkLibFlags(): { | ||
| "@aws-cdk/aws-signer:signingProfileNamePassedToCfn": boolean; | ||
| "@aws-cdk/aws-ecs-patterns:secGroupsDisablesImplicitOpenListener": boolean; | ||
| "@aws-cdk/aws-lambda:recognizeLayerVersion": boolean; | ||
| "@aws-cdk/core:checkSecretUsage": boolean; | ||
| "@aws-cdk/core:target-partitions": string[]; | ||
| "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": boolean; | ||
| "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": boolean; | ||
| "@aws-cdk/aws-ecs:arnFormatIncludesClusterName": boolean; | ||
| "@aws-cdk/aws-iam:minimizePolicies": boolean; | ||
| "@aws-cdk/core:validateSnapshotRemovalPolicy": boolean; | ||
| "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": boolean; | ||
| "@aws-cdk/aws-s3:createDefaultLoggingPolicy": boolean; | ||
| "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": boolean; | ||
| "@aws-cdk/aws-apigateway:disableCloudWatchRole": boolean; | ||
| "@aws-cdk/core:enablePartitionLiterals": boolean; | ||
| "@aws-cdk/aws-events:eventsTargetQueueSameAccount": boolean; | ||
| "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": boolean; | ||
| "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName": boolean; | ||
| "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": boolean; | ||
| "@aws-cdk/aws-route53-patters:useCertificate": boolean; | ||
| "@aws-cdk/customresources:installLatestAwsSdkDefault": boolean; | ||
| "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": boolean; | ||
| "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup": boolean; | ||
| "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId": boolean; | ||
| "@aws-cdk/aws-ec2:launchTemplateDefaultUserData": boolean; | ||
| "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments": boolean; | ||
| "@aws-cdk/aws-redshift:columnId": boolean; | ||
| "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2": boolean; | ||
| "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": boolean; | ||
| "@aws-cdk/aws-apigateway:requestValidatorUniqueId": boolean; | ||
| "@aws-cdk/aws-kms:aliasNameRef": boolean; | ||
| "@aws-cdk/aws-kms:applyImportedAliasPermissionsToPrincipal": boolean; | ||
| "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": boolean; | ||
| "@aws-cdk/core:includePrefixInUniqueNameGeneration": boolean; | ||
| "@aws-cdk/aws-efs:denyAnonymousAccess": boolean; | ||
| "@aws-cdk/aws-opensearchservice:enableOpensearchMultiAzWithStandby": boolean; | ||
| "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion": boolean; | ||
| "@aws-cdk/aws-efs:mountTargetOrderInsensitiveLogicalId": boolean; | ||
| "@aws-cdk/aws-rds:auroraClusterChangeScopeOfInstanceParameterGroupWithEachParameters": boolean; | ||
| "@aws-cdk/aws-appsync:useArnForSourceApiAssociationIdentifier": boolean; | ||
| "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials": boolean; | ||
| "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForCodeCommitSource": boolean; | ||
| "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction": boolean; | ||
| "@aws-cdk/aws-codepipeline:crossAccountKeysDefaultValueToFalse": boolean; | ||
| "@aws-cdk/aws-codepipeline:defaultPipelineTypeToV2": boolean; | ||
| "@aws-cdk/aws-kms:reduceCrossAccountRegionPolicyScope": boolean; | ||
| "@aws-cdk/aws-eks:nodegroupNameAttribute": boolean; | ||
| "@aws-cdk/aws-eks:useNativeOidcProvider": boolean; | ||
| "@aws-cdk/aws-ec2:ebsDefaultGp3Volume": boolean; | ||
| "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm": boolean; | ||
| "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault": boolean; | ||
| "@aws-cdk/aws-s3:keepNotificationInImportedBucket": boolean; | ||
| "@aws-cdk/core:explicitStackTags": boolean; | ||
| "@aws-cdk/aws-ecs:reduceEc2FargateCloudWatchPermissions": boolean; | ||
| "@aws-cdk/aws-dynamodb:resourcePolicyPerReplica": boolean; | ||
| "@aws-cdk/aws-ec2:ec2SumTImeoutEnabled": boolean; | ||
| "@aws-cdk/aws-appsync:appSyncGraphQLAPIScopeLambdaPermission": boolean; | ||
| "@aws-cdk/aws-rds:setCorrectValueForDatabaseInstanceReadReplicaInstanceResourceId": boolean; | ||
| "@aws-cdk/core:cfnIncludeRejectComplexResourceUpdateCreatePolicyIntrinsics": boolean; | ||
| "@aws-cdk/aws-lambda-nodejs:sdkV3ExcludeSmithyPackages": boolean; | ||
| "@aws-cdk/aws-stepfunctions-tasks:fixRunEcsTaskPolicy": boolean; | ||
| "@aws-cdk/aws-ec2:bastionHostUseAmazonLinux2023ByDefault": boolean; | ||
| "@aws-cdk/aws-route53-targets:userPoolDomainNameMethodWithoutCustomResource": boolean; | ||
| "@aws-cdk/aws-elasticloadbalancingV2:albDualstackWithoutPublicIpv4SecurityGroupRulesDefault": boolean; | ||
| "@aws-cdk/aws-iam:oidcRejectUnauthorizedConnections": boolean; | ||
| "@aws-cdk/core:enableAdditionalMetadataCollection": boolean; | ||
| "@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy": boolean; | ||
| "@aws-cdk/aws-s3:setUniqueReplicationRoleName": boolean; | ||
| "@aws-cdk/aws-events:requireEventBusPolicySid": boolean; | ||
| "@aws-cdk/core:aspectPrioritiesMutating": boolean; | ||
| "@aws-cdk/aws-dynamodb:retainTableReplica": boolean; | ||
| "@aws-cdk/aws-stepfunctions:useDistributedMapResultWriterV2": boolean; | ||
| "@aws-cdk/s3-notifications:addS3TrustKeyPolicyForSnsSubscriptions": boolean; | ||
| "@aws-cdk/aws-ec2:requirePrivateSubnetsForEgressOnlyInternetGateway": boolean; | ||
| "@aws-cdk/aws-s3:publicAccessBlockedByDefault": boolean; | ||
| "@aws-cdk/aws-lambda:useCdkManagedLogGroup": boolean; | ||
| "@aws-cdk/aws-elasticloadbalancingv2:networkLoadBalancerWithSecurityGroupByDefault": boolean; | ||
| "@aws-cdk/aws-ecs-patterns:uniqueTargetGroupId": boolean; | ||
| "@aws-cdk/aws-route53-patterns:useDistribution": boolean; | ||
| "@aws-cdk/aws-cloudfront:defaultFunctionRuntimeV2_0": boolean; | ||
| "@aws-cdk/aws-elasticloadbalancingv2:usePostQuantumTlsPolicy": boolean; | ||
| "@aws-cdk/aws-batch:defaultToAL2023": boolean; | ||
| "@aws-cdk/core:annotationsInValidationReport": boolean; | ||
| }; | ||
| export interface SnapshotAndTestDefinition { | ||
| readonly testDefinition: IntegTestSuite | LegacyIntegTestSuite; | ||
| readonly snapshotDirectory: string; | ||
| } | ||
| //# sourceMappingURL=cdk-integ-helper.d.ts.map |
| {"version":3,"file":"cdk-integ-helper.d.ts","sourceRoot":"","sources":["cdk-integ-helper.ts"],"names":[],"mappings":"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"} |
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.DEFAULT_SYNTH_OPTIONS = exports.CdkIntegHelper = void 0; | ||
| exports.currentlyRecommendedAwsCdkLibFlags = currentlyRecommendedAwsCdkLibFlags; | ||
| /* eslint-disable @cdklabs/no-literal-partition */ | ||
| const path = require("path"); | ||
| const cloud_assembly_api_1 = require("@aws-cdk/cloud-assembly-api"); | ||
| const fs = require("fs-extra"); | ||
| const integ_test_suite_1 = require("./integ-test-suite"); | ||
| const recommendedFlagsFile = require("../recommended-feature-flags.json"); | ||
| const utils_1 = require("../utils"); | ||
| const engine_1 = require("./engine"); | ||
| const logger = require("../logger"); | ||
| const cloud_assembly_1 = require("./private/cloud-assembly"); | ||
| const integ_manifest_1 = require("./private/integ-manifest"); | ||
| const DESTRUCTIVE_CHANGES = '!!DESTRUCTIVE_CHANGES:'; | ||
| /** | ||
| * Class with some helper routines for running CDK snapshots and integration tests. | ||
| * | ||
| * A "golden snapshot" is the snapshot that is stored permanently in version | ||
| * control, that new runs are compared against (stored in a directory named | ||
| * `<test-name>.snapshot`). | ||
| * | ||
| * This is as opposed to other snapshots, which can be generated for example | ||
| * temporarily in a temporary directory, to compare agains the golden snapshot. | ||
| */ | ||
| class CdkIntegHelper { | ||
| /** | ||
| * Factory method to create an instance of the CdkIntegHelper. | ||
| * | ||
| * Hiding the constructor to prevent inheritance. | ||
| */ | ||
| static create(options) { | ||
| return new CdkIntegHelper(options); | ||
| } | ||
| /** | ||
| * The directory where the golden snapshot will be stored | ||
| */ | ||
| goldenSnapshotDir; | ||
| /** | ||
| * An instance of the CDK CLI | ||
| */ | ||
| cdk; | ||
| /** | ||
| * Pretty name of the test | ||
| */ | ||
| testName; | ||
| /** | ||
| * The value used in the '--app' CLI parameter | ||
| * | ||
| * Path to the integ test source file, relative to `this.directory`. | ||
| */ | ||
| cdkApp; | ||
| /** | ||
| * The path where the `cdk.context.json` file | ||
| * will be created | ||
| */ | ||
| cdkContextPath; | ||
| /** | ||
| * The working directory that the integration tests will be | ||
| * executed from | ||
| */ | ||
| directory; | ||
| /** | ||
| * The test to run | ||
| */ | ||
| test; | ||
| /** | ||
| * Default options to pass to the CDK CLI | ||
| */ | ||
| defaultArgs = { | ||
| pathMetadata: false, | ||
| assetMetadata: false, | ||
| versionReporting: false, | ||
| }; | ||
| /** | ||
| * The directory where the CDK will be synthed to | ||
| * | ||
| * Relative to cwd. | ||
| */ | ||
| cdkOutDir; | ||
| /** | ||
| * The profile to use for the CDK CLI calls | ||
| */ | ||
| profile; | ||
| /** | ||
| * Show output from the integ test run. | ||
| */ | ||
| showOutput; | ||
| _destructiveChanges; | ||
| legacyContext; | ||
| _expectedTestSuite; | ||
| _actualSnapshot; | ||
| _legacyEnableLookups; | ||
| /** | ||
| * Private constructor to prevent inheritance. | ||
| */ | ||
| constructor(options) { | ||
| this.test = options.test; | ||
| this.directory = this.test.directory; | ||
| this.testName = this.test.testName; | ||
| this.goldenSnapshotDir = this.test.snapshotDir; | ||
| this.cdkContextPath = path.join(this.directory, 'cdk.context.json'); | ||
| this.profile = options.profile; | ||
| this.showOutput = options.showOutput ?? false; | ||
| this.cdk = options.cdk ?? (0, engine_1.makeEngine)(options); | ||
| this.cdkOutDir = options.integOutDir ?? this.test.temporaryOutputDir; | ||
| const testRunCommand = this.test.appCommand; | ||
| this.cdkApp = testRunCommand.replace('{filePath}', path.relative(this.directory, this.test.fileName)); | ||
| } | ||
| /** | ||
| * Configure the legacy enableLookups value to use when generating the actual snapshot. | ||
| * | ||
| * Must be set before using snapshot methods. | ||
| */ | ||
| configureLegacyEnableLookups(enableLookups) { | ||
| this._legacyEnableLookups = enableLookups; | ||
| } | ||
| /** | ||
| * Return the list of actual (i.e. new) test cases for this integration test | ||
| */ | ||
| async actualTests() { | ||
| return (await this.actualTestSuite()).testSuite; | ||
| } | ||
| /** | ||
| * Generate a new "actual" snapshot which will be compared to the | ||
| * existing "expected" snapshot | ||
| * This will synth and then load the integration test manifest | ||
| */ | ||
| async generateActualSnapshot() { | ||
| await this.synthActualSnapshot(this.cdkOutDir); | ||
| const manifest = await this.loadManifest(this.cdkOutDir); | ||
| return { | ||
| testDefinition: manifest, | ||
| snapshotDirectory: this.cdkOutDir, | ||
| }; | ||
| } | ||
| /** | ||
| * Synth the actual application to the given directory, for purposes of generating/validating a snapshot | ||
| * | ||
| * `legacyEnableLookups` is to preserve historical behavior for a while: | ||
| * traditionally, the application would only be seeded with context if | ||
| * `enableLookups` was true, and this information would come from the test | ||
| * definition. | ||
| * | ||
| * - Since the test definition comes from inside the app, this requires a | ||
| * synth just to get the test definition, and then another synth to generate | ||
| * the actual snapshot with the correct context, which is time consuming. | ||
| * - Given that the context is fixed and fake, it could always have been passed. | ||
| * | ||
| * However, the snapshot contents themselves depend on the context flag, and changing | ||
| * this behavior now invalidates all snapshots everywhere, which is annoying for upgrading. | ||
| * | ||
| * So we will use the behavior from the GOLDEN SNAPSHOT's test definition to | ||
| * determine whether to pass the context, and if the new actual snapshot has a | ||
| * different value for `enableLookups`, we will throw away the old snapshot and synth again. | ||
| */ | ||
| async synthActualSnapshot(outputDirectory) { | ||
| if (this._legacyEnableLookups === undefined) { | ||
| throw new Error('Must call configureLegacyEnableLookups before generating snapshots'); | ||
| } | ||
| await this.cdk.synth({ | ||
| app: this.cdkApp, | ||
| context: this.getContext(this._legacyEnableLookups !== false ? exports.DEFAULT_SYNTH_OPTIONS.context : {}), | ||
| env: exports.DEFAULT_SYNTH_OPTIONS.env, | ||
| output: path.relative(this.directory, outputDirectory), | ||
| }); | ||
| } | ||
| actualSynthReproCommand() { | ||
| // Show the command necessary to repro this | ||
| const envSet = Object.entries(exports.DEFAULT_SYNTH_OPTIONS.env).map(([k, v]) => `${k}='${v}'`); | ||
| const envCmd = envSet.length > 0 ? ['env', ...envSet] : []; | ||
| return [ | ||
| ...envCmd, | ||
| 'cdk', | ||
| 'synth', | ||
| '-a', | ||
| `'${this.cdkApp}'`, | ||
| '-o', | ||
| `'${this.cdkOutDir}'`, | ||
| ...Object.entries(this.getContext(exports.DEFAULT_SYNTH_OPTIONS.context)).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : []), | ||
| ]; | ||
| } | ||
| /** | ||
| * Returns true if a snapshot already exists for this test | ||
| */ | ||
| hasSnapshot() { | ||
| return fs.existsSync(this.goldenSnapshotDir); | ||
| } | ||
| /** | ||
| * The test suite from the existing snapshot | ||
| */ | ||
| async expectedTestSuite() { | ||
| if (!this._expectedTestSuite && this.hasSnapshot()) { | ||
| this._expectedTestSuite = await this.loadManifest(); | ||
| } | ||
| return this._expectedTestSuite; | ||
| } | ||
| async actualSnapshot() { | ||
| if (!this._actualSnapshot) { | ||
| this._actualSnapshot = await this.generateActualSnapshot(); | ||
| // Check if the enableLookups value has changed between the golden | ||
| // snapshot and the actual snapshot. If it has, we need to re-synth the | ||
| // actual snapshot with the new enableLookups value. | ||
| // | ||
| // See `synthActualSnapshot` for a description of why this is necessary. | ||
| const actualEnableLookups = this._actualSnapshot.testDefinition.enableLookups ?? false; | ||
| if (actualEnableLookups !== this._legacyEnableLookups && this._legacyEnableLookups !== 'dont-care') { | ||
| this.configureLegacyEnableLookups(actualEnableLookups); | ||
| this._actualSnapshot = await this.generateActualSnapshot(); | ||
| } | ||
| } | ||
| return this._actualSnapshot; | ||
| } | ||
| /** | ||
| * The test suite from the new "actual" snapshot | ||
| */ | ||
| async actualTestSuite() { | ||
| return (await this.actualSnapshot()).testDefinition; | ||
| } | ||
| /** | ||
| * Load the integ manifest which contains information | ||
| * on how to execute the tests | ||
| * First we try and load the manifest from the integ manifest (i.e. integ.json) | ||
| * from the cloud assembly. If it doesn't exist, then we fallback to the | ||
| * "legacy mode" and create a manifest from pragma | ||
| */ | ||
| async loadManifest(dir) { | ||
| const manifest = dir ?? this.goldenSnapshotDir; | ||
| try { | ||
| const testSuite = integ_test_suite_1.IntegTestSuite.fromPath(manifest); | ||
| return testSuite; | ||
| } | ||
| catch (modernError) { | ||
| // Only attempt legacy test case if the integ test manifest was not found | ||
| // For any other errors, e.g. when parsing the manifest fails, we abort. | ||
| if (!(modernError instanceof integ_manifest_1.NoManifestError)) { | ||
| throw modernError; | ||
| } | ||
| if (this.showOutput) { | ||
| logger.trace("Failed to load integ test manifest for '%s'. Attempting as deprecated legacy test instead. Error was: %s", manifest, modernError.message ?? String(modernError)); | ||
| } | ||
| const testCases = await integ_test_suite_1.LegacyIntegTestSuite.fromLegacy({ | ||
| cdk: this.cdk, | ||
| testName: this.test.normalizedTestName, | ||
| integSourceFilePath: this.test.fileName, | ||
| listOptions: { | ||
| ...this.defaultArgs, | ||
| all: true, | ||
| app: this.cdkApp, | ||
| profile: this.profile, | ||
| output: path.relative(this.directory, this.cdkOutDir), | ||
| }, | ||
| }); | ||
| this.legacyContext = integ_test_suite_1.LegacyIntegTestSuite.getPragmaContext(this.test.fileName); | ||
| return testCases; | ||
| } | ||
| } | ||
| cleanup() { | ||
| const cdkOutPath = this.cdkOutDir; | ||
| if (fs.existsSync(cdkOutPath)) { | ||
| fs.removeSync(cdkOutPath); | ||
| } | ||
| // Clear cache | ||
| this._actualSnapshot = undefined; | ||
| } | ||
| /** | ||
| * If there are any destructive changes to a stack then this will record | ||
| * those in the manifest.json file | ||
| */ | ||
| renderTraceData() { | ||
| const traceData = new Map(); | ||
| const destructiveChanges = this._destructiveChanges ?? []; | ||
| destructiveChanges.forEach(change => { | ||
| const trace = traceData.get(change.stackName); | ||
| if (trace) { | ||
| trace.set(change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`); | ||
| } | ||
| else { | ||
| traceData.set(change.stackName, new Map([ | ||
| [change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`], | ||
| ])); | ||
| } | ||
| }); | ||
| return traceData; | ||
| } | ||
| /** | ||
| * In cases where we do not want to retain the assets, | ||
| * for example, if the assets are very large. | ||
| * | ||
| * Since it is possible to disable the update workflow for individual test | ||
| * cases, this needs to first get a list of stacks that have the update workflow | ||
| * disabled and then delete assets that relate to that stack. It does that | ||
| * by reading the asset manifest for the stack and deleting the asset source | ||
| */ | ||
| async removeAssetsFromSnapshot() { | ||
| const stacks = (await this.actualTestSuite()).getStacksWithoutUpdateWorkflow() ?? []; | ||
| const manifest = cloud_assembly_1.AssemblyManifestReader.fromPath(this.goldenSnapshotDir); | ||
| const assets = (0, utils_1.flatten)(stacks.map(stack => { | ||
| return manifest.getAssetLocationsForStack(stack) ?? []; | ||
| })); | ||
| assets.forEach(asset => { | ||
| const fileName = path.join(this.goldenSnapshotDir, asset); | ||
| if (fs.existsSync(fileName)) { | ||
| if (fs.lstatSync(fileName).isDirectory()) { | ||
| fs.removeSync(fileName); | ||
| } | ||
| else { | ||
| fs.unlinkSync(fileName); | ||
| } | ||
| } | ||
| }); | ||
| } | ||
| /** | ||
| * Remove the asset cache (.cache/) files from the snapshot. | ||
| * These are a cache of the asset zips, but we are fine with | ||
| * re-zipping on deploy | ||
| */ | ||
| removeAssetsCacheFromSnapshot() { | ||
| const files = fs.readdirSync(this.goldenSnapshotDir); | ||
| files.forEach(file => { | ||
| const fileName = path.join(this.goldenSnapshotDir, file); | ||
| if (fs.lstatSync(fileName).isDirectory() && file === '.cache') { | ||
| fs.emptyDirSync(fileName); | ||
| fs.rmdirSync(fileName); | ||
| } | ||
| }); | ||
| } | ||
| /** | ||
| * Create the new snapshot. | ||
| * | ||
| * If lookups are enabled, then we need create the snapshot by synth'ing again | ||
| * with the dummy context so that each time the test is run on different machines | ||
| * (and with different context/env) the diff will not change. | ||
| * | ||
| * If lookups are disabled (which means the stack is env agnostic) then just copy | ||
| * the assembly that was output by the deployment | ||
| */ | ||
| async createSnapshot() { | ||
| if (fs.existsSync(this.goldenSnapshotDir)) { | ||
| fs.removeSync(this.goldenSnapshotDir); | ||
| } | ||
| // TODO: If we're clever, we should be able to reuse the snapshot that was | ||
| // generated during the test invalidation check and avoid the below synth. | ||
| // But that gets run in a completely different lifecycle and it might not | ||
| // exist. We're not dealing with that just yet. | ||
| await this.synthActualSnapshot(this.goldenSnapshotDir); | ||
| await this.cleanupGoldenSnapshot(); | ||
| } | ||
| /** | ||
| * Perform some cleanup steps after the snapshot is created | ||
| * Anytime the snapshot needs to be modified after creation | ||
| * the logic should live here. | ||
| */ | ||
| async cleanupGoldenSnapshot() { | ||
| if (fs.existsSync(this.goldenSnapshotDir)) { | ||
| await this.removeAssetsFromSnapshot(); | ||
| this.removeAssetsCacheFromSnapshot(); | ||
| const assembly = cloud_assembly_1.AssemblyManifestReader.fromPath(this.goldenSnapshotDir); | ||
| assembly.cleanManifest(); | ||
| assembly.recordTrace(this.renderTraceData()); | ||
| } | ||
| // if this is a legacy test then create an integ manifest | ||
| // in the snapshot directory which can be used for the | ||
| // update workflow. Save any legacyContext as well so that it can be read | ||
| // the next time | ||
| const actualTestSuite = await this.actualTestSuite(); | ||
| if (actualTestSuite.type === 'legacy-test-suite') { | ||
| actualTestSuite.saveManifest(this.goldenSnapshotDir, this.legacyContext); | ||
| } | ||
| } | ||
| getContext(additionalContext) { | ||
| return { | ||
| ...currentlyRecommendedAwsCdkLibFlags(), | ||
| ...this.legacyContext, | ||
| ...additionalContext, | ||
| // Don't record creation stack traces in the snapshot, since they just take up space and are never deterministic. | ||
| 'aws:cdk:disable-creation-stack-traces': true, | ||
| // We originally had PLANNED to set this to ['aws', 'aws-cn'], but due to a programming mistake | ||
| // it was set to everything. In this PR, set it to everything to not mess up all the snapshots. | ||
| '@aws-cdk/core:target-partitions': undefined, | ||
| /* ---------------- THE FUTURE LIVES BELOW---------------------------- | ||
| // Restricting to these target partitions makes most service principals synthesize to | ||
| // `service.${URL_SUFFIX}`, which is technically *incorrect* (it's only `amazonaws.com` | ||
| // or `amazonaws.com.cn`, never UrlSuffix for any of the restricted regions) but it's what | ||
| // most existing integ tests contain, and we want to disturb as few as possible. | ||
| // [TARGET_PARTITIONS]: ['aws', 'aws-cn'], | ||
| /* ---------------- END OF THE FUTURE ------------------------------- */ | ||
| }; | ||
| } | ||
| } | ||
| exports.CdkIntegHelper = CdkIntegHelper; | ||
| // Default context we run all integ tests with, so they don't depend on the | ||
| // account of the exercising user. | ||
| exports.DEFAULT_SYNTH_OPTIONS = { | ||
| context: { | ||
| [cloud_assembly_api_1.AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY]: ['test-region-1a', 'test-region-1b', 'test-region-1c'], | ||
| 'availability-zones:account=12345678:region=test-region': ['test-region-1a', 'test-region-1b', 'test-region-1c'], | ||
| 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234', | ||
| 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234', | ||
| 'ssm:account=12345678:parameterName=/aws/service/ecs/optimized-ami/amazon-linux/recommended:region=test-region': '{"image_id": "ami-1234"}', | ||
| // eslint-disable-next-line @stylistic/max-len | ||
| 'ami:account=12345678:filters.image-type.0=machine:filters.name.0=amzn-ami-vpc-nat-*:filters.state.0=available:owners.0=amazon:region=test-region': 'ami-1234', | ||
| 'vpc-provider:account=12345678:filter.isDefault=true:region=test-region:returnAsymmetricSubnets=true': { | ||
| vpcId: 'vpc-60900905', | ||
| subnetGroups: [ | ||
| { | ||
| type: 'Public', | ||
| name: 'Public', | ||
| subnets: [ | ||
| { | ||
| subnetId: 'subnet-e19455ca', | ||
| availabilityZone: 'us-east-1a', | ||
| routeTableId: 'rtb-e19455ca', | ||
| }, | ||
| { | ||
| subnetId: 'subnet-e0c24797', | ||
| availabilityZone: 'us-east-1b', | ||
| routeTableId: 'rtb-e0c24797', | ||
| }, | ||
| { | ||
| subnetId: 'subnet-ccd77395', | ||
| availabilityZone: 'us-east-1c', | ||
| routeTableId: 'rtb-ccd77395', | ||
| }, | ||
| ], | ||
| }, | ||
| ], | ||
| }, | ||
| }, | ||
| env: { | ||
| CDK_INTEG_ACCOUNT: '12345678', | ||
| CDK_INTEG_REGION: 'test-region', | ||
| CDK_INTEG_HOSTED_ZONE_ID: 'Z23ABC4XYZL05B', | ||
| CDK_INTEG_HOSTED_ZONE_NAME: 'example.com', | ||
| CDK_INTEG_DOMAIN_NAME: '*.example.com', | ||
| CDK_INTEG_CERT_ARN: 'arn:aws:acm:test-region:12345678:certificate/86468209-a272-595d-b831-0efb6421265z', | ||
| CDK_INTEG_SUBNET_ID: 'subnet-0dff1a399d8f6f92c', | ||
| }, | ||
| }; | ||
| /** | ||
| * Return the currently recommended flags for `aws-cdk-lib`. | ||
| * | ||
| * These have been built into the CLI at build time. If this ever gets changed | ||
| * back to a dynamic load, remember that this source file may be bundled into | ||
| * a JavaScript bundle, and `__dirname` might not point where you think it does. | ||
| */ | ||
| function currentlyRecommendedAwsCdkLibFlags() { | ||
| return recommendedFlagsFile; | ||
| } | ||
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-integ-helper.js","sourceRoot":"","sources":["cdk-integ-helper.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @cdklabs/no-literal-partition */\nimport * as path from 'path';\nimport { AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY } from '@aws-cdk/cloud-assembly-api';\nimport type { TestCase, DefaultCdkOptions } from '@aws-cdk/cloud-assembly-schema';\nimport * as fs from 'fs-extra';\nimport { IntegTestSuite, LegacyIntegTestSuite } from './integ-test-suite';\nimport type { IntegTest } from './integration-tests';\nimport * as recommendedFlagsFile from '../recommended-feature-flags.json';\nimport { flatten } from '../utils';\nimport { makeEngine } from './engine';\nimport type { ICdk } from '../engines/cdk-interface';\nimport * as logger from '../logger';\nimport type { ManifestTrace } from './private/cloud-assembly';\nimport { AssemblyManifestReader } from './private/cloud-assembly';\nimport type { DestructiveChange } from '../workers/common';\nimport { NoManifestError } from './private/integ-manifest';\n\nconst DESTRUCTIVE_CHANGES = '!!DESTRUCTIVE_CHANGES:';\n\n/**\n * Options for creating an integ helper\n */\nexport interface CdkIntegHelperOptions {\n  /**\n   * Information about the test to run\n   */\n  readonly test: IntegTest;\n\n  /**\n   * The region where the test should be deployed\n   */\n  readonly region: string;\n\n  /**\n   * The AWS profile to use when invoking the CDK CLI\n   *\n   * @default - no profile is passed, the default profile is used\n   */\n  readonly profile?: string;\n\n  /**\n   * Additional environment variables that will be available\n   * to the CDK CLI\n   *\n   * @default - no additional environment variables\n   */\n  readonly env?: { [name: string]: string };\n\n  /**\n   * tmp cdk.out directory\n   *\n   * @default - directory will be `cdk-integ.out.${testName}`\n   */\n  readonly integOutDir?: string;\n\n  /**\n   * Instance of the CDK Toolkit Engine to use\n   *\n   * @default - based on `engine` option\n   */\n  readonly cdk?: ICdk;\n\n  /**\n   * Show output from running integration tests\n   *\n   * @default false\n   */\n  readonly showOutput?: boolean;\n\n  /**\n   * Use the indicated proxy\n   *\n   * @default - no proxy\n   */\n  readonly proxy?: string;\n\n  /**\n   * Path to CA certificate to use when validating HTTPS requests\n   *\n   * @default - no additional CA bundle\n   */\n  readonly caBundlePath?: string;\n}\n\n/**\n * Whether to synthesize the actual snapshot with lookups enabled or not.\n *\n * If either `true` or `false`, we send context in or not while synthesizing,\n * and if the generated snapshot test definition requests a different value we\n * will synth again.\n *\n * For `dont-care`, we do send in the context but we never resynth.\n */\nexport type LegacyEnableLookups = true | false | 'dont-care';\n\n/**\n * Class with some helper routines for running CDK snapshots and integration tests.\n *\n * A \"golden snapshot\" is the snapshot that is stored permanently in version\n * control, that new runs are compared against (stored in a directory named\n * `<test-name>.snapshot`).\n *\n * This is as opposed to other snapshots, which can be generated for example\n * temporarily in a temporary directory, to compare agains the golden snapshot.\n */\nexport class CdkIntegHelper {\n  /**\n   * Factory method to create an instance of the CdkIntegHelper.\n   *\n   * Hiding the constructor to prevent inheritance.\n   */\n  public static create(options: CdkIntegHelperOptions) {\n    return new CdkIntegHelper(options);\n  }\n\n  /**\n   * The directory where the golden snapshot will be stored\n   */\n  public readonly goldenSnapshotDir: string;\n\n  /**\n   * An instance of the CDK  CLI\n   */\n  public readonly cdk: ICdk;\n\n  /**\n   * Pretty name of the test\n   */\n  public readonly testName: string;\n\n  /**\n   * The value used in the '--app' CLI parameter\n   *\n   * Path to the integ test source file, relative to `this.directory`.\n   */\n  public readonly cdkApp: string;\n\n  /**\n   * The path where the `cdk.context.json` file\n   * will be created\n   */\n  public readonly cdkContextPath: string;\n\n  /**\n   * The working directory that the integration tests will be\n   * executed from\n   */\n  public readonly directory: string;\n\n  /**\n   * The test to run\n   */\n  private readonly test: IntegTest;\n\n  /**\n   * Default options to pass to the CDK CLI\n   */\n  public readonly defaultArgs: DefaultCdkOptions = {\n    pathMetadata: false,\n    assetMetadata: false,\n    versionReporting: false,\n  };\n\n  /**\n   * The directory where the CDK will be synthed to\n   *\n   * Relative to cwd.\n   */\n  public readonly cdkOutDir: string;\n\n  /**\n   * The profile to use for the CDK CLI calls\n   */\n  public readonly profile?: string;\n\n  /**\n   * Show output from the integ test run.\n   */\n  private readonly showOutput: boolean;\n\n  public _destructiveChanges?: DestructiveChange[];\n  private legacyContext?: Record<string, any>;\n  private _expectedTestSuite?: IntegTestSuite | LegacyIntegTestSuite;\n  private _actualSnapshot?: SnapshotAndTestDefinition;\n  private _legacyEnableLookups?: LegacyEnableLookups;\n\n  /**\n   * Private constructor to prevent inheritance.\n   */\n  private constructor(options: CdkIntegHelperOptions) {\n    this.test = options.test;\n    this.directory = this.test.directory;\n    this.testName = this.test.testName;\n    this.goldenSnapshotDir = this.test.snapshotDir;\n    this.cdkContextPath = path.join(this.directory, 'cdk.context.json');\n    this.profile = options.profile;\n    this.showOutput = options.showOutput ?? false;\n\n    this.cdk = options.cdk ?? makeEngine(options);\n    this.cdkOutDir = options.integOutDir ?? this.test.temporaryOutputDir;\n\n    const testRunCommand = this.test.appCommand;\n    this.cdkApp = testRunCommand.replace('{filePath}', path.relative(this.directory, this.test.fileName));\n  }\n\n  /**\n   * Configure the legacy enableLookups value to use when generating the actual snapshot.\n   *\n   * Must be set before using snapshot methods.\n   */\n  public configureLegacyEnableLookups(enableLookups: LegacyEnableLookups): void {\n    this._legacyEnableLookups = enableLookups;\n  }\n\n  /**\n   * Return the list of actual (i.e. new) test cases for this integration test\n   */\n  public async actualTests(): Promise<{ [testName: string]: TestCase } | undefined> {\n    return (await this.actualTestSuite()).testSuite;\n  }\n\n  /**\n   * Generate a new \"actual\" snapshot which will be compared to the\n   * existing \"expected\" snapshot\n   * This will synth and then load the integration test manifest\n   */\n  private async generateActualSnapshot(): Promise<SnapshotAndTestDefinition> {\n    await this.synthActualSnapshot(this.cdkOutDir);\n    const manifest = await this.loadManifest(this.cdkOutDir);\n    return {\n      testDefinition: manifest,\n      snapshotDirectory: this.cdkOutDir,\n    };\n  }\n\n  /**\n   * Synth the actual application to the given directory, for purposes of generating/validating a snapshot\n   *\n   * `legacyEnableLookups` is to preserve historical behavior for a while:\n   * traditionally, the application would only be seeded with context if\n   * `enableLookups` was true, and this information would come from the test\n   * definition.\n   *\n   * - Since the test definition comes from inside the app, this requires a\n   *   synth just to get the test definition, and then another synth to generate\n   *   the actual snapshot with the correct context, which is time consuming.\n   * - Given that the context is fixed and fake, it could always have been passed.\n   *\n   * However, the snapshot contents themselves depend on the context flag, and changing\n   * this behavior now invalidates all snapshots everywhere, which is annoying for upgrading.\n   *\n   * So we will use the behavior from the GOLDEN SNAPSHOT's test definition to\n   * determine whether to pass the context, and if the new actual snapshot has a\n   * different value for `enableLookups`, we will throw away the old snapshot and synth again.\n   */\n  private async synthActualSnapshot(outputDirectory: string): Promise<void> {\n    if (this._legacyEnableLookups === undefined) {\n      throw new Error('Must call configureLegacyEnableLookups before generating snapshots');\n    }\n\n    await this.cdk.synth({\n      app: this.cdkApp,\n      context: this.getContext(this._legacyEnableLookups !== false ? DEFAULT_SYNTH_OPTIONS.context : {}),\n      env: DEFAULT_SYNTH_OPTIONS.env,\n      output: path.relative(this.directory, outputDirectory),\n    });\n  }\n\n  public actualSynthReproCommand() {\n    // Show the command necessary to repro this\n    const envSet = Object.entries(DEFAULT_SYNTH_OPTIONS.env).map(([k, v]) => `${k}='${v}'`);\n    const envCmd = envSet.length > 0 ? ['env', ...envSet] : [];\n\n    return [\n      ...envCmd,\n      'cdk',\n      'synth',\n      '-a',\n      `'${this.cdkApp}'`,\n      '-o',\n      `'${this.cdkOutDir}'`,\n      ...Object.entries(this.getContext(DEFAULT_SYNTH_OPTIONS.context)).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : []),\n    ];\n  }\n\n  /**\n   * Returns true if a snapshot already exists for this test\n   */\n  public hasSnapshot(): boolean {\n    return fs.existsSync(this.goldenSnapshotDir);\n  }\n\n  /**\n   * The test suite from the existing snapshot\n   */\n  public async expectedTestSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite | undefined> {\n    if (!this._expectedTestSuite && this.hasSnapshot()) {\n      this._expectedTestSuite = await this.loadManifest();\n    }\n    return this._expectedTestSuite;\n  }\n\n  public async actualSnapshot(): Promise<SnapshotAndTestDefinition> {\n    if (!this._actualSnapshot) {\n      this._actualSnapshot = await this.generateActualSnapshot();\n\n      // Check if the enableLookups value has changed between the golden\n      // snapshot and the actual snapshot. If it has, we need to re-synth the\n      // actual snapshot with the new enableLookups value.\n      //\n      // See `synthActualSnapshot` for a description of why this is necessary.\n      const actualEnableLookups = this._actualSnapshot.testDefinition.enableLookups ?? false;\n      if (actualEnableLookups !== this._legacyEnableLookups && this._legacyEnableLookups !== 'dont-care') {\n        this.configureLegacyEnableLookups(actualEnableLookups);\n        this._actualSnapshot = await this.generateActualSnapshot();\n      }\n    }\n    return this._actualSnapshot;\n  }\n\n  /**\n   * The test suite from the new \"actual\" snapshot\n   */\n  private async actualTestSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    return (await this.actualSnapshot()).testDefinition;\n  }\n\n  /**\n   * Load the integ manifest which contains information\n   * on how to execute the tests\n   * First we try and load the manifest from the integ manifest (i.e. integ.json)\n   * from the cloud assembly. If it doesn't exist, then we fallback to the\n   * \"legacy mode\" and create a manifest from pragma\n   */\n  public async loadManifest(dir?: string): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    const manifest = dir ?? this.goldenSnapshotDir;\n    try {\n      const testSuite = IntegTestSuite.fromPath(manifest);\n      return testSuite;\n    } catch (modernError: any) {\n      // Only attempt legacy test case if the integ test manifest was not found\n      // For any other errors, e.g. when parsing the manifest fails, we abort.\n      if (!(modernError instanceof NoManifestError)) {\n        throw modernError;\n      }\n\n      if (this.showOutput) {\n        logger.trace(\n          \"Failed to load integ test manifest for '%s'. Attempting as deprecated legacy test instead. Error was: %s\",\n          manifest,\n          modernError.message ?? String(modernError),\n        );\n      }\n\n      const testCases = await LegacyIntegTestSuite.fromLegacy({\n        cdk: this.cdk,\n        testName: this.test.normalizedTestName,\n        integSourceFilePath: this.test.fileName,\n        listOptions: {\n          ...this.defaultArgs,\n          all: true,\n          app: this.cdkApp,\n          profile: this.profile,\n          output: path.relative(this.directory, this.cdkOutDir),\n        },\n      });\n      this.legacyContext = LegacyIntegTestSuite.getPragmaContext(this.test.fileName);\n      return testCases;\n    }\n  }\n\n  public cleanup(): void {\n    const cdkOutPath = this.cdkOutDir;\n    if (fs.existsSync(cdkOutPath)) {\n      fs.removeSync(cdkOutPath);\n    }\n    // Clear cache\n    this._actualSnapshot = undefined;\n  }\n\n  /**\n   * If there are any destructive changes to a stack then this will record\n   * those in the manifest.json file\n   */\n  private renderTraceData(): ManifestTrace {\n    const traceData: ManifestTrace = new Map();\n    const destructiveChanges = this._destructiveChanges ?? [];\n    destructiveChanges.forEach(change => {\n      const trace = traceData.get(change.stackName);\n      if (trace) {\n        trace.set(change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`);\n      } else {\n        traceData.set(change.stackName, new Map([\n          [change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`],\n        ]));\n      }\n    });\n    return traceData;\n  }\n\n  /**\n   * In cases where we do not want to retain the assets,\n   * for example, if the assets are very large.\n   *\n   * Since it is possible to disable the update workflow for individual test\n   * cases, this needs to first get a list of stacks that have the update workflow\n   * disabled and then delete assets that relate to that stack. It does that\n   * by reading the asset manifest for the stack and deleting the asset source\n   */\n  private async removeAssetsFromSnapshot(): Promise<void> {\n    const stacks = (await this.actualTestSuite()).getStacksWithoutUpdateWorkflow() ?? [];\n    const manifest = AssemblyManifestReader.fromPath(this.goldenSnapshotDir);\n    const assets = flatten(stacks.map(stack => {\n      return manifest.getAssetLocationsForStack(stack) ?? [];\n    }));\n\n    assets.forEach(asset => {\n      const fileName = path.join(this.goldenSnapshotDir, asset);\n      if (fs.existsSync(fileName)) {\n        if (fs.lstatSync(fileName).isDirectory()) {\n          fs.removeSync(fileName);\n        } else {\n          fs.unlinkSync(fileName);\n        }\n      }\n    });\n  }\n\n  /**\n   * Remove the asset cache (.cache/) files from the snapshot.\n   * These are a cache of the asset zips, but we are fine with\n   * re-zipping on deploy\n   */\n  private removeAssetsCacheFromSnapshot(): void {\n    const files = fs.readdirSync(this.goldenSnapshotDir);\n    files.forEach(file => {\n      const fileName = path.join(this.goldenSnapshotDir, file);\n      if (fs.lstatSync(fileName).isDirectory() && file === '.cache') {\n        fs.emptyDirSync(fileName);\n        fs.rmdirSync(fileName);\n      }\n    });\n  }\n\n  /**\n   * Create the new snapshot.\n   *\n   * If lookups are enabled, then we need create the snapshot by synth'ing again\n   * with the dummy context so that each time the test is run on different machines\n   * (and with different context/env) the diff will not change.\n   *\n   * If lookups are disabled (which means the stack is env agnostic) then just copy\n   * the assembly that was output by the deployment\n   */\n  public async createSnapshot(): Promise<void> {\n    if (fs.existsSync(this.goldenSnapshotDir)) {\n      fs.removeSync(this.goldenSnapshotDir);\n    }\n\n    // TODO: If we're clever, we should be able to reuse the snapshot that was\n    // generated during the test invalidation check and avoid the below synth.\n    // But that gets run in a completely different lifecycle and it might not\n    // exist. We're not dealing with that just yet.\n    await this.synthActualSnapshot(this.goldenSnapshotDir);\n\n    await this.cleanupGoldenSnapshot();\n  }\n\n  /**\n   * Perform some cleanup steps after the snapshot is created\n   * Anytime the snapshot needs to be modified after creation\n   * the logic should live here.\n   */\n  private async cleanupGoldenSnapshot(): Promise<void> {\n    if (fs.existsSync(this.goldenSnapshotDir)) {\n      await this.removeAssetsFromSnapshot();\n      this.removeAssetsCacheFromSnapshot();\n      const assembly = AssemblyManifestReader.fromPath(this.goldenSnapshotDir);\n      assembly.cleanManifest();\n      assembly.recordTrace(this.renderTraceData());\n    }\n\n    // if this is a legacy test then create an integ manifest\n    // in the snapshot directory which can be used for the\n    // update workflow. Save any legacyContext as well so that it can be read\n    // the next time\n    const actualTestSuite = await this.actualTestSuite();\n    if (actualTestSuite.type === 'legacy-test-suite') {\n      (actualTestSuite as LegacyIntegTestSuite).saveManifest(this.goldenSnapshotDir, this.legacyContext);\n    }\n  }\n\n  public getContext(additionalContext?: Record<string, any>): Record<string, any> {\n    return {\n      ...currentlyRecommendedAwsCdkLibFlags(),\n      ...this.legacyContext,\n      ...additionalContext,\n\n      // Don't record creation stack traces in the snapshot, since they just take up space and are never deterministic.\n      'aws:cdk:disable-creation-stack-traces': true,\n\n      // We originally had PLANNED to set this to ['aws', 'aws-cn'], but due to a programming mistake\n      // it was set to everything. In this PR, set it to everything to not mess up all the snapshots.\n      '@aws-cdk/core:target-partitions': undefined,\n\n      /* ---------------- THE FUTURE LIVES BELOW----------------------------\n      // Restricting to these target partitions makes most service principals synthesize to\n      // `service.${URL_SUFFIX}`, which is technically *incorrect* (it's only `amazonaws.com`\n      // or `amazonaws.com.cn`, never UrlSuffix for any of the restricted regions) but it's what\n      // most existing integ tests contain, and we want to disturb as few as possible.\n      // [TARGET_PARTITIONS]: ['aws', 'aws-cn'],\n      /* ---------------- END OF THE FUTURE ------------------------------- */\n    };\n  }\n}\n\n// Default context we run all integ tests with, so they don't depend on the\n// account of the exercising user.\nexport const DEFAULT_SYNTH_OPTIONS = {\n  context: {\n    [AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY]: ['test-region-1a', 'test-region-1b', 'test-region-1c'],\n    'availability-zones:account=12345678:region=test-region': ['test-region-1a', 'test-region-1b', 'test-region-1c'],\n    'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234',\n    'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234',\n    'ssm:account=12345678:parameterName=/aws/service/ecs/optimized-ami/amazon-linux/recommended:region=test-region': '{\"image_id\": \"ami-1234\"}',\n    // eslint-disable-next-line @stylistic/max-len\n    'ami:account=12345678:filters.image-type.0=machine:filters.name.0=amzn-ami-vpc-nat-*:filters.state.0=available:owners.0=amazon:region=test-region': 'ami-1234',\n    'vpc-provider:account=12345678:filter.isDefault=true:region=test-region:returnAsymmetricSubnets=true': {\n      vpcId: 'vpc-60900905',\n      subnetGroups: [\n        {\n          type: 'Public',\n          name: 'Public',\n          subnets: [\n            {\n              subnetId: 'subnet-e19455ca',\n              availabilityZone: 'us-east-1a',\n              routeTableId: 'rtb-e19455ca',\n            },\n            {\n              subnetId: 'subnet-e0c24797',\n              availabilityZone: 'us-east-1b',\n              routeTableId: 'rtb-e0c24797',\n            },\n            {\n              subnetId: 'subnet-ccd77395',\n              availabilityZone: 'us-east-1c',\n              routeTableId: 'rtb-ccd77395',\n            },\n          ],\n        },\n      ],\n    },\n  },\n  env: {\n    CDK_INTEG_ACCOUNT: '12345678',\n    CDK_INTEG_REGION: 'test-region',\n    CDK_INTEG_HOSTED_ZONE_ID: 'Z23ABC4XYZL05B',\n    CDK_INTEG_HOSTED_ZONE_NAME: 'example.com',\n    CDK_INTEG_DOMAIN_NAME: '*.example.com',\n    CDK_INTEG_CERT_ARN: 'arn:aws:acm:test-region:12345678:certificate/86468209-a272-595d-b831-0efb6421265z',\n    CDK_INTEG_SUBNET_ID: 'subnet-0dff1a399d8f6f92c',\n  },\n};\n\n/**\n * Return the currently recommended flags for `aws-cdk-lib`.\n *\n * These have been built into the CLI at build time. If this ever gets changed\n * back to a dynamic load, remember that this source file may be bundled into\n * a JavaScript bundle, and `__dirname` might not point where you think it does.\n */\nexport function currentlyRecommendedAwsCdkLibFlags() {\n  return recommendedFlagsFile;\n}\n\nexport interface SnapshotAndTestDefinition {\n  readonly testDefinition: IntegTestSuite | LegacyIntegTestSuite;\n  readonly snapshotDirectory: string;\n}\n"]} |
@@ -1,2 +0,2 @@ | ||
| import type { IntegRunnerOptions } from './runner-base'; | ||
| import type { CdkIntegHelperOptions } from './cdk-integ-helper'; | ||
| import { ToolkitLibRunnerEngine } from '../engines/toolkit-lib'; | ||
@@ -8,3 +8,4 @@ /** | ||
| */ | ||
| export declare function makeEngine(options: IntegRunnerOptions): ToolkitLibRunnerEngine; | ||
| export declare function makeEngine(options: EngineOptions): ToolkitLibRunnerEngine; | ||
| export type EngineOptions = Pick<CdkIntegHelperOptions, 'test' | 'showOutput' | 'env' | 'region' | 'profile' | 'proxy' | 'caBundlePath'>; | ||
| //# sourceMappingURL=engine.d.ts.map |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,kBAAkB,GAAG,sBAAsB,CAU9E"} | ||
| {"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,sBAAsB,CAUzE;AAED,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,qBAAqB,EAAE,MAAM,GAAG,YAAY,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,cAAc,CAAC,CAAC"} |
@@ -21,2 +21,2 @@ "use strict"; | ||
| } | ||
| //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5naW5lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZW5naW5lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBUUEsZ0NBVUM7QUFqQkQsd0RBQWdFO0FBRWhFOzs7O0dBSUc7QUFDSCxTQUFnQixVQUFVLENBQUMsT0FBMkI7SUFDcEQsT0FBTyxJQUFJLG9DQUFzQixDQUFDO1FBQ2hDLGdCQUFnQixFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUztRQUN4QyxVQUFVLEVBQUUsT0FBTyxDQUFDLFVBQVU7UUFDOUIsR0FBRyxFQUFFLE9BQU8sQ0FBQyxHQUFHO1FBQ2hCLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTTtRQUN0QixPQUFPLEVBQUUsT0FBTyxDQUFDLE9BQU87UUFDeEIsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLO1FBQ3BCLFlBQVksRUFBRSxPQUFPLENBQUMsWUFBWTtLQUNuQyxDQUFDLENBQUM7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBJbnRlZ1J1bm5lck9wdGlvbnMgfSBmcm9tICcuL3J1bm5lci1iYXNlJztcbmltcG9ydCB7IFRvb2xraXRMaWJSdW5uZXJFbmdpbmUgfSBmcm9tICcuLi9lbmdpbmVzL3Rvb2xraXQtbGliJztcblxuLyoqXG4gKiBDcmVhdGVzIHRoZSBlbmdpbmUgZm9yIHJ1bm5pbmcgaW50ZWdyYXRpb24gdGVzdHMuXG4gKlxuICogT25seSB0aGUgdG9vbGtpdC1saWIgZW5naW5lIGlzIHN1cHBvcnRlZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG1ha2VFbmdpbmUob3B0aW9uczogSW50ZWdSdW5uZXJPcHRpb25zKTogVG9vbGtpdExpYlJ1bm5lckVuZ2luZSB7XG4gIHJldHVybiBuZXcgVG9vbGtpdExpYlJ1bm5lckVuZ2luZSh7XG4gICAgd29ya2luZ0RpcmVjdG9yeTogb3B0aW9ucy50ZXN0LmRpcmVjdG9yeSxcbiAgICBzaG93T3V0cHV0OiBvcHRpb25zLnNob3dPdXRwdXQsXG4gICAgZW52OiBvcHRpb25zLmVudixcbiAgICByZWdpb246IG9wdGlvbnMucmVnaW9uLFxuICAgIHByb2ZpbGU6IG9wdGlvbnMucHJvZmlsZSxcbiAgICBwcm94eTogb3B0aW9ucy5wcm94eSxcbiAgICBjYUJ1bmRsZVBhdGg6IG9wdGlvbnMuY2FCdW5kbGVQYXRoLFxuICB9KTtcbn1cbiJdfQ== | ||
| //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5naW5lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZW5naW5lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBUUEsZ0NBVUM7QUFqQkQsd0RBQWdFO0FBRWhFOzs7O0dBSUc7QUFDSCxTQUFnQixVQUFVLENBQUMsT0FBc0I7SUFDL0MsT0FBTyxJQUFJLG9DQUFzQixDQUFDO1FBQ2hDLGdCQUFnQixFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUztRQUN4QyxVQUFVLEVBQUUsT0FBTyxDQUFDLFVBQVU7UUFDOUIsR0FBRyxFQUFFLE9BQU8sQ0FBQyxHQUFHO1FBQ2hCLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTTtRQUN0QixPQUFPLEVBQUUsT0FBTyxDQUFDLE9BQU87UUFDeEIsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLO1FBQ3BCLFlBQVksRUFBRSxPQUFPLENBQUMsWUFBWTtLQUNuQyxDQUFDLENBQUM7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBDZGtJbnRlZ0hlbHBlck9wdGlvbnMgfSBmcm9tICcuL2Nkay1pbnRlZy1oZWxwZXInO1xuaW1wb3J0IHsgVG9vbGtpdExpYlJ1bm5lckVuZ2luZSB9IGZyb20gJy4uL2VuZ2luZXMvdG9vbGtpdC1saWInO1xuXG4vKipcbiAqIENyZWF0ZXMgdGhlIGVuZ2luZSBmb3IgcnVubmluZyBpbnRlZ3JhdGlvbiB0ZXN0cy5cbiAqXG4gKiBPbmx5IHRoZSB0b29sa2l0LWxpYiBlbmdpbmUgaXMgc3VwcG9ydGVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gbWFrZUVuZ2luZShvcHRpb25zOiBFbmdpbmVPcHRpb25zKTogVG9vbGtpdExpYlJ1bm5lckVuZ2luZSB7XG4gIHJldHVybiBuZXcgVG9vbGtpdExpYlJ1bm5lckVuZ2luZSh7XG4gICAgd29ya2luZ0RpcmVjdG9yeTogb3B0aW9ucy50ZXN0LmRpcmVjdG9yeSxcbiAgICBzaG93T3V0cHV0OiBvcHRpb25zLnNob3dPdXRwdXQsXG4gICAgZW52OiBvcHRpb25zLmVudixcbiAgICByZWdpb246IG9wdGlvbnMucmVnaW9uLFxuICAgIHByb2ZpbGU6IG9wdGlvbnMucHJvZmlsZSxcbiAgICBwcm94eTogb3B0aW9ucy5wcm94eSxcbiAgICBjYUJ1bmRsZVBhdGg6IG9wdGlvbnMuY2FCdW5kbGVQYXRoLFxuICB9KTtcbn1cblxuZXhwb3J0IHR5cGUgRW5naW5lT3B0aW9ucyA9IFBpY2s8Q2RrSW50ZWdIZWxwZXJPcHRpb25zLCAndGVzdCcgfCAnc2hvd091dHB1dCcgfCAnZW52JyB8ICdyZWdpb24nIHwgJ3Byb2ZpbGUnIHwgJ3Byb3h5JyB8ICdjYUJ1bmRsZVBhdGgnPjtcbiJdfQ== |
@@ -1,2 +0,2 @@ | ||
| export * from './runner-base'; | ||
| export * from './cdk-integ-helper'; | ||
| export * from './integ-test-suite'; | ||
@@ -3,0 +3,0 @@ export * from './integ-test-runner'; |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC"} | ||
| {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC"} |
@@ -17,3 +17,3 @@ "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| __exportStar(require("./runner-base"), exports); | ||
| __exportStar(require("./cdk-integ-helper"), exports); | ||
| __exportStar(require("./integ-test-suite"), exports); | ||
@@ -23,2 +23,2 @@ __exportStar(require("./integ-test-runner"), exports); | ||
| __exportStar(require("./integration-tests"), exports); | ||
| //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0RBQThCO0FBQzlCLHFEQUFtQztBQUNuQyxzREFBb0M7QUFDcEMseURBQXVDO0FBQ3ZDLHNEQUFvQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcnVubmVyLWJhc2UnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlZy10ZXN0LXN1aXRlJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZWctdGVzdC1ydW5uZXInO1xuZXhwb3J0ICogZnJvbSAnLi9zbmFwc2hvdC10ZXN0LXJ1bm5lcic7XG5leHBvcnQgKiBmcm9tICcuL2ludGVncmF0aW9uLXRlc3RzJztcbiJdfQ== | ||
| //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEscURBQW1DO0FBQ25DLHFEQUFtQztBQUNuQyxzREFBb0M7QUFDcEMseURBQXVDO0FBQ3ZDLHNEQUFvQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2RrLWludGVnLWhlbHBlcic7XG5leHBvcnQgKiBmcm9tICcuL2ludGVnLXRlc3Qtc3VpdGUnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlZy10ZXN0LXJ1bm5lcic7XG5leHBvcnQgKiBmcm9tICcuL3NuYXBzaG90LXRlc3QtcnVubmVyJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZWdyYXRpb24tdGVzdHMnO1xuIl19 |
| import type { TestCase } from '@aws-cdk/cloud-assembly-schema'; | ||
| import type { IntegRunnerOptions } from './runner-base'; | ||
| import { IntegRunner } from './runner-base'; | ||
| import type { CdkIntegHelperOptions } from './cdk-integ-helper'; | ||
| import type { DestructiveChange, AssertionResults } from '../workers/common'; | ||
@@ -86,4 +85,13 @@ export interface CommonOptions { | ||
| */ | ||
| export declare class IntegTestRunner extends IntegRunner { | ||
| constructor(options: IntegRunnerOptions, destructiveChanges?: DestructiveChange[]); | ||
| export declare class IntegTestRunner { | ||
| private readonly helper; | ||
| constructor(options: CdkIntegHelperOptions, destructiveChanges?: DestructiveChange[]); | ||
| /** | ||
| * Compatibility shim with old API | ||
| */ | ||
| get testName(): string; | ||
| /** | ||
| * Compatibility shim with old API | ||
| */ | ||
| private actualTestSuite; | ||
| actualTests(): Promise<{ | ||
@@ -90,0 +98,0 @@ [testName: string]: TestCase; |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"integ-test-runner.d.ts","sourceRoot":"","sources":["integ-test-runner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAkB,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAM/E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAmB,MAAM,mBAAmB,CAAC;AAkB9F,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,UAAW,SAAQ,aAAa;IAC/C;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;;;;OAQG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAE1B;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAElC;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;;;;OAOG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACxC;AAED;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,WAAW;gBAClC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,CAAC,EAAE,iBAAiB,EAAE;IAKpE,WAAW,IAAI,OAAO,CAAC;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAA;KAAE,GAAG,SAAS,CAAC;IAe1E,oBAAoB,IAAI,IAAI;IAQnC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAgB7B;;;OAGG;YACW,cAAc;IAgD5B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,gBAAgB;IAgDxB;;;;OAIG;IACU,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAmCjE;;;;;;;;;;OAUG;IACU,gBAAgB,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAgEzF;;OAEG;YACW,OAAO;YA6BP,KAAK;IA0InB;;;OAGG;YACW,MAAM;IA8GpB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAiC/B;;OAEG;IACH,OAAO,CAAC,UAAU;CAYnB"} | ||
| {"version":3,"file":"integ-test-runner.d.ts","sourceRoot":"","sources":["integ-test-runner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAkB,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAM/E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAKhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAmB,MAAM,mBAAmB,CAAC;AAkB9F,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,UAAW,SAAQ,aAAa;IAC/C;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;;;;OAQG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAE1B;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAElC;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;;;;OAOG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACxC;AAED;;;GAGG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;gBAC5B,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,CAAC,EAAE,iBAAiB,EAAE;IAepF;;OAEG;IACH,IAAW,QAAQ,WAElB;IAED;;OAEG;YACW,eAAe;IAIhB,WAAW,IAAI,OAAO,CAAC;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAA;KAAE,GAAG,SAAS,CAAC;IAe1E,oBAAoB,IAAI,IAAI;IAQnC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAgB7B;;;OAGG;YACW,cAAc;IAgD5B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,gBAAgB;IAgDxB;;;;OAIG;IACU,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAmCjE;;;;;;;;;;OAUG;IACU,gBAAgB,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IA0EzF;;OAEG;YACW,OAAO;YA6BP,KAAK;IA0InB;;;OAGG;YACW,MAAM;IA8GpB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAiC/B;;OAEG;IACH,OAAO,CAAC,UAAU;CAYnB"} |
@@ -1,2 +0,1 @@ | ||
| import { AssetManifest } from '@aws-cdk/cdk-assets-lib'; | ||
| import type { AssemblyManifest } from '@aws-cdk/cloud-assembly-schema'; | ||
@@ -61,3 +60,3 @@ /** | ||
| */ | ||
| getAssetManifestsForStack(stackId: string): AssetManifest[]; | ||
| private getAssetManifestsForStack; | ||
| /** | ||
@@ -64,0 +63,0 @@ * Get a list of assets from the assembly manifest |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"cloud-assembly.d.ts","sourceRoot":"","sources":["cloud-assembly.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,KAAK,EAAE,gBAAgB,EAAwJ,MAAM,gCAAgC,CAAC;AAI7N;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE7C;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAEpD;;GAEG;AACH,qBAAa,sBAAsB;IAsCF,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAAoB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IArC7G,gBAAuB,gBAAgB,mBAAmB;IAE1D;;OAEG;WACW,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,sBAAsB;IAShE;;;;OAIG;WACW,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,sBAAsB;IAahE;;OAEG;IACH,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAEtB,SAAS,EAAE,MAAM,EAAmB,QAAQ,EAAE,gBAAgB,EAAmB,gBAAgB,EAAE,MAAM;IAIrH;;;OAGG;IACH,IAAW,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAYvC;IAED;;;OAGG;IACI,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAepE;;OAEG;IACI,WAAW,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAQ9C;;OAEG;IACI,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAYrD;;OAEG;IACI,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAmB3D;;OAEG;IACI,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE;IAUlE;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAelC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAoB/B;;;;OAIG;IACI,aAAa,IAAI,IAAI;IAQ5B,OAAO,CAAC,sBAAsB;IAmC9B,OAAO,CAAC,eAAe;CAcxB"} | ||
| {"version":3,"file":"cloud-assembly.d.ts","sourceRoot":"","sources":["cloud-assembly.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAwJ,MAAM,gCAAgC,CAAC;AAI7N;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE7C;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAEpD;;GAEG;AACH,qBAAa,sBAAsB;IAsCF,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAAoB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IArC7G,gBAAuB,gBAAgB,mBAAmB;IAE1D;;OAEG;WACW,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,sBAAsB;IAShE;;;;OAIG;WACW,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,sBAAsB;IAahE;;OAEG;IACH,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAEtB,SAAS,EAAE,MAAM,EAAmB,QAAQ,EAAE,gBAAgB,EAAmB,gBAAgB,EAAE,MAAM;IAIrH;;;OAGG;IACH,IAAW,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAYvC;IAED;;;OAGG;IACI,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAepE;;OAEG;IACI,WAAW,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAQ9C;;OAEG;IACI,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAYrD;;OAEG;IACI,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAmB3D;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAUjC;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAelC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAoB/B;;;;OAIG;IACI,aAAa,IAAI,IAAI;IAQ5B,OAAO,CAAC,sBAAsB;IAmC9B,OAAO,CAAC,eAAe;CAcxB"} |
@@ -247,2 +247,2 @@ "use strict"; | ||
| exports.AssemblyManifestReader = AssemblyManifestReader; | ||
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-assembly.js","sourceRoot":"","sources":["cloud-assembly.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type { FileManifestEntry, DockerImageManifestEntry } from '@aws-cdk/cdk-assets-lib';\nimport { AssetManifest } from '@aws-cdk/cdk-assets-lib';\nimport { CloudArtifact } from '@aws-cdk/cloud-assembly-api';\nimport type { AssemblyManifest, AwsCloudFormationStackProperties, ArtifactManifest, MetadataEntry, AssetManifestProperties, ContainerImageAssetMetadataEntry, FileAssetMetadataEntry } from '@aws-cdk/cloud-assembly-schema';\nimport { Manifest, ArtifactType, ArtifactMetadataEntryType } from '@aws-cdk/cloud-assembly-schema';\nimport * as fs from 'fs-extra';\n\n/**\n * Trace information for stack\n * map of resource logicalId to trace message\n */\nexport type StackTrace = Map<string, string>;\n\n/**\n * Trace information for a assembly\n *\n * map of stackId to StackTrace\n */\nexport type ManifestTrace = Map<string, StackTrace>;\n\n/**\n * Reads a Cloud Assembly manifest\n */\nexport class AssemblyManifestReader {\n  public static readonly DEFAULT_FILENAME = 'manifest.json';\n\n  /**\n   * Reads a Cloud Assembly manifest from a file\n   */\n  public static fromFile(fileName: string): AssemblyManifestReader {\n    try {\n      const obj = Manifest.loadAssemblyManifest(fileName);\n      return new AssemblyManifestReader(path.dirname(fileName), obj, fileName);\n    } catch (e: any) {\n      throw new Error(`Cannot read integ manifest '${fileName}': ${e.message}`);\n    }\n  }\n\n  /**\n   * Reads a Cloud Assembly manifest from a file or a directory\n   * If the given filePath is a directory then it will look for\n   * a file within the directory with the DEFAULT_FILENAME\n   */\n  public static fromPath(filePath: string): AssemblyManifestReader {\n    let st;\n    try {\n      st = fs.statSync(filePath);\n    } catch (e: any) {\n      throw new Error(`Cannot read integ manifest at '${filePath}': ${e.message}`);\n    }\n    if (st.isDirectory()) {\n      return AssemblyManifestReader.fromFile(path.join(filePath, AssemblyManifestReader.DEFAULT_FILENAME));\n    }\n    return AssemblyManifestReader.fromFile(filePath);\n  }\n\n  /**\n   * The directory where the manifest was found\n   */\n  public readonly directory: string;\n\n  constructor(directory: string, private readonly manifest: AssemblyManifest, private readonly manifestFileName: string) {\n    this.directory = directory;\n  }\n\n  /**\n   * Get the stacks from the manifest\n   * returns a map of artifactId to CloudFormation template\n   */\n  public get stacks(): Record<string, any> {\n    const stacks: Record<string, any> = {};\n    for (const [artifactId, artifact] of Object.entries(this.manifest.artifacts ?? {})) {\n      if (artifact.type !== ArtifactType.AWS_CLOUDFORMATION_STACK) {\n        continue;\n      }\n      const props = artifact.properties as AwsCloudFormationStackProperties;\n\n      const template = fs.readJSONSync(path.resolve(this.directory, props.templateFile));\n      stacks[artifactId] = template;\n    }\n    return stacks;\n  }\n\n  /**\n   * Get the nested stacks for a given stack\n   * returns a map of artifactId to CloudFormation template\n   */\n  public getNestedStacksForStack(stackId: string): Record<string, any> {\n    const nestedTemplates: string[] = this.getAssetManifestsForStack(stackId).flatMap(\n      manifest => manifest.files\n        .filter(asset => asset.source.path?.endsWith('.nested.template.json'))\n        .map(asset => asset.source.path!),\n    );\n\n    const nestedStacks: Record<string, any> = Object.fromEntries(nestedTemplates.map(templateFile => ([\n      templateFile.split('.', 1)[0],\n      fs.readJSONSync(path.resolve(this.directory, templateFile)),\n    ])));\n\n    return nestedStacks;\n  }\n\n  /**\n   * Write trace data to the assembly manifest metadata\n   */\n  public recordTrace(trace: ManifestTrace): void {\n    const newManifest = {\n      ...this.manifest,\n      artifacts: this.renderArtifacts(trace),\n    };\n    Manifest.saveAssemblyManifest(newManifest, this.manifestFileName);\n  }\n\n  /**\n   * Return a list of assets for a given stack\n   */\n  public getAssetIdsForStack(stackId: string): string[] {\n    const assets: string[] = [];\n    for (const artifact of Object.values(this.manifest.artifacts ?? {})) {\n      if (artifact.type === ArtifactType.ASSET_MANIFEST && (artifact.properties as AssetManifestProperties)?.file === `${stackId}.assets.json`) {\n        assets.push(...this.assetsFromAssetManifest(artifact).map(asset => asset.id.assetId));\n      } else if (artifact.type === ArtifactType.AWS_CLOUDFORMATION_STACK) {\n        assets.push(...this.assetsFromAssemblyManifest(artifact).map(asset => asset.id));\n      }\n    }\n    return assets;\n  }\n\n  /**\n   * For a given stackId return a list of assets that belong to the stack\n   */\n  public getAssetLocationsForStack(stackId: string): string[] {\n    const assets: string[] = [];\n    for (const artifact of Object.values(this.manifest.artifacts ?? {})) {\n      if (artifact.type === ArtifactType.ASSET_MANIFEST && (artifact.properties as AssetManifestProperties)?.file === `${stackId}.assets.json`) {\n        assets.push(...this.assetsFromAssetManifest(artifact).flatMap(asset => {\n          if (asset.type === 'file' && !asset.source.path?.endsWith('nested.template.json')) {\n            return asset.source.path!;\n          } else if (asset.type !== 'file') {\n            return asset.source.directory!;\n          }\n          return [];\n        }));\n      } else if (artifact.type === ArtifactType.AWS_CLOUDFORMATION_STACK) {\n        assets.push(...this.assetsFromAssemblyManifest(artifact).map(asset => asset.path));\n      }\n    }\n    return assets;\n  }\n\n  /**\n   * Return a list of asset artifacts for a given stack\n   */\n  public getAssetManifestsForStack(stackId: string): AssetManifest[] {\n    return Object.values(this.manifest.artifacts ?? {})\n      .filter(artifact =>\n        artifact.type === ArtifactType.ASSET_MANIFEST && (artifact.properties as AssetManifestProperties)?.file === `${stackId}.assets.json`)\n      .map(artifact => {\n        const fileName = (artifact.properties as AssetManifestProperties).file;\n        return AssetManifest.fromFile(path.join(this.directory, fileName));\n      });\n  }\n\n  /**\n   * Get a list of assets from the assembly manifest\n   */\n  private assetsFromAssemblyManifest(artifact: ArtifactManifest): (ContainerImageAssetMetadataEntry | FileAssetMetadataEntry)[] {\n    const assets: (ContainerImageAssetMetadataEntry | FileAssetMetadataEntry)[] = [];\n    for (const metadata of Object.values(CloudArtifact.readMetadata(this.directory, artifact) ?? {})) {\n      metadata.forEach(data => {\n        if (data.type === ArtifactMetadataEntryType.ASSET) {\n          const asset = (data.data as ContainerImageAssetMetadataEntry | FileAssetMetadataEntry);\n          if (asset.path.startsWith('asset.')) {\n            assets.push(asset);\n          }\n        }\n      });\n    }\n    return assets;\n  }\n\n  /**\n   * Get a list of assets from the asset manifest\n   */\n  private assetsFromAssetManifest(artifact: ArtifactManifest): (FileManifestEntry | DockerImageManifestEntry)[] {\n    const assets: (FileManifestEntry | DockerImageManifestEntry)[] = [];\n    const fileName = (artifact.properties as AssetManifestProperties).file;\n    const assetManifest = AssetManifest.fromFile(path.join(this.directory, fileName));\n    assetManifest.entries.forEach(entry => {\n      if (entry.type === 'file') {\n        const source = (entry as FileManifestEntry).source;\n        if (source.path && (source.path.startsWith('asset.') || source.path.endsWith('nested.template.json'))) {\n          assets.push(entry as FileManifestEntry);\n        }\n      } else if (entry.type === 'docker-image') {\n        const source = (entry as DockerImageManifestEntry).source;\n        if (source.directory && source.directory.startsWith('asset.')) {\n          assets.push(entry as DockerImageManifestEntry);\n        }\n      }\n    });\n    return assets;\n  }\n\n  /**\n   * Clean the manifest of any unneccesary data. Currently that includes\n   * the metadata trace information since this includes trace information like\n   * file system locations and file lines that will change depending on what machine the test is run on\n   */\n  public cleanManifest(): void {\n    const newManifest = {\n      ...this.manifest,\n      artifacts: this.renderArtifacts(),\n    };\n    Manifest.saveAssemblyManifest(newManifest, this.manifestFileName);\n  }\n\n  private renderArtifactMetadata(artifact: ArtifactManifest, trace?: StackTrace): { [id: string]: MetadataEntry[] } | undefined {\n    const newMetadata: { [id: string]: MetadataEntry[] } = {};\n    if (!artifact.metadata) return artifact.metadata;\n    for (const [metadataId, metadataEntry] of Object.entries(artifact.metadata ?? {})) {\n      newMetadata[metadataId] = metadataEntry.map((meta: MetadataEntry) => {\n        if (meta.type === 'aws:cdk:logicalId' && trace && meta.data) {\n          const traceData = trace.get(meta.data.toString());\n          if (traceData) {\n            trace.delete(meta.data.toString());\n            return {\n              type: meta.type,\n              data: meta.data,\n              trace: [traceData],\n            };\n          }\n        }\n        // return metadata without the trace data\n        return {\n          type: meta.type,\n          data: meta.data,\n        };\n      });\n    }\n    if (trace && trace.size > 0) {\n      for (const [id, data] of trace.entries()) {\n        newMetadata[id] = [{\n          type: 'aws:cdk:logicalId',\n          data: id,\n          trace: [data],\n        }];\n      }\n    }\n    return newMetadata;\n  }\n\n  private renderArtifacts(trace?: ManifestTrace): { [id: string]: ArtifactManifest } | undefined {\n    const newArtifacts: { [id: string]: ArtifactManifest } = {};\n    for (const [artifactId, artifact] of Object.entries(this.manifest.artifacts ?? {})) {\n      let stackTrace: StackTrace | undefined = undefined;\n      if (artifact.type === ArtifactType.AWS_CLOUDFORMATION_STACK && trace) {\n        stackTrace = trace.get(artifactId);\n      }\n      newArtifacts[artifactId] = {\n        ...artifact,\n        metadata: this.renderArtifactMetadata(artifact, stackTrace),\n      };\n    }\n    return newArtifacts;\n  }\n}\n"]} | ||
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-assembly.js","sourceRoot":"","sources":["cloud-assembly.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type { FileManifestEntry, DockerImageManifestEntry } from '@aws-cdk/cdk-assets-lib';\nimport { AssetManifest } from '@aws-cdk/cdk-assets-lib';\nimport { CloudArtifact } from '@aws-cdk/cloud-assembly-api';\nimport type { AssemblyManifest, AwsCloudFormationStackProperties, ArtifactManifest, MetadataEntry, AssetManifestProperties, ContainerImageAssetMetadataEntry, FileAssetMetadataEntry } from '@aws-cdk/cloud-assembly-schema';\nimport { Manifest, ArtifactType, ArtifactMetadataEntryType } from '@aws-cdk/cloud-assembly-schema';\nimport * as fs from 'fs-extra';\n\n/**\n * Trace information for stack\n * map of resource logicalId to trace message\n */\nexport type StackTrace = Map<string, string>;\n\n/**\n * Trace information for a assembly\n *\n * map of stackId to StackTrace\n */\nexport type ManifestTrace = Map<string, StackTrace>;\n\n/**\n * Reads a Cloud Assembly manifest\n */\nexport class AssemblyManifestReader {\n  public static readonly DEFAULT_FILENAME = 'manifest.json';\n\n  /**\n   * Reads a Cloud Assembly manifest from a file\n   */\n  public static fromFile(fileName: string): AssemblyManifestReader {\n    try {\n      const obj = Manifest.loadAssemblyManifest(fileName);\n      return new AssemblyManifestReader(path.dirname(fileName), obj, fileName);\n    } catch (e: any) {\n      throw new Error(`Cannot read integ manifest '${fileName}': ${e.message}`);\n    }\n  }\n\n  /**\n   * Reads a Cloud Assembly manifest from a file or a directory\n   * If the given filePath is a directory then it will look for\n   * a file within the directory with the DEFAULT_FILENAME\n   */\n  public static fromPath(filePath: string): AssemblyManifestReader {\n    let st;\n    try {\n      st = fs.statSync(filePath);\n    } catch (e: any) {\n      throw new Error(`Cannot read integ manifest at '${filePath}': ${e.message}`);\n    }\n    if (st.isDirectory()) {\n      return AssemblyManifestReader.fromFile(path.join(filePath, AssemblyManifestReader.DEFAULT_FILENAME));\n    }\n    return AssemblyManifestReader.fromFile(filePath);\n  }\n\n  /**\n   * The directory where the manifest was found\n   */\n  public readonly directory: string;\n\n  constructor(directory: string, private readonly manifest: AssemblyManifest, private readonly manifestFileName: string) {\n    this.directory = directory;\n  }\n\n  /**\n   * Get the stacks from the manifest\n   * returns a map of artifactId to CloudFormation template\n   */\n  public get stacks(): Record<string, any> {\n    const stacks: Record<string, any> = {};\n    for (const [artifactId, artifact] of Object.entries(this.manifest.artifacts ?? {})) {\n      if (artifact.type !== ArtifactType.AWS_CLOUDFORMATION_STACK) {\n        continue;\n      }\n      const props = artifact.properties as AwsCloudFormationStackProperties;\n\n      const template = fs.readJSONSync(path.resolve(this.directory, props.templateFile));\n      stacks[artifactId] = template;\n    }\n    return stacks;\n  }\n\n  /**\n   * Get the nested stacks for a given stack\n   * returns a map of artifactId to CloudFormation template\n   */\n  public getNestedStacksForStack(stackId: string): Record<string, any> {\n    const nestedTemplates: string[] = this.getAssetManifestsForStack(stackId).flatMap(\n      manifest => manifest.files\n        .filter(asset => asset.source.path?.endsWith('.nested.template.json'))\n        .map(asset => asset.source.path!),\n    );\n\n    const nestedStacks: Record<string, any> = Object.fromEntries(nestedTemplates.map(templateFile => ([\n      templateFile.split('.', 1)[0],\n      fs.readJSONSync(path.resolve(this.directory, templateFile)),\n    ])));\n\n    return nestedStacks;\n  }\n\n  /**\n   * Write trace data to the assembly manifest metadata\n   */\n  public recordTrace(trace: ManifestTrace): void {\n    const newManifest = {\n      ...this.manifest,\n      artifacts: this.renderArtifacts(trace),\n    };\n    Manifest.saveAssemblyManifest(newManifest, this.manifestFileName);\n  }\n\n  /**\n   * Return a list of assets for a given stack\n   */\n  public getAssetIdsForStack(stackId: string): string[] {\n    const assets: string[] = [];\n    for (const artifact of Object.values(this.manifest.artifacts ?? {})) {\n      if (artifact.type === ArtifactType.ASSET_MANIFEST && (artifact.properties as AssetManifestProperties)?.file === `${stackId}.assets.json`) {\n        assets.push(...this.assetsFromAssetManifest(artifact).map(asset => asset.id.assetId));\n      } else if (artifact.type === ArtifactType.AWS_CLOUDFORMATION_STACK) {\n        assets.push(...this.assetsFromAssemblyManifest(artifact).map(asset => asset.id));\n      }\n    }\n    return assets;\n  }\n\n  /**\n   * For a given stackId return a list of assets that belong to the stack\n   */\n  public getAssetLocationsForStack(stackId: string): string[] {\n    const assets: string[] = [];\n    for (const artifact of Object.values(this.manifest.artifacts ?? {})) {\n      if (artifact.type === ArtifactType.ASSET_MANIFEST && (artifact.properties as AssetManifestProperties)?.file === `${stackId}.assets.json`) {\n        assets.push(...this.assetsFromAssetManifest(artifact).flatMap(asset => {\n          if (asset.type === 'file' && !asset.source.path?.endsWith('nested.template.json')) {\n            return asset.source.path!;\n          } else if (asset.type !== 'file') {\n            return asset.source.directory!;\n          }\n          return [];\n        }));\n      } else if (artifact.type === ArtifactType.AWS_CLOUDFORMATION_STACK) {\n        assets.push(...this.assetsFromAssemblyManifest(artifact).map(asset => asset.path));\n      }\n    }\n    return assets;\n  }\n\n  /**\n   * Return a list of asset artifacts for a given stack\n   */\n  private getAssetManifestsForStack(stackId: string): AssetManifest[] {\n    return Object.values(this.manifest.artifacts ?? {})\n      .filter(artifact =>\n        artifact.type === ArtifactType.ASSET_MANIFEST && (artifact.properties as AssetManifestProperties)?.file === `${stackId}.assets.json`)\n      .map(artifact => {\n        const fileName = (artifact.properties as AssetManifestProperties).file;\n        return AssetManifest.fromFile(path.join(this.directory, fileName));\n      });\n  }\n\n  /**\n   * Get a list of assets from the assembly manifest\n   */\n  private assetsFromAssemblyManifest(artifact: ArtifactManifest): (ContainerImageAssetMetadataEntry | FileAssetMetadataEntry)[] {\n    const assets: (ContainerImageAssetMetadataEntry | FileAssetMetadataEntry)[] = [];\n    for (const metadata of Object.values(CloudArtifact.readMetadata(this.directory, artifact) ?? {})) {\n      metadata.forEach(data => {\n        if (data.type === ArtifactMetadataEntryType.ASSET) {\n          const asset = (data.data as ContainerImageAssetMetadataEntry | FileAssetMetadataEntry);\n          if (asset.path.startsWith('asset.')) {\n            assets.push(asset);\n          }\n        }\n      });\n    }\n    return assets;\n  }\n\n  /**\n   * Get a list of assets from the asset manifest\n   */\n  private assetsFromAssetManifest(artifact: ArtifactManifest): (FileManifestEntry | DockerImageManifestEntry)[] {\n    const assets: (FileManifestEntry | DockerImageManifestEntry)[] = [];\n    const fileName = (artifact.properties as AssetManifestProperties).file;\n    const assetManifest = AssetManifest.fromFile(path.join(this.directory, fileName));\n    assetManifest.entries.forEach(entry => {\n      if (entry.type === 'file') {\n        const source = (entry as FileManifestEntry).source;\n        if (source.path && (source.path.startsWith('asset.') || source.path.endsWith('nested.template.json'))) {\n          assets.push(entry as FileManifestEntry);\n        }\n      } else if (entry.type === 'docker-image') {\n        const source = (entry as DockerImageManifestEntry).source;\n        if (source.directory && source.directory.startsWith('asset.')) {\n          assets.push(entry as DockerImageManifestEntry);\n        }\n      }\n    });\n    return assets;\n  }\n\n  /**\n   * Clean the manifest of any unneccesary data. Currently that includes\n   * the metadata trace information since this includes trace information like\n   * file system locations and file lines that will change depending on what machine the test is run on\n   */\n  public cleanManifest(): void {\n    const newManifest = {\n      ...this.manifest,\n      artifacts: this.renderArtifacts(),\n    };\n    Manifest.saveAssemblyManifest(newManifest, this.manifestFileName);\n  }\n\n  private renderArtifactMetadata(artifact: ArtifactManifest, trace?: StackTrace): { [id: string]: MetadataEntry[] } | undefined {\n    const newMetadata: { [id: string]: MetadataEntry[] } = {};\n    if (!artifact.metadata) return artifact.metadata;\n    for (const [metadataId, metadataEntry] of Object.entries(artifact.metadata ?? {})) {\n      newMetadata[metadataId] = metadataEntry.map((meta: MetadataEntry) => {\n        if (meta.type === 'aws:cdk:logicalId' && trace && meta.data) {\n          const traceData = trace.get(meta.data.toString());\n          if (traceData) {\n            trace.delete(meta.data.toString());\n            return {\n              type: meta.type,\n              data: meta.data,\n              trace: [traceData],\n            };\n          }\n        }\n        // return metadata without the trace data\n        return {\n          type: meta.type,\n          data: meta.data,\n        };\n      });\n    }\n    if (trace && trace.size > 0) {\n      for (const [id, data] of trace.entries()) {\n        newMetadata[id] = [{\n          type: 'aws:cdk:logicalId',\n          data: id,\n          trace: [data],\n        }];\n      }\n    }\n    return newMetadata;\n  }\n\n  private renderArtifacts(trace?: ManifestTrace): { [id: string]: ArtifactManifest } | undefined {\n    const newArtifacts: { [id: string]: ArtifactManifest } = {};\n    for (const [artifactId, artifact] of Object.entries(this.manifest.artifacts ?? {})) {\n      let stackTrace: StackTrace | undefined = undefined;\n      if (artifact.type === ArtifactType.AWS_CLOUDFORMATION_STACK && trace) {\n        stackTrace = trace.get(artifactId);\n      }\n      newArtifacts[artifactId] = {\n        ...artifact,\n        metadata: this.renderArtifactMetadata(artifact, stackTrace),\n      };\n    }\n    return newArtifacts;\n  }\n}\n"]} |
@@ -1,3 +0,2 @@ | ||
| import type { IntegRunnerOptions } from './runner-base'; | ||
| import { IntegRunner } from './runner-base'; | ||
| import type { CdkIntegHelperOptions } from './cdk-integ-helper'; | ||
| import type { Diagnostic, DestructiveChange, SnapshotVerificationOptions } from '../workers/common'; | ||
@@ -8,7 +7,12 @@ /** | ||
| */ | ||
| export declare class IntegSnapshotRunner extends IntegRunner { | ||
| constructor(options: Omit<IntegRunnerOptions, 'region'>); | ||
| export declare class IntegSnapshotRunner { | ||
| private readonly helper; | ||
| constructor(options: Omit<CdkIntegHelperOptions, 'region'>); | ||
| hasSnapshot(): boolean; | ||
| actualTests(): Promise<{ | ||
| [testName: string]: import("@aws-cdk/cloud-assembly-schema").TestCase; | ||
| } | undefined>; | ||
| dontCareAboutLegacyLookupsForTests(): void; | ||
| /** | ||
| * Synth the integration tests and compare the templates | ||
| * to the existing snapshot. | ||
| * Synth the CDK app and compare the templates to the existing snapshot. | ||
| * | ||
@@ -15,0 +19,0 @@ * @returns any diagnostics and any destructive changes |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"snapshot-test-runner.d.ts","sourceRoot":"","sources":["snapshot-test-runner.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,WAAW,EAAyB,MAAM,eAAe,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAsBpG;;;GAGG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;gBACtC,OAAO,EAAE,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC;IAOvD;;;;;OAKG;IACU,YAAY,CAAC,OAAO,GAAE,2BAAgC,GAAG,OAAO,CAAC;QAC5E,WAAW,EAAE,UAAU,EAAE,CAAC;QAC1B,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;KACzC,CAAC;IAkEF;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAsB3B;;;;;;OAMG;YACW,8BAA8B;IAS5C;;;;;;OAMG;YACW,YAAY;IAuG1B,OAAO,CAAC,YAAY;IAIpB;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;CA4E7B"} | ||
| {"version":3,"file":"snapshot-test-runner.d.ts","sourceRoot":"","sources":["snapshot-test-runner.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAGhE,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAsBpG;;;GAGG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;gBAC5B,OAAO,EAAE,IAAI,CAAC,qBAAqB,EAAE,QAAQ,CAAC;IAOnD,WAAW;IAIX,WAAW;;;IAIX,kCAAkC;IAIzC;;;;OAIG;IACU,YAAY,CAAC,OAAO,GAAE,2BAAgC,GAAG,OAAO,CAAC;QAC5E,WAAW,EAAE,UAAU,EAAE,CAAC;QAC1B,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;KACzC,CAAC;IAoDF;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAsB3B;;;;;;OAMG;YACW,8BAA8B;IAS5C;;;;;;OAMG;YACW,YAAY;IAuG1B,OAAO,CAAC,YAAY;IAIpB;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;CA4E7B"} |
@@ -9,4 +9,4 @@ "use strict"; | ||
| const cloudformation_diff_1 = require("@aws-cdk/cloudformation-diff"); | ||
| const cdk_integ_helper_1 = require("./cdk-integ-helper"); | ||
| const cloud_assembly_1 = require("./private/cloud-assembly"); | ||
| const runner_base_1 = require("./runner-base"); | ||
| const common_1 = require("../workers/common"); | ||
@@ -17,5 +17,6 @@ /** | ||
| */ | ||
| class IntegSnapshotRunner extends runner_base_1.IntegRunner { | ||
| class IntegSnapshotRunner { | ||
| helper; | ||
| constructor(options) { | ||
| super({ | ||
| this.helper = cdk_integ_helper_1.CdkIntegHelper.create({ | ||
| ...options, | ||
@@ -25,5 +26,13 @@ region: cloud_assembly_api_1.UNKNOWN_REGION, | ||
| } | ||
| hasSnapshot() { | ||
| return this.helper.hasSnapshot(); | ||
| } | ||
| actualTests() { | ||
| return this.helper.actualTests(); | ||
| } | ||
| dontCareAboutLegacyLookupsForTests() { | ||
| this.helper.configureLegacyEnableLookups('dont-care'); | ||
| } | ||
| /** | ||
| * Synth the integration tests and compare the templates | ||
| * to the existing snapshot. | ||
| * Synth the CDK app and compare the templates to the existing snapshot. | ||
| * | ||
@@ -35,19 +44,10 @@ * @returns any diagnostics and any destructive changes | ||
| try { | ||
| const expectedTestSuite = await this.expectedTestSuite(); | ||
| const actualTestSuite = await this.actualTestSuite(); | ||
| const expectedSnapshotAssembly = this.getSnapshotAssembly(this.snapshotDir, expectedTestSuite?.stacks); | ||
| // synth the integration test | ||
| // FIXME: ideally we should not need to run this again if | ||
| // the cdkOutDir exists already, but for some reason generateActualSnapshot | ||
| // generates an incorrect snapshot and I have no idea why so synth again here | ||
| // to produce the "correct" snapshot | ||
| const env = runner_base_1.DEFAULT_SYNTH_OPTIONS.env; | ||
| await this.cdk.synth({ | ||
| app: this.cdkApp, | ||
| context: this.getContext(actualTestSuite.enableLookups ? runner_base_1.DEFAULT_SYNTH_OPTIONS.context : {}), | ||
| env, | ||
| output: path.relative(this.directory, this.cdkOutDir), | ||
| }); | ||
| // Read the "expected" snapshot | ||
| const expectedTestSuite = await this.helper.expectedTestSuite(); | ||
| const expectedSnapshotAssembly = this.getSnapshotAssembly(this.helper.goldenSnapshotDir, expectedTestSuite?.stacks); | ||
| // Configure settings from the golden snapshot | ||
| this.helper.configureLegacyEnableLookups(expectedTestSuite?.enableLookups ?? false); | ||
| // read the "actual" snapshot | ||
| const actualSnapshotAssembly = this.getSnapshotAssembly(this.cdkOutDir, actualTestSuite.stacks); | ||
| const actualSnapshot = await this.helper.actualSnapshot(); | ||
| const actualSnapshotAssembly = this.getSnapshotAssembly(this.helper.cdkOutDir, actualSnapshot.testDefinition.stacks); | ||
| // diff the existing snapshot (expected) with the integration test (actual) | ||
@@ -59,10 +59,7 @@ const diagnostics = await this.diffAssembly(expectedSnapshotAssembly, actualSnapshotAssembly); | ||
| if (options.retain) { | ||
| additionalMessages.push(`(Failure retained) Expected: ${path.relative(process.cwd(), this.snapshotDir)}`, ` Actual: ${path.relative(process.cwd(), this.cdkOutDir)}`), | ||
| additionalMessages.push(`(Failure retained) Expected: ${path.relative(process.cwd(), this.helper.goldenSnapshotDir)}`, ` Actual: ${path.relative(process.cwd(), this.helper.cdkOutDir)}`), | ||
| doClean = false; | ||
| } | ||
| if (options.verbose) { | ||
| // Show the command necessary to repro this | ||
| const envSet = Object.entries(env).map(([k, v]) => `${k}='${v}'`); | ||
| const envCmd = envSet.length > 0 ? ['env', ...envSet] : []; | ||
| additionalMessages.push('Repro:', ` ${[...envCmd, 'cdk synth', `-a '${this.cdkApp}'`, `-o '${this.cdkOutDir}'`, ...Object.entries(this.getContext()).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : [])].join(' ')}`); | ||
| additionalMessages.push('Repro:', ` ${this.helper.actualSynthReproCommand().join(' ')}`); | ||
| } | ||
@@ -81,3 +78,3 @@ diagnostics.diagnostics[0] = { | ||
| if (doClean) { | ||
| this.cleanup(); | ||
| this.helper.cleanup(); | ||
| } | ||
@@ -121,3 +118,3 @@ } | ||
| async getAllowedDestroyTypesForStack(stackId) { | ||
| for (const testCase of Object.values((await this.actualTests()) ?? {})) { | ||
| for (const testCase of Object.values((await this.helper.actualTests()) ?? {})) { | ||
| if (testCase.stacks.includes(stackId)) { | ||
@@ -145,3 +142,3 @@ return testCase.allowDestroy; | ||
| failures.push({ | ||
| testName: this.testName, | ||
| testName: this.helper.testName, | ||
| stackName: templateId, | ||
@@ -160,3 +157,3 @@ reason: common_1.DiagnosticReason.SNAPSHOT_FAILED, | ||
| failures.push({ | ||
| testName: this.testName, | ||
| testName: this.helper.testName, | ||
| stackName: templateId, | ||
@@ -170,3 +167,3 @@ reason: common_1.DiagnosticReason.SNAPSHOT_FAILED, | ||
| const config = { | ||
| diffAssets: (await this.actualTestSuite()).getOptionsForStack(stackId)?.diffAssets, | ||
| diffAssets: (await this.helper.actualSnapshot()).testDefinition.getOptionsForStack(stackId)?.diffAssets, | ||
| }; | ||
@@ -223,3 +220,3 @@ let actualTemplate = actual[stackId].templates[templateId]; | ||
| stackName: templateId, | ||
| testName: this.testName, | ||
| testName: this.helper.testName, | ||
| config, | ||
@@ -334,2 +331,2 @@ }); | ||
| } | ||
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snapshot-test-runner.js","sourceRoot":"","sources":["snapshot-test-runner.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type { WritableOptions } from 'stream';\nimport { Writable } from 'stream';\nimport { StringDecoder } from 'string_decoder';\nimport { UNKNOWN_REGION } from '@aws-cdk/cloud-assembly-api';\nimport type { ResourceDifference } from '@aws-cdk/cloudformation-diff';\nimport { fullDiff, formatDifferences, ResourceImpact } from '@aws-cdk/cloudformation-diff';\nimport { AssemblyManifestReader } from './private/cloud-assembly';\nimport type { IntegRunnerOptions } from './runner-base';\nimport { IntegRunner, DEFAULT_SYNTH_OPTIONS } from './runner-base';\nimport type { Diagnostic, DestructiveChange, SnapshotVerificationOptions } from '../workers/common';\nimport { DiagnosticReason } from '../workers/common';\n\ninterface SnapshotAssembly {\n  /**\n   * Map of stacks that are part of this assembly\n   */\n  [stackName: string]: {\n    /**\n     * All templates for this stack, including nested stacks\n     */\n    templates: {\n      [templateId: string]: any;\n    };\n\n    /**\n     * List of asset Ids that are used by this assembly\n     */\n    assets: string[];\n  };\n}\n\n/**\n * Runner for snapshot tests. This handles orchestrating\n * the validation of the integration test snapshots\n */\nexport class IntegSnapshotRunner extends IntegRunner {\n  constructor(options: Omit<IntegRunnerOptions, 'region'>) {\n    super({\n      ...options,\n      region: UNKNOWN_REGION,\n    });\n  }\n\n  /**\n   * Synth the integration tests and compare the templates\n   * to the existing snapshot.\n   *\n   * @returns any diagnostics and any destructive changes\n   */\n  public async testSnapshot(options: SnapshotVerificationOptions = {}): Promise<{\n    diagnostics: Diagnostic[];\n    destructiveChanges: DestructiveChange[];\n  }> {\n    let doClean = true;\n    try {\n      const expectedTestSuite = await this.expectedTestSuite();\n      const actualTestSuite = await this.actualTestSuite();\n      const expectedSnapshotAssembly = this.getSnapshotAssembly(this.snapshotDir, expectedTestSuite?.stacks);\n\n      // synth the integration test\n      // FIXME: ideally we should not need to run this again if\n      // the cdkOutDir exists already, but for some reason generateActualSnapshot\n      // generates an incorrect snapshot and I have no idea why so synth again here\n      // to produce the \"correct\" snapshot\n      const env = DEFAULT_SYNTH_OPTIONS.env;\n      await this.cdk.synth({\n        app: this.cdkApp,\n        context: this.getContext(actualTestSuite.enableLookups ? DEFAULT_SYNTH_OPTIONS.context : {}),\n        env,\n        output: path.relative(this.directory, this.cdkOutDir),\n      });\n\n      // read the \"actual\" snapshot\n      const actualSnapshotAssembly = this.getSnapshotAssembly(this.cdkOutDir, actualTestSuite.stacks);\n\n      // diff the existing snapshot (expected) with the integration test (actual)\n      const diagnostics = await this.diffAssembly(expectedSnapshotAssembly, actualSnapshotAssembly);\n\n      if (diagnostics.diagnostics.length) {\n        // Attach additional messages to the first diagnostic\n        const additionalMessages: string[] = [];\n\n        if (options.retain) {\n          additionalMessages.push(\n            `(Failure retained) Expected: ${path.relative(process.cwd(), this.snapshotDir)}`,\n            `                   Actual:   ${path.relative(process.cwd(), this.cdkOutDir)}`,\n          ),\n          doClean = false;\n        }\n\n        if (options.verbose) {\n          // Show the command necessary to repro this\n          const envSet = Object.entries(env).map(([k, v]) => `${k}='${v}'`);\n          const envCmd = envSet.length > 0 ? ['env', ...envSet] : [];\n\n          additionalMessages.push(\n            'Repro:',\n            `  ${[...envCmd, 'cdk synth', `-a '${this.cdkApp}'`, `-o '${this.cdkOutDir}'`, ...Object.entries(this.getContext()).flatMap(([k, v]) => typeof v !== 'object' ? [`-c '${k}=${v}'`] : [])].join(' ')}`,\n\n          );\n        }\n\n        diagnostics.diagnostics[0] = {\n          ...diagnostics.diagnostics[0],\n          additionalMessages,\n        };\n      }\n\n      return diagnostics;\n    } catch (e) {\n      throw e;\n    } finally {\n      if (doClean) {\n        this.cleanup();\n      }\n    }\n  }\n\n  /**\n   * For a given cloud assembly return a collection of all templates\n   * that should be part of the snapshot and any required meta data.\n   *\n   * @param cloudAssemblyDir - The directory of the cloud assembly to look for snapshots\n   * @param pickStacks - Pick only these stacks from the cloud assembly\n   * @returns A SnapshotAssembly, the collection of all templates in this snapshot and required meta data\n   */\n  private getSnapshotAssembly(cloudAssemblyDir: string, pickStacks: string[] = []): SnapshotAssembly {\n    const assembly = this.readAssembly(cloudAssemblyDir);\n    const stacks = assembly.stacks;\n    const snapshots: SnapshotAssembly = {};\n    for (const [stackName, stackTemplate] of Object.entries(stacks)) {\n      if (pickStacks.includes(stackName)) {\n        const manifest = AssemblyManifestReader.fromPath(cloudAssemblyDir);\n        const assets = manifest.getAssetIdsForStack(stackName);\n\n        snapshots[stackName] = {\n          templates: {\n            [stackName]: stackTemplate,\n            ...assembly.getNestedStacksForStack(stackName),\n          },\n          assets,\n        };\n      }\n    }\n\n    return snapshots;\n  }\n\n  /**\n   * For a given stack return all resource types that are allowed to be destroyed\n   * as part of a stack update\n   *\n   * @param stackId - the stack id\n   * @returns a list of resource types or undefined if none are found\n   */\n  private async getAllowedDestroyTypesForStack(stackId: string): Promise<string[] | undefined> {\n    for (const testCase of Object.values((await this.actualTests()) ?? {})) {\n      if (testCase.stacks.includes(stackId)) {\n        return testCase.allowDestroy;\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Find any differences between the existing and expected snapshots\n   *\n   * @param existing - the existing (expected) snapshot\n   * @param actual - the new (actual) snapshot\n   * @returns any diagnostics and any destructive changes\n   */\n  private async diffAssembly(\n    expected: SnapshotAssembly,\n    actual: SnapshotAssembly,\n  ): Promise<{ diagnostics: Diagnostic[]; destructiveChanges: DestructiveChange[] }> {\n    const failures: Diagnostic[] = [];\n    const destructiveChanges: DestructiveChange[] = [];\n\n    // check if there is a CFN template in the current snapshot\n    // that does not exist in the \"actual\" snapshot\n    for (const [stackId, stack] of Object.entries(expected)) {\n      for (const templateId of Object.keys(stack.templates)) {\n        if (!actual[stackId]?.templates[templateId]) {\n          failures.push({\n            testName: this.testName,\n            stackName: templateId,\n            reason: DiagnosticReason.SNAPSHOT_FAILED,\n            message: `${templateId} exists in snapshot, but not in actual`,\n          });\n        }\n      }\n    }\n\n    for (const [stackId, stack] of Object.entries(actual)) {\n      for (const templateId of Object.keys(stack.templates)) {\n      // check if there is a CFN template in the \"actual\" snapshot\n      // that does not exist in the current snapshot\n        if (!expected[stackId]?.templates[templateId]) {\n          failures.push({\n            testName: this.testName,\n            stackName: templateId,\n            reason: DiagnosticReason.SNAPSHOT_FAILED,\n            message: `${templateId} does not exist in snapshot, but does in actual`,\n          });\n          continue;\n        } else {\n          const config = {\n            diffAssets: (await this.actualTestSuite()).getOptionsForStack(stackId)?.diffAssets,\n          };\n          let actualTemplate = actual[stackId].templates[templateId];\n          let expectedTemplate = expected[stackId].templates[templateId];\n\n          // if we are not verifying asset hashes then remove the specific\n          // asset hashes from the templates so they are not part of the diff\n          // comparison\n          if (!config.diffAssets) {\n            actualTemplate = this.canonicalizeTemplate(actualTemplate, actual[stackId].assets);\n            expectedTemplate = this.canonicalizeTemplate(expectedTemplate, expected[stackId].assets);\n          }\n          const templateDiff = fullDiff(expectedTemplate, actualTemplate);\n          if (!templateDiff.isEmpty) {\n            const allowedDestroyTypes = (await this.getAllowedDestroyTypesForStack(stackId)) ?? [];\n\n            // go through all the resource differences and check for any\n            // \"destructive\" changes\n            templateDiff.resources.forEachDifference((logicalId: string, change: ResourceDifference) => {\n            // if the change is a removal it will not show up as a 'changeImpact'\n            // so need to check for it separately, unless it is a resourceType that\n            // has been \"allowed\" to be destroyed\n              const resourceType = change.oldValue?.Type ?? change.newValue?.Type;\n              if (resourceType && allowedDestroyTypes.includes(resourceType)) {\n                return;\n              }\n              if (change.isRemoval) {\n                destructiveChanges.push({\n                  impact: ResourceImpact.WILL_DESTROY,\n                  logicalId,\n                  stackName: templateId,\n                });\n              } else {\n                switch (change.changeImpact) {\n                  case ResourceImpact.MAY_REPLACE:\n                  case ResourceImpact.WILL_ORPHAN:\n                  case ResourceImpact.WILL_DESTROY:\n                  case ResourceImpact.WILL_REPLACE:\n                    destructiveChanges.push({\n                      impact: change.changeImpact,\n                      logicalId,\n                      stackName: templateId,\n                    });\n                    break;\n                }\n              }\n            });\n            const writable = new StringWritable({});\n            formatDifferences(writable, templateDiff);\n            failures.push({\n              reason: DiagnosticReason.SNAPSHOT_FAILED,\n              message: writable.data,\n              stackName: templateId,\n              testName: this.testName,\n              config,\n            });\n          }\n        }\n      }\n    }\n\n    return {\n      diagnostics: failures,\n      destructiveChanges,\n    };\n  }\n\n  private readAssembly(dir: string): AssemblyManifestReader {\n    return AssemblyManifestReader.fromPath(dir);\n  }\n\n  /**\n   * Reduce template to a normal form where asset references have been normalized\n   *\n   * This makes it possible to compare templates if all that's different between\n   * them is the hashes of the asset values.\n   */\n  private canonicalizeTemplate(template: any, assets: string[]): any {\n    const assetsSeen = new Set<string>();\n    const stringSubstitutions = new Array<[RegExp, string]>();\n\n    // Find assets via parameters (for LegacyStackSynthesizer)\n    const paramRe = /^AssetParameters([a-zA-Z0-9]{64})(S3Bucket|S3VersionKey|ArtifactHash)([a-zA-Z0-9]{8})$/;\n    for (const paramName of Object.keys(template?.Parameters || {})) {\n      const m = paramRe.exec(paramName);\n      if (!m) {\n        continue;\n      }\n      if (assetsSeen.has(m[1])) {\n        continue;\n      }\n\n      assetsSeen.add(m[1]);\n      const ix = assetsSeen.size;\n\n      // Full parameter reference\n      stringSubstitutions.push([\n        new RegExp(`AssetParameters${m[1]}(S3Bucket|S3VersionKey|ArtifactHash)([a-zA-Z0-9]{8})`),\n        `Asset${ix}$1`,\n      ]);\n      // Substring asset hash reference\n      stringSubstitutions.push([\n        new RegExp(`${m[1]}`),\n        `Asset${ix}Hash`,\n      ]);\n    }\n\n    // find assets defined in the asset manifest\n    try {\n      assets.forEach(asset => {\n        if (!assetsSeen.has(asset)) {\n          assetsSeen.add(asset);\n          const ix = assetsSeen.size;\n          stringSubstitutions.push([\n            new RegExp(asset),\n            `Asset${ix}$1`,\n          ]);\n        }\n      });\n    } catch {\n      // if there is no asset manifest that is fine.\n    }\n\n    // Substitute them out\n    return substitute(template);\n\n    function substitute(what: any): any {\n      if (Array.isArray(what)) {\n        return what.map(substitute);\n      }\n\n      if (typeof what === 'object' && what !== null) {\n        const ret: any = {};\n        for (const [k, v] of Object.entries(what)) {\n          ret[stringSub(k)] = substitute(v);\n        }\n        return ret;\n      }\n\n      if (typeof what === 'string') {\n        return stringSub(what);\n      }\n\n      return what;\n    }\n\n    function stringSub(x: string) {\n      for (const [re, replacement] of stringSubstitutions) {\n        x = x.replace(re, replacement);\n      }\n      return x;\n    }\n  }\n}\n\nclass StringWritable extends Writable {\n  public data: string;\n  private _decoder: StringDecoder;\n  constructor(options: WritableOptions) {\n    super(options);\n    this._decoder = new StringDecoder();\n    this.data = '';\n  }\n\n  _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void {\n    if (encoding === 'buffer') {\n      chunk = this._decoder.write(chunk);\n    }\n\n    this.data += chunk;\n    callback();\n  }\n\n  _final(callback: (error?: Error | null) => void): void {\n    this.data += this._decoder.end();\n    callback();\n  }\n}\n"]} | ||
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snapshot-test-runner.js","sourceRoot":"","sources":["snapshot-test-runner.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type { WritableOptions } from 'stream';\nimport { Writable } from 'stream';\nimport { StringDecoder } from 'string_decoder';\nimport { UNKNOWN_REGION } from '@aws-cdk/cloud-assembly-api';\nimport type { ResourceDifference } from '@aws-cdk/cloudformation-diff';\nimport { fullDiff, formatDifferences, ResourceImpact } from '@aws-cdk/cloudformation-diff';\nimport type { CdkIntegHelperOptions } from './cdk-integ-helper';\nimport { CdkIntegHelper } from './cdk-integ-helper';\nimport { AssemblyManifestReader } from './private/cloud-assembly';\nimport type { Diagnostic, DestructiveChange, SnapshotVerificationOptions } from '../workers/common';\nimport { DiagnosticReason } from '../workers/common';\n\ninterface SnapshotAssembly {\n  /**\n   * Map of stacks that are part of this assembly\n   */\n  [stackName: string]: {\n    /**\n     * All templates for this stack, including nested stacks\n     */\n    templates: {\n      [templateId: string]: any;\n    };\n\n    /**\n     * List of asset Ids that are used by this assembly\n     */\n    assets: string[];\n  };\n}\n\n/**\n * Runner for snapshot tests. This handles orchestrating\n * the validation of the integration test snapshots\n */\nexport class IntegSnapshotRunner {\n  private readonly helper: CdkIntegHelper;\n  constructor(options: Omit<CdkIntegHelperOptions, 'region'>) {\n    this.helper = CdkIntegHelper.create({\n      ...options,\n      region: UNKNOWN_REGION,\n    });\n  }\n\n  public hasSnapshot() {\n    return this.helper.hasSnapshot();\n  }\n\n  public actualTests() {\n    return this.helper.actualTests();\n  }\n\n  public dontCareAboutLegacyLookupsForTests() {\n    this.helper.configureLegacyEnableLookups('dont-care');\n  }\n\n  /**\n   * Synth the CDK app and compare the templates to the existing snapshot.\n   *\n   * @returns any diagnostics and any destructive changes\n   */\n  public async testSnapshot(options: SnapshotVerificationOptions = {}): Promise<{\n    diagnostics: Diagnostic[];\n    destructiveChanges: DestructiveChange[];\n  }> {\n    let doClean = true;\n    try {\n      // Read the \"expected\" snapshot\n      const expectedTestSuite = await this.helper.expectedTestSuite();\n      const expectedSnapshotAssembly = this.getSnapshotAssembly(this.helper.goldenSnapshotDir, expectedTestSuite?.stacks);\n\n      // Configure settings from the golden snapshot\n      this.helper.configureLegacyEnableLookups(expectedTestSuite?.enableLookups ?? false);\n\n      // read the \"actual\" snapshot\n      const actualSnapshot = await this.helper.actualSnapshot();\n      const actualSnapshotAssembly = this.getSnapshotAssembly(this.helper.cdkOutDir, actualSnapshot.testDefinition.stacks);\n\n      // diff the existing snapshot (expected) with the integration test (actual)\n      const diagnostics = await this.diffAssembly(expectedSnapshotAssembly, actualSnapshotAssembly);\n\n      if (diagnostics.diagnostics.length) {\n        // Attach additional messages to the first diagnostic\n        const additionalMessages: string[] = [];\n\n        if (options.retain) {\n          additionalMessages.push(\n            `(Failure retained) Expected: ${path.relative(process.cwd(), this.helper.goldenSnapshotDir)}`,\n            `                   Actual:   ${path.relative(process.cwd(), this.helper.cdkOutDir)}`,\n          ),\n          doClean = false;\n        }\n\n        if (options.verbose) {\n          additionalMessages.push(\n            'Repro:',\n            `  ${this.helper.actualSynthReproCommand().join(' ')}`,\n          );\n        }\n\n        diagnostics.diagnostics[0] = {\n          ...diagnostics.diagnostics[0],\n          additionalMessages,\n        };\n      }\n\n      return diagnostics;\n    } catch (e) {\n      throw e;\n    } finally {\n      if (doClean) {\n        this.helper.cleanup();\n      }\n    }\n  }\n\n  /**\n   * For a given cloud assembly return a collection of all templates\n   * that should be part of the snapshot and any required meta data.\n   *\n   * @param cloudAssemblyDir - The directory of the cloud assembly to look for snapshots\n   * @param pickStacks - Pick only these stacks from the cloud assembly\n   * @returns A SnapshotAssembly, the collection of all templates in this snapshot and required meta data\n   */\n  private getSnapshotAssembly(cloudAssemblyDir: string, pickStacks: string[] = []): SnapshotAssembly {\n    const assembly = this.readAssembly(cloudAssemblyDir);\n    const stacks = assembly.stacks;\n    const snapshots: SnapshotAssembly = {};\n    for (const [stackName, stackTemplate] of Object.entries(stacks)) {\n      if (pickStacks.includes(stackName)) {\n        const manifest = AssemblyManifestReader.fromPath(cloudAssemblyDir);\n        const assets = manifest.getAssetIdsForStack(stackName);\n\n        snapshots[stackName] = {\n          templates: {\n            [stackName]: stackTemplate,\n            ...assembly.getNestedStacksForStack(stackName),\n          },\n          assets,\n        };\n      }\n    }\n\n    return snapshots;\n  }\n\n  /**\n   * For a given stack return all resource types that are allowed to be destroyed\n   * as part of a stack update\n   *\n   * @param stackId - the stack id\n   * @returns a list of resource types or undefined if none are found\n   */\n  private async getAllowedDestroyTypesForStack(stackId: string): Promise<string[] | undefined> {\n    for (const testCase of Object.values((await this.helper.actualTests()) ?? {})) {\n      if (testCase.stacks.includes(stackId)) {\n        return testCase.allowDestroy;\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Find any differences between the existing and expected snapshots\n   *\n   * @param existing - the existing (expected) snapshot\n   * @param actual - the new (actual) snapshot\n   * @returns any diagnostics and any destructive changes\n   */\n  private async diffAssembly(\n    expected: SnapshotAssembly,\n    actual: SnapshotAssembly,\n  ): Promise<{ diagnostics: Diagnostic[]; destructiveChanges: DestructiveChange[] }> {\n    const failures: Diagnostic[] = [];\n    const destructiveChanges: DestructiveChange[] = [];\n\n    // check if there is a CFN template in the current snapshot\n    // that does not exist in the \"actual\" snapshot\n    for (const [stackId, stack] of Object.entries(expected)) {\n      for (const templateId of Object.keys(stack.templates)) {\n        if (!actual[stackId]?.templates[templateId]) {\n          failures.push({\n            testName: this.helper.testName,\n            stackName: templateId,\n            reason: DiagnosticReason.SNAPSHOT_FAILED,\n            message: `${templateId} exists in snapshot, but not in actual`,\n          });\n        }\n      }\n    }\n\n    for (const [stackId, stack] of Object.entries(actual)) {\n      for (const templateId of Object.keys(stack.templates)) {\n      // check if there is a CFN template in the \"actual\" snapshot\n      // that does not exist in the current snapshot\n        if (!expected[stackId]?.templates[templateId]) {\n          failures.push({\n            testName: this.helper.testName,\n            stackName: templateId,\n            reason: DiagnosticReason.SNAPSHOT_FAILED,\n            message: `${templateId} does not exist in snapshot, but does in actual`,\n          });\n          continue;\n        } else {\n          const config = {\n            diffAssets: (await this.helper.actualSnapshot()).testDefinition.getOptionsForStack(stackId)?.diffAssets,\n          };\n          let actualTemplate = actual[stackId].templates[templateId];\n          let expectedTemplate = expected[stackId].templates[templateId];\n\n          // if we are not verifying asset hashes then remove the specific\n          // asset hashes from the templates so they are not part of the diff\n          // comparison\n          if (!config.diffAssets) {\n            actualTemplate = this.canonicalizeTemplate(actualTemplate, actual[stackId].assets);\n            expectedTemplate = this.canonicalizeTemplate(expectedTemplate, expected[stackId].assets);\n          }\n          const templateDiff = fullDiff(expectedTemplate, actualTemplate);\n          if (!templateDiff.isEmpty) {\n            const allowedDestroyTypes = (await this.getAllowedDestroyTypesForStack(stackId)) ?? [];\n\n            // go through all the resource differences and check for any\n            // \"destructive\" changes\n            templateDiff.resources.forEachDifference((logicalId: string, change: ResourceDifference) => {\n            // if the change is a removal it will not show up as a 'changeImpact'\n            // so need to check for it separately, unless it is a resourceType that\n            // has been \"allowed\" to be destroyed\n              const resourceType = change.oldValue?.Type ?? change.newValue?.Type;\n              if (resourceType && allowedDestroyTypes.includes(resourceType)) {\n                return;\n              }\n              if (change.isRemoval) {\n                destructiveChanges.push({\n                  impact: ResourceImpact.WILL_DESTROY,\n                  logicalId,\n                  stackName: templateId,\n                });\n              } else {\n                switch (change.changeImpact) {\n                  case ResourceImpact.MAY_REPLACE:\n                  case ResourceImpact.WILL_ORPHAN:\n                  case ResourceImpact.WILL_DESTROY:\n                  case ResourceImpact.WILL_REPLACE:\n                    destructiveChanges.push({\n                      impact: change.changeImpact,\n                      logicalId,\n                      stackName: templateId,\n                    });\n                    break;\n                }\n              }\n            });\n            const writable = new StringWritable({});\n            formatDifferences(writable, templateDiff);\n            failures.push({\n              reason: DiagnosticReason.SNAPSHOT_FAILED,\n              message: writable.data,\n              stackName: templateId,\n              testName: this.helper.testName,\n              config,\n            });\n          }\n        }\n      }\n    }\n\n    return {\n      diagnostics: failures,\n      destructiveChanges,\n    };\n  }\n\n  private readAssembly(dir: string): AssemblyManifestReader {\n    return AssemblyManifestReader.fromPath(dir);\n  }\n\n  /**\n   * Reduce template to a normal form where asset references have been normalized\n   *\n   * This makes it possible to compare templates if all that's different between\n   * them is the hashes of the asset values.\n   */\n  private canonicalizeTemplate(template: any, assets: string[]): any {\n    const assetsSeen = new Set<string>();\n    const stringSubstitutions = new Array<[RegExp, string]>();\n\n    // Find assets via parameters (for LegacyStackSynthesizer)\n    const paramRe = /^AssetParameters([a-zA-Z0-9]{64})(S3Bucket|S3VersionKey|ArtifactHash)([a-zA-Z0-9]{8})$/;\n    for (const paramName of Object.keys(template?.Parameters || {})) {\n      const m = paramRe.exec(paramName);\n      if (!m) {\n        continue;\n      }\n      if (assetsSeen.has(m[1])) {\n        continue;\n      }\n\n      assetsSeen.add(m[1]);\n      const ix = assetsSeen.size;\n\n      // Full parameter reference\n      stringSubstitutions.push([\n        new RegExp(`AssetParameters${m[1]}(S3Bucket|S3VersionKey|ArtifactHash)([a-zA-Z0-9]{8})`),\n        `Asset${ix}$1`,\n      ]);\n      // Substring asset hash reference\n      stringSubstitutions.push([\n        new RegExp(`${m[1]}`),\n        `Asset${ix}Hash`,\n      ]);\n    }\n\n    // find assets defined in the asset manifest\n    try {\n      assets.forEach(asset => {\n        if (!assetsSeen.has(asset)) {\n          assetsSeen.add(asset);\n          const ix = assetsSeen.size;\n          stringSubstitutions.push([\n            new RegExp(asset),\n            `Asset${ix}$1`,\n          ]);\n        }\n      });\n    } catch {\n      // if there is no asset manifest that is fine.\n    }\n\n    // Substitute them out\n    return substitute(template);\n\n    function substitute(what: any): any {\n      if (Array.isArray(what)) {\n        return what.map(substitute);\n      }\n\n      if (typeof what === 'object' && what !== null) {\n        const ret: any = {};\n        for (const [k, v] of Object.entries(what)) {\n          ret[stringSub(k)] = substitute(v);\n        }\n        return ret;\n      }\n\n      if (typeof what === 'string') {\n        return stringSub(what);\n      }\n\n      return what;\n    }\n\n    function stringSub(x: string) {\n      for (const [re, replacement] of stringSubstitutions) {\n        x = x.replace(re, replacement);\n      }\n      return x;\n    }\n  }\n}\n\nclass StringWritable extends Writable {\n  public data: string;\n  private _decoder: StringDecoder;\n  constructor(options: WritableOptions) {\n    super(options);\n    this._decoder = new StringDecoder();\n    this.data = '';\n  }\n\n  _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void {\n    if (encoding === 'buffer') {\n      chunk = this._decoder.write(chunk);\n    }\n\n    this.data += chunk;\n    callback();\n  }\n\n  _final(callback: (error?: Error | null) => void): void {\n    this.data += this._decoder.end();\n    callback();\n  }\n}\n"]} |
+7
-7
@@ -67,9 +67,9 @@ { | ||
| "@aws-cdk/aws-service-spec": "^0.1.185", | ||
| "@aws-cdk/cdk-assets-lib": "1.4.11", | ||
| "@aws-cdk/cloud-assembly-api": "2.2.5", | ||
| "@aws-cdk/cloud-assembly-schema": ">=54.4.0", | ||
| "@aws-cdk/cdk-assets-lib": "1.4.12", | ||
| "@aws-cdk/cloud-assembly-api": "2.2.6", | ||
| "@aws-cdk/cloud-assembly-schema": ">=54.5.0", | ||
| "@aws-cdk/cloudformation-diff": "2.187.1", | ||
| "@aws-cdk/toolkit-lib": "1.29.1", | ||
| "@aws-cdk/toolkit-lib": "1.30.0", | ||
| "@aws-sdk/client-cloudformation": "^3", | ||
| "aws-cdk": "2.1128.0", | ||
| "aws-cdk": "2.1128.1", | ||
| "chalk": "^4", | ||
@@ -84,3 +84,3 @@ "chokidar": "^4", | ||
| "@aws-cdk/aws-service-spec": "0.1.185", | ||
| "aws-cdk": "2.1128.0" | ||
| "aws-cdk": "2.1128.1" | ||
| }, | ||
@@ -107,3 +107,3 @@ "keywords": [ | ||
| }, | ||
| "version": "2.200.1", | ||
| "version": "2.200.2", | ||
| "packageManager": "yarn@4.13.0", | ||
@@ -110,0 +110,0 @@ "types": "lib/index.d.ts", |
| import type { TestCase, DefaultCdkOptions } from '@aws-cdk/cloud-assembly-schema'; | ||
| import { IntegTestSuite, LegacyIntegTestSuite } from './integ-test-suite'; | ||
| import type { IntegTest } from './integration-tests'; | ||
| import type { ICdk } from '../engines/cdk-interface'; | ||
| import type { DestructiveChange } from '../workers/common'; | ||
| /** | ||
| * Options for creating an integration test runner | ||
| */ | ||
| export interface IntegRunnerOptions { | ||
| /** | ||
| * Information about the test to run | ||
| */ | ||
| readonly test: IntegTest; | ||
| /** | ||
| * The region where the test should be deployed | ||
| */ | ||
| readonly region: string; | ||
| /** | ||
| * The AWS profile to use when invoking the CDK CLI | ||
| * | ||
| * @default - no profile is passed, the default profile is used | ||
| */ | ||
| readonly profile?: string; | ||
| /** | ||
| * Additional environment variables that will be available | ||
| * to the CDK CLI | ||
| * | ||
| * @default - no additional environment variables | ||
| */ | ||
| readonly env?: { | ||
| [name: string]: string; | ||
| }; | ||
| /** | ||
| * tmp cdk.out directory | ||
| * | ||
| * @default - directory will be `cdk-integ.out.${testName}` | ||
| */ | ||
| readonly integOutDir?: string; | ||
| /** | ||
| * Instance of the CDK Toolkit Engine to use | ||
| * | ||
| * @default - based on `engine` option | ||
| */ | ||
| readonly cdk?: ICdk; | ||
| /** | ||
| * Show output from running integration tests | ||
| * | ||
| * @default false | ||
| */ | ||
| readonly showOutput?: boolean; | ||
| /** | ||
| * Use the indicated proxy | ||
| * | ||
| * @default - no proxy | ||
| */ | ||
| readonly proxy?: string; | ||
| /** | ||
| * Path to CA certificate to use when validating HTTPS requests | ||
| * | ||
| * @default - no additional CA bundle | ||
| */ | ||
| readonly caBundlePath?: string; | ||
| } | ||
| /** | ||
| * The different components of a test name | ||
| */ | ||
| /** | ||
| * Represents an Integration test runner | ||
| */ | ||
| export declare abstract class IntegRunner { | ||
| /** | ||
| * The directory where the snapshot will be stored | ||
| */ | ||
| readonly snapshotDir: string; | ||
| /** | ||
| * An instance of the CDK CLI | ||
| */ | ||
| readonly cdk: ICdk; | ||
| /** | ||
| * Pretty name of the test | ||
| */ | ||
| readonly testName: string; | ||
| /** | ||
| * The value used in the '--app' CLI parameter | ||
| * | ||
| * Path to the integ test source file, relative to `this.directory`. | ||
| */ | ||
| protected readonly cdkApp: string; | ||
| /** | ||
| * The path where the `cdk.context.json` file | ||
| * will be created | ||
| */ | ||
| protected readonly cdkContextPath: string; | ||
| /** | ||
| * The working directory that the integration tests will be | ||
| * executed from | ||
| */ | ||
| protected readonly directory: string; | ||
| /** | ||
| * The test to run | ||
| */ | ||
| protected readonly test: IntegTest; | ||
| /** | ||
| * Default options to pass to the CDK CLI | ||
| */ | ||
| protected readonly defaultArgs: DefaultCdkOptions; | ||
| /** | ||
| * The directory where the CDK will be synthed to | ||
| * | ||
| * Relative to cwd. | ||
| */ | ||
| protected readonly cdkOutDir: string; | ||
| /** | ||
| * The profile to use for the CDK CLI calls | ||
| */ | ||
| protected readonly profile?: string; | ||
| /** | ||
| * Show output from the integ test run. | ||
| */ | ||
| protected readonly showOutput: boolean; | ||
| protected _destructiveChanges?: DestructiveChange[]; | ||
| private legacyContext?; | ||
| private _expectedTestSuite?; | ||
| private _actualTestSuite?; | ||
| constructor(options: IntegRunnerOptions); | ||
| /** | ||
| * Return the list of expected (i.e. existing) test cases for this integration test | ||
| */ | ||
| expectedTests(): Promise<{ | ||
| [testName: string]: TestCase; | ||
| } | undefined>; | ||
| /** | ||
| * Return the list of actual (i.e. new) test cases for this integration test | ||
| */ | ||
| actualTests(): Promise<{ | ||
| [testName: string]: TestCase; | ||
| } | undefined>; | ||
| /** | ||
| * Generate a new "actual" snapshot which will be compared to the | ||
| * existing "expected" snapshot | ||
| * This will synth and then load the integration test manifest | ||
| */ | ||
| generateActualSnapshot(): Promise<IntegTestSuite | LegacyIntegTestSuite>; | ||
| /** | ||
| * Returns true if a snapshot already exists for this test | ||
| */ | ||
| hasSnapshot(): boolean; | ||
| /** | ||
| * The test suite from the existing snapshot | ||
| */ | ||
| protected expectedTestSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite | undefined>; | ||
| /** | ||
| * The test suite from the new "actual" snapshot | ||
| */ | ||
| protected actualTestSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite>; | ||
| /** | ||
| * Load the integ manifest which contains information | ||
| * on how to execute the tests | ||
| * First we try and load the manifest from the integ manifest (i.e. integ.json) | ||
| * from the cloud assembly. If it doesn't exist, then we fallback to the | ||
| * "legacy mode" and create a manifest from pragma | ||
| */ | ||
| protected loadManifest(dir?: string): Promise<IntegTestSuite | LegacyIntegTestSuite>; | ||
| protected cleanup(): void; | ||
| /** | ||
| * If there are any destructive changes to a stack then this will record | ||
| * those in the manifest.json file | ||
| */ | ||
| private renderTraceData; | ||
| /** | ||
| * In cases where we do not want to retain the assets, | ||
| * for example, if the assets are very large. | ||
| * | ||
| * Since it is possible to disable the update workflow for individual test | ||
| * cases, this needs to first get a list of stacks that have the update workflow | ||
| * disabled and then delete assets that relate to that stack. It does that | ||
| * by reading the asset manifest for the stack and deleting the asset source | ||
| */ | ||
| protected removeAssetsFromSnapshot(): Promise<void>; | ||
| /** | ||
| * Remove the asset cache (.cache/) files from the snapshot. | ||
| * These are a cache of the asset zips, but we are fine with | ||
| * re-zipping on deploy | ||
| */ | ||
| protected removeAssetsCacheFromSnapshot(): void; | ||
| /** | ||
| * Create the new snapshot. | ||
| * | ||
| * If lookups are enabled, then we need create the snapshot by synth'ing again | ||
| * with the dummy context so that each time the test is run on different machines | ||
| * (and with different context/env) the diff will not change. | ||
| * | ||
| * If lookups are disabled (which means the stack is env agnostic) then just copy | ||
| * the assembly that was output by the deployment | ||
| */ | ||
| protected createSnapshot(): Promise<void>; | ||
| /** | ||
| * Perform some cleanup steps after the snapshot is created | ||
| * Anytime the snapshot needs to be modified after creation | ||
| * the logic should live here. | ||
| */ | ||
| private cleanupSnapshot; | ||
| protected getContext(additionalContext?: Record<string, any>): Record<string, any>; | ||
| } | ||
| export declare const DEFAULT_SYNTH_OPTIONS: { | ||
| context: { | ||
| "aws:cdk:availability-zones:fallback": string[]; | ||
| 'availability-zones:account=12345678:region=test-region': string[]; | ||
| 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2:region=test-region': string; | ||
| 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2:region=test-region': string; | ||
| 'ssm:account=12345678:parameterName=/aws/service/ecs/optimized-ami/amazon-linux/recommended:region=test-region': string; | ||
| 'ami:account=12345678:filters.image-type.0=machine:filters.name.0=amzn-ami-vpc-nat-*:filters.state.0=available:owners.0=amazon:region=test-region': string; | ||
| 'vpc-provider:account=12345678:filter.isDefault=true:region=test-region:returnAsymmetricSubnets=true': { | ||
| vpcId: string; | ||
| subnetGroups: { | ||
| type: string; | ||
| name: string; | ||
| subnets: { | ||
| subnetId: string; | ||
| availabilityZone: string; | ||
| routeTableId: string; | ||
| }[]; | ||
| }[]; | ||
| }; | ||
| }; | ||
| env: { | ||
| CDK_INTEG_ACCOUNT: string; | ||
| CDK_INTEG_REGION: string; | ||
| CDK_INTEG_HOSTED_ZONE_ID: string; | ||
| CDK_INTEG_HOSTED_ZONE_NAME: string; | ||
| CDK_INTEG_DOMAIN_NAME: string; | ||
| CDK_INTEG_CERT_ARN: string; | ||
| CDK_INTEG_SUBNET_ID: string; | ||
| }; | ||
| }; | ||
| /** | ||
| * Return the currently recommended flags for `aws-cdk-lib`. | ||
| * | ||
| * These have been built into the CLI at build time. If this ever gets changed | ||
| * back to a dynamic load, remember that this source file may be bundled into | ||
| * a JavaScript bundle, and `__dirname` might not point where you think it does. | ||
| */ | ||
| export declare function currentlyRecommendedAwsCdkLibFlags(): { | ||
| "@aws-cdk/aws-signer:signingProfileNamePassedToCfn": boolean; | ||
| "@aws-cdk/aws-ecs-patterns:secGroupsDisablesImplicitOpenListener": boolean; | ||
| "@aws-cdk/aws-lambda:recognizeLayerVersion": boolean; | ||
| "@aws-cdk/core:checkSecretUsage": boolean; | ||
| "@aws-cdk/core:target-partitions": string[]; | ||
| "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": boolean; | ||
| "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": boolean; | ||
| "@aws-cdk/aws-ecs:arnFormatIncludesClusterName": boolean; | ||
| "@aws-cdk/aws-iam:minimizePolicies": boolean; | ||
| "@aws-cdk/core:validateSnapshotRemovalPolicy": boolean; | ||
| "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": boolean; | ||
| "@aws-cdk/aws-s3:createDefaultLoggingPolicy": boolean; | ||
| "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": boolean; | ||
| "@aws-cdk/aws-apigateway:disableCloudWatchRole": boolean; | ||
| "@aws-cdk/core:enablePartitionLiterals": boolean; | ||
| "@aws-cdk/aws-events:eventsTargetQueueSameAccount": boolean; | ||
| "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": boolean; | ||
| "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName": boolean; | ||
| "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": boolean; | ||
| "@aws-cdk/aws-route53-patters:useCertificate": boolean; | ||
| "@aws-cdk/customresources:installLatestAwsSdkDefault": boolean; | ||
| "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": boolean; | ||
| "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup": boolean; | ||
| "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId": boolean; | ||
| "@aws-cdk/aws-ec2:launchTemplateDefaultUserData": boolean; | ||
| "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments": boolean; | ||
| "@aws-cdk/aws-redshift:columnId": boolean; | ||
| "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2": boolean; | ||
| "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": boolean; | ||
| "@aws-cdk/aws-apigateway:requestValidatorUniqueId": boolean; | ||
| "@aws-cdk/aws-kms:aliasNameRef": boolean; | ||
| "@aws-cdk/aws-kms:applyImportedAliasPermissionsToPrincipal": boolean; | ||
| "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": boolean; | ||
| "@aws-cdk/core:includePrefixInUniqueNameGeneration": boolean; | ||
| "@aws-cdk/aws-efs:denyAnonymousAccess": boolean; | ||
| "@aws-cdk/aws-opensearchservice:enableOpensearchMultiAzWithStandby": boolean; | ||
| "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion": boolean; | ||
| "@aws-cdk/aws-efs:mountTargetOrderInsensitiveLogicalId": boolean; | ||
| "@aws-cdk/aws-rds:auroraClusterChangeScopeOfInstanceParameterGroupWithEachParameters": boolean; | ||
| "@aws-cdk/aws-appsync:useArnForSourceApiAssociationIdentifier": boolean; | ||
| "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials": boolean; | ||
| "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForCodeCommitSource": boolean; | ||
| "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction": boolean; | ||
| "@aws-cdk/aws-codepipeline:crossAccountKeysDefaultValueToFalse": boolean; | ||
| "@aws-cdk/aws-codepipeline:defaultPipelineTypeToV2": boolean; | ||
| "@aws-cdk/aws-kms:reduceCrossAccountRegionPolicyScope": boolean; | ||
| "@aws-cdk/aws-eks:nodegroupNameAttribute": boolean; | ||
| "@aws-cdk/aws-eks:useNativeOidcProvider": boolean; | ||
| "@aws-cdk/aws-ec2:ebsDefaultGp3Volume": boolean; | ||
| "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm": boolean; | ||
| "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault": boolean; | ||
| "@aws-cdk/aws-s3:keepNotificationInImportedBucket": boolean; | ||
| "@aws-cdk/core:explicitStackTags": boolean; | ||
| "@aws-cdk/aws-ecs:reduceEc2FargateCloudWatchPermissions": boolean; | ||
| "@aws-cdk/aws-dynamodb:resourcePolicyPerReplica": boolean; | ||
| "@aws-cdk/aws-ec2:ec2SumTImeoutEnabled": boolean; | ||
| "@aws-cdk/aws-appsync:appSyncGraphQLAPIScopeLambdaPermission": boolean; | ||
| "@aws-cdk/aws-rds:setCorrectValueForDatabaseInstanceReadReplicaInstanceResourceId": boolean; | ||
| "@aws-cdk/core:cfnIncludeRejectComplexResourceUpdateCreatePolicyIntrinsics": boolean; | ||
| "@aws-cdk/aws-lambda-nodejs:sdkV3ExcludeSmithyPackages": boolean; | ||
| "@aws-cdk/aws-stepfunctions-tasks:fixRunEcsTaskPolicy": boolean; | ||
| "@aws-cdk/aws-ec2:bastionHostUseAmazonLinux2023ByDefault": boolean; | ||
| "@aws-cdk/aws-route53-targets:userPoolDomainNameMethodWithoutCustomResource": boolean; | ||
| "@aws-cdk/aws-elasticloadbalancingV2:albDualstackWithoutPublicIpv4SecurityGroupRulesDefault": boolean; | ||
| "@aws-cdk/aws-iam:oidcRejectUnauthorizedConnections": boolean; | ||
| "@aws-cdk/core:enableAdditionalMetadataCollection": boolean; | ||
| "@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy": boolean; | ||
| "@aws-cdk/aws-s3:setUniqueReplicationRoleName": boolean; | ||
| "@aws-cdk/aws-events:requireEventBusPolicySid": boolean; | ||
| "@aws-cdk/core:aspectPrioritiesMutating": boolean; | ||
| "@aws-cdk/aws-dynamodb:retainTableReplica": boolean; | ||
| "@aws-cdk/aws-stepfunctions:useDistributedMapResultWriterV2": boolean; | ||
| "@aws-cdk/s3-notifications:addS3TrustKeyPolicyForSnsSubscriptions": boolean; | ||
| "@aws-cdk/aws-ec2:requirePrivateSubnetsForEgressOnlyInternetGateway": boolean; | ||
| "@aws-cdk/aws-s3:publicAccessBlockedByDefault": boolean; | ||
| "@aws-cdk/aws-lambda:useCdkManagedLogGroup": boolean; | ||
| "@aws-cdk/aws-elasticloadbalancingv2:networkLoadBalancerWithSecurityGroupByDefault": boolean; | ||
| "@aws-cdk/aws-ecs-patterns:uniqueTargetGroupId": boolean; | ||
| "@aws-cdk/aws-route53-patterns:useDistribution": boolean; | ||
| "@aws-cdk/aws-cloudfront:defaultFunctionRuntimeV2_0": boolean; | ||
| "@aws-cdk/aws-elasticloadbalancingv2:usePostQuantumTlsPolicy": boolean; | ||
| "@aws-cdk/aws-batch:defaultToAL2023": boolean; | ||
| "@aws-cdk/core:annotationsInValidationReport": boolean; | ||
| }; | ||
| //# sourceMappingURL=runner-base.d.ts.map |
| {"version":3,"file":"runner-base.d.ts","sourceRoot":"","sources":["runner-base.ts"],"names":[],"mappings":"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"} |
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.DEFAULT_SYNTH_OPTIONS = exports.IntegRunner = void 0; | ||
| exports.currentlyRecommendedAwsCdkLibFlags = currentlyRecommendedAwsCdkLibFlags; | ||
| /* eslint-disable @cdklabs/no-literal-partition */ | ||
| const path = require("path"); | ||
| const cloud_assembly_api_1 = require("@aws-cdk/cloud-assembly-api"); | ||
| const fs = require("fs-extra"); | ||
| const integ_test_suite_1 = require("./integ-test-suite"); | ||
| const recommendedFlagsFile = require("../recommended-feature-flags.json"); | ||
| const utils_1 = require("../utils"); | ||
| const engine_1 = require("./engine"); | ||
| const logger = require("../logger"); | ||
| const cloud_assembly_1 = require("./private/cloud-assembly"); | ||
| const integ_manifest_1 = require("./private/integ-manifest"); | ||
| const DESTRUCTIVE_CHANGES = '!!DESTRUCTIVE_CHANGES:'; | ||
| /** | ||
| * The different components of a test name | ||
| */ | ||
| /** | ||
| * Represents an Integration test runner | ||
| */ | ||
| class IntegRunner { | ||
| /** | ||
| * The directory where the snapshot will be stored | ||
| */ | ||
| snapshotDir; | ||
| /** | ||
| * An instance of the CDK CLI | ||
| */ | ||
| cdk; | ||
| /** | ||
| * Pretty name of the test | ||
| */ | ||
| testName; | ||
| /** | ||
| * The value used in the '--app' CLI parameter | ||
| * | ||
| * Path to the integ test source file, relative to `this.directory`. | ||
| */ | ||
| cdkApp; | ||
| /** | ||
| * The path where the `cdk.context.json` file | ||
| * will be created | ||
| */ | ||
| cdkContextPath; | ||
| /** | ||
| * The working directory that the integration tests will be | ||
| * executed from | ||
| */ | ||
| directory; | ||
| /** | ||
| * The test to run | ||
| */ | ||
| test; | ||
| /** | ||
| * Default options to pass to the CDK CLI | ||
| */ | ||
| defaultArgs = { | ||
| pathMetadata: false, | ||
| assetMetadata: false, | ||
| versionReporting: false, | ||
| }; | ||
| /** | ||
| * The directory where the CDK will be synthed to | ||
| * | ||
| * Relative to cwd. | ||
| */ | ||
| cdkOutDir; | ||
| /** | ||
| * The profile to use for the CDK CLI calls | ||
| */ | ||
| profile; | ||
| /** | ||
| * Show output from the integ test run. | ||
| */ | ||
| showOutput; | ||
| _destructiveChanges; | ||
| legacyContext; | ||
| _expectedTestSuite; | ||
| _actualTestSuite; | ||
| constructor(options) { | ||
| this.test = options.test; | ||
| this.directory = this.test.directory; | ||
| this.testName = this.test.testName; | ||
| this.snapshotDir = this.test.snapshotDir; | ||
| this.cdkContextPath = path.join(this.directory, 'cdk.context.json'); | ||
| this.profile = options.profile; | ||
| this.showOutput = options.showOutput ?? false; | ||
| this.cdk = options.cdk ?? (0, engine_1.makeEngine)(options); | ||
| this.cdkOutDir = options.integOutDir ?? this.test.temporaryOutputDir; | ||
| const testRunCommand = this.test.appCommand; | ||
| this.cdkApp = testRunCommand.replace('{filePath}', path.relative(this.directory, this.test.fileName)); | ||
| } | ||
| /** | ||
| * Return the list of expected (i.e. existing) test cases for this integration test | ||
| */ | ||
| async expectedTests() { | ||
| return (await this.expectedTestSuite())?.testSuite; | ||
| } | ||
| /** | ||
| * Return the list of actual (i.e. new) test cases for this integration test | ||
| */ | ||
| async actualTests() { | ||
| return (await this.actualTestSuite()).testSuite; | ||
| } | ||
| /** | ||
| * Generate a new "actual" snapshot which will be compared to the | ||
| * existing "expected" snapshot | ||
| * This will synth and then load the integration test manifest | ||
| */ | ||
| async generateActualSnapshot() { | ||
| await this.cdk.synth({ | ||
| app: this.cdkApp, | ||
| // we don't know the "actual" context yet (this method is what generates it) so just | ||
| // use the "expected" context. This is only run in order to read the manifest | ||
| context: this.getContext((await this.expectedTestSuite())?.synthContext), | ||
| env: exports.DEFAULT_SYNTH_OPTIONS.env, | ||
| output: path.relative(this.directory, this.cdkOutDir), | ||
| }); | ||
| const manifest = await this.loadManifest(this.cdkOutDir); | ||
| // after we load the manifest remove the tmp snapshot | ||
| // so that it doesn't mess up the real snapshot created later | ||
| this.cleanup(); | ||
| return manifest; | ||
| } | ||
| /** | ||
| * Returns true if a snapshot already exists for this test | ||
| */ | ||
| hasSnapshot() { | ||
| return fs.existsSync(this.snapshotDir); | ||
| } | ||
| /** | ||
| * The test suite from the existing snapshot | ||
| */ | ||
| async expectedTestSuite() { | ||
| if (!this._expectedTestSuite && this.hasSnapshot()) { | ||
| this._expectedTestSuite = await this.loadManifest(); | ||
| } | ||
| return this._expectedTestSuite; | ||
| } | ||
| /** | ||
| * The test suite from the new "actual" snapshot | ||
| */ | ||
| async actualTestSuite() { | ||
| if (!this._actualTestSuite) { | ||
| this._actualTestSuite = await this.generateActualSnapshot(); | ||
| } | ||
| return this._actualTestSuite; | ||
| } | ||
| /** | ||
| * Load the integ manifest which contains information | ||
| * on how to execute the tests | ||
| * First we try and load the manifest from the integ manifest (i.e. integ.json) | ||
| * from the cloud assembly. If it doesn't exist, then we fallback to the | ||
| * "legacy mode" and create a manifest from pragma | ||
| */ | ||
| async loadManifest(dir) { | ||
| const manifest = dir ?? this.snapshotDir; | ||
| try { | ||
| const testSuite = integ_test_suite_1.IntegTestSuite.fromPath(manifest); | ||
| return testSuite; | ||
| } | ||
| catch (modernError) { | ||
| // Only attempt legacy test case if the integ test manifest was not found | ||
| // For any other errors, e.g. when parsing the manifest fails, we abort. | ||
| if (!(modernError instanceof integ_manifest_1.NoManifestError)) { | ||
| throw modernError; | ||
| } | ||
| if (this.showOutput) { | ||
| logger.trace("Failed to load integ test manifest for '%s'. Attempting as deprecated legacy test instead. Error was: %s", manifest, modernError.message ?? String(modernError)); | ||
| } | ||
| const testCases = await integ_test_suite_1.LegacyIntegTestSuite.fromLegacy({ | ||
| cdk: this.cdk, | ||
| testName: this.test.normalizedTestName, | ||
| integSourceFilePath: this.test.fileName, | ||
| listOptions: { | ||
| ...this.defaultArgs, | ||
| all: true, | ||
| app: this.cdkApp, | ||
| profile: this.profile, | ||
| output: path.relative(this.directory, this.cdkOutDir), | ||
| }, | ||
| }); | ||
| this.legacyContext = integ_test_suite_1.LegacyIntegTestSuite.getPragmaContext(this.test.fileName); | ||
| return testCases; | ||
| } | ||
| } | ||
| cleanup() { | ||
| const cdkOutPath = this.cdkOutDir; | ||
| if (fs.existsSync(cdkOutPath)) { | ||
| fs.removeSync(cdkOutPath); | ||
| } | ||
| } | ||
| /** | ||
| * If there are any destructive changes to a stack then this will record | ||
| * those in the manifest.json file | ||
| */ | ||
| renderTraceData() { | ||
| const traceData = new Map(); | ||
| const destructiveChanges = this._destructiveChanges ?? []; | ||
| destructiveChanges.forEach(change => { | ||
| const trace = traceData.get(change.stackName); | ||
| if (trace) { | ||
| trace.set(change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`); | ||
| } | ||
| else { | ||
| traceData.set(change.stackName, new Map([ | ||
| [change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`], | ||
| ])); | ||
| } | ||
| }); | ||
| return traceData; | ||
| } | ||
| /** | ||
| * In cases where we do not want to retain the assets, | ||
| * for example, if the assets are very large. | ||
| * | ||
| * Since it is possible to disable the update workflow for individual test | ||
| * cases, this needs to first get a list of stacks that have the update workflow | ||
| * disabled and then delete assets that relate to that stack. It does that | ||
| * by reading the asset manifest for the stack and deleting the asset source | ||
| */ | ||
| async removeAssetsFromSnapshot() { | ||
| const stacks = (await this.actualTestSuite()).getStacksWithoutUpdateWorkflow() ?? []; | ||
| const manifest = cloud_assembly_1.AssemblyManifestReader.fromPath(this.snapshotDir); | ||
| const assets = (0, utils_1.flatten)(stacks.map(stack => { | ||
| return manifest.getAssetLocationsForStack(stack) ?? []; | ||
| })); | ||
| assets.forEach(asset => { | ||
| const fileName = path.join(this.snapshotDir, asset); | ||
| if (fs.existsSync(fileName)) { | ||
| if (fs.lstatSync(fileName).isDirectory()) { | ||
| fs.removeSync(fileName); | ||
| } | ||
| else { | ||
| fs.unlinkSync(fileName); | ||
| } | ||
| } | ||
| }); | ||
| } | ||
| /** | ||
| * Remove the asset cache (.cache/) files from the snapshot. | ||
| * These are a cache of the asset zips, but we are fine with | ||
| * re-zipping on deploy | ||
| */ | ||
| removeAssetsCacheFromSnapshot() { | ||
| const files = fs.readdirSync(this.snapshotDir); | ||
| files.forEach(file => { | ||
| const fileName = path.join(this.snapshotDir, file); | ||
| if (fs.lstatSync(fileName).isDirectory() && file === '.cache') { | ||
| fs.emptyDirSync(fileName); | ||
| fs.rmdirSync(fileName); | ||
| } | ||
| }); | ||
| } | ||
| /** | ||
| * Create the new snapshot. | ||
| * | ||
| * If lookups are enabled, then we need create the snapshot by synth'ing again | ||
| * with the dummy context so that each time the test is run on different machines | ||
| * (and with different context/env) the diff will not change. | ||
| * | ||
| * If lookups are disabled (which means the stack is env agnostic) then just copy | ||
| * the assembly that was output by the deployment | ||
| */ | ||
| async createSnapshot() { | ||
| if (fs.existsSync(this.snapshotDir)) { | ||
| fs.removeSync(this.snapshotDir); | ||
| } | ||
| const actualTestSuite = await this.actualTestSuite(); | ||
| // if lookups are enabled then we need to synth again | ||
| // using dummy context and save that as the snapshot | ||
| await this.cdk.synth({ | ||
| app: this.cdkApp, | ||
| context: this.getContext(actualTestSuite.enableLookups ? exports.DEFAULT_SYNTH_OPTIONS.context : {}), | ||
| env: exports.DEFAULT_SYNTH_OPTIONS.env, | ||
| output: path.relative(this.directory, this.snapshotDir), | ||
| }); | ||
| await this.cleanupSnapshot(); | ||
| } | ||
| /** | ||
| * Perform some cleanup steps after the snapshot is created | ||
| * Anytime the snapshot needs to be modified after creation | ||
| * the logic should live here. | ||
| */ | ||
| async cleanupSnapshot() { | ||
| if (fs.existsSync(this.snapshotDir)) { | ||
| await this.removeAssetsFromSnapshot(); | ||
| this.removeAssetsCacheFromSnapshot(); | ||
| const assembly = cloud_assembly_1.AssemblyManifestReader.fromPath(this.snapshotDir); | ||
| assembly.cleanManifest(); | ||
| assembly.recordTrace(this.renderTraceData()); | ||
| } | ||
| // if this is a legacy test then create an integ manifest | ||
| // in the snapshot directory which can be used for the | ||
| // update workflow. Save any legacyContext as well so that it can be read | ||
| // the next time | ||
| const actualTestSuite = await this.actualTestSuite(); | ||
| if (actualTestSuite.type === 'legacy-test-suite') { | ||
| actualTestSuite.saveManifest(this.snapshotDir, this.legacyContext); | ||
| } | ||
| } | ||
| getContext(additionalContext) { | ||
| return { | ||
| ...currentlyRecommendedAwsCdkLibFlags(), | ||
| ...this.legacyContext, | ||
| ...additionalContext, | ||
| // We originally had PLANNED to set this to ['aws', 'aws-cn'], but due to a programming mistake | ||
| // it was set to everything. In this PR, set it to everything to not mess up all the snapshots. | ||
| ['@aws-cdk/core:target-partitions']: undefined, | ||
| /* ---------------- THE FUTURE LIVES BELOW---------------------------- | ||
| // Restricting to these target partitions makes most service principals synthesize to | ||
| // `service.${URL_SUFFIX}`, which is technically *incorrect* (it's only `amazonaws.com` | ||
| // or `amazonaws.com.cn`, never UrlSuffix for any of the restricted regions) but it's what | ||
| // most existing integ tests contain, and we want to disturb as few as possible. | ||
| // [TARGET_PARTITIONS]: ['aws', 'aws-cn'], | ||
| /* ---------------- END OF THE FUTURE ------------------------------- */ | ||
| }; | ||
| } | ||
| } | ||
| exports.IntegRunner = IntegRunner; | ||
| // Default context we run all integ tests with, so they don't depend on the | ||
| // account of the exercising user. | ||
| exports.DEFAULT_SYNTH_OPTIONS = { | ||
| context: { | ||
| [cloud_assembly_api_1.AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY]: ['test-region-1a', 'test-region-1b', 'test-region-1c'], | ||
| 'availability-zones:account=12345678:region=test-region': ['test-region-1a', 'test-region-1b', 'test-region-1c'], | ||
| 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234', | ||
| 'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234', | ||
| 'ssm:account=12345678:parameterName=/aws/service/ecs/optimized-ami/amazon-linux/recommended:region=test-region': '{"image_id": "ami-1234"}', | ||
| // eslint-disable-next-line @stylistic/max-len | ||
| 'ami:account=12345678:filters.image-type.0=machine:filters.name.0=amzn-ami-vpc-nat-*:filters.state.0=available:owners.0=amazon:region=test-region': 'ami-1234', | ||
| 'vpc-provider:account=12345678:filter.isDefault=true:region=test-region:returnAsymmetricSubnets=true': { | ||
| vpcId: 'vpc-60900905', | ||
| subnetGroups: [ | ||
| { | ||
| type: 'Public', | ||
| name: 'Public', | ||
| subnets: [ | ||
| { | ||
| subnetId: 'subnet-e19455ca', | ||
| availabilityZone: 'us-east-1a', | ||
| routeTableId: 'rtb-e19455ca', | ||
| }, | ||
| { | ||
| subnetId: 'subnet-e0c24797', | ||
| availabilityZone: 'us-east-1b', | ||
| routeTableId: 'rtb-e0c24797', | ||
| }, | ||
| { | ||
| subnetId: 'subnet-ccd77395', | ||
| availabilityZone: 'us-east-1c', | ||
| routeTableId: 'rtb-ccd77395', | ||
| }, | ||
| ], | ||
| }, | ||
| ], | ||
| }, | ||
| }, | ||
| env: { | ||
| CDK_INTEG_ACCOUNT: '12345678', | ||
| CDK_INTEG_REGION: 'test-region', | ||
| CDK_INTEG_HOSTED_ZONE_ID: 'Z23ABC4XYZL05B', | ||
| CDK_INTEG_HOSTED_ZONE_NAME: 'example.com', | ||
| CDK_INTEG_DOMAIN_NAME: '*.example.com', | ||
| CDK_INTEG_CERT_ARN: 'arn:aws:acm:test-region:12345678:certificate/86468209-a272-595d-b831-0efb6421265z', | ||
| CDK_INTEG_SUBNET_ID: 'subnet-0dff1a399d8f6f92c', | ||
| }, | ||
| }; | ||
| /** | ||
| * Return the currently recommended flags for `aws-cdk-lib`. | ||
| * | ||
| * These have been built into the CLI at build time. If this ever gets changed | ||
| * back to a dynamic load, remember that this source file may be bundled into | ||
| * a JavaScript bundle, and `__dirname` might not point where you think it does. | ||
| */ | ||
| function currentlyRecommendedAwsCdkLibFlags() { | ||
| return recommendedFlagsFile; | ||
| } | ||
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runner-base.js","sourceRoot":"","sources":["runner-base.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @cdklabs/no-literal-partition */\nimport * as path from 'path';\nimport { AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY } from '@aws-cdk/cloud-assembly-api';\nimport type { TestCase, DefaultCdkOptions } from '@aws-cdk/cloud-assembly-schema';\nimport * as fs from 'fs-extra';\nimport { IntegTestSuite, LegacyIntegTestSuite } from './integ-test-suite';\nimport type { IntegTest } from './integration-tests';\nimport * as recommendedFlagsFile from '../recommended-feature-flags.json';\nimport { flatten } from '../utils';\nimport { makeEngine } from './engine';\nimport type { ICdk } from '../engines/cdk-interface';\nimport * as logger from '../logger';\nimport type { ManifestTrace } from './private/cloud-assembly';\nimport { AssemblyManifestReader } from './private/cloud-assembly';\nimport type { DestructiveChange } from '../workers/common';\nimport { NoManifestError } from './private/integ-manifest';\n\nconst DESTRUCTIVE_CHANGES = '!!DESTRUCTIVE_CHANGES:';\n\n/**\n * Options for creating an integration test runner\n */\nexport interface IntegRunnerOptions {\n  /**\n   * Information about the test to run\n   */\n  readonly test: IntegTest;\n\n  /**\n   * The region where the test should be deployed\n   */\n  readonly region: string;\n\n  /**\n   * The AWS profile to use when invoking the CDK CLI\n   *\n   * @default - no profile is passed, the default profile is used\n   */\n  readonly profile?: string;\n\n  /**\n   * Additional environment variables that will be available\n   * to the CDK CLI\n   *\n   * @default - no additional environment variables\n   */\n  readonly env?: { [name: string]: string };\n\n  /**\n   * tmp cdk.out directory\n   *\n   * @default - directory will be `cdk-integ.out.${testName}`\n   */\n  readonly integOutDir?: string;\n\n  /**\n   * Instance of the CDK Toolkit Engine to use\n   *\n   * @default - based on `engine` option\n   */\n  readonly cdk?: ICdk;\n\n  /**\n   * Show output from running integration tests\n   *\n   * @default false\n   */\n  readonly showOutput?: boolean;\n\n  /**\n   * Use the indicated proxy\n   *\n   * @default - no proxy\n   */\n  readonly proxy?: string;\n\n  /**\n   * Path to CA certificate to use when validating HTTPS requests\n   *\n   * @default - no additional CA bundle\n   */\n  readonly caBundlePath?: string;\n}\n\n/**\n * The different components of a test name\n */\n/**\n * Represents an Integration test runner\n */\nexport abstract class IntegRunner {\n  /**\n   * The directory where the snapshot will be stored\n   */\n  public readonly snapshotDir: string;\n\n  /**\n   * An instance of the CDK  CLI\n   */\n  public readonly cdk: ICdk;\n\n  /**\n   * Pretty name of the test\n   */\n  public readonly testName: string;\n\n  /**\n   * The value used in the '--app' CLI parameter\n   *\n   * Path to the integ test source file, relative to `this.directory`.\n   */\n  protected readonly cdkApp: string;\n\n  /**\n   * The path where the `cdk.context.json` file\n   * will be created\n   */\n  protected readonly cdkContextPath: string;\n\n  /**\n   * The working directory that the integration tests will be\n   * executed from\n   */\n  protected readonly directory: string;\n\n  /**\n   * The test to run\n   */\n  protected readonly test: IntegTest;\n\n  /**\n   * Default options to pass to the CDK CLI\n   */\n  protected readonly defaultArgs: DefaultCdkOptions = {\n    pathMetadata: false,\n    assetMetadata: false,\n    versionReporting: false,\n  };\n\n  /**\n   * The directory where the CDK will be synthed to\n   *\n   * Relative to cwd.\n   */\n  protected readonly cdkOutDir: string;\n\n  /**\n   * The profile to use for the CDK CLI calls\n   */\n  protected readonly profile?: string;\n\n  /**\n   * Show output from the integ test run.\n   */\n  protected readonly showOutput: boolean;\n\n  protected _destructiveChanges?: DestructiveChange[];\n  private legacyContext?: Record<string, any>;\n  private _expectedTestSuite?: IntegTestSuite | LegacyIntegTestSuite;\n  private _actualTestSuite?: IntegTestSuite | LegacyIntegTestSuite;\n\n  constructor(options: IntegRunnerOptions) {\n    this.test = options.test;\n    this.directory = this.test.directory;\n    this.testName = this.test.testName;\n    this.snapshotDir = this.test.snapshotDir;\n    this.cdkContextPath = path.join(this.directory, 'cdk.context.json');\n    this.profile = options.profile;\n    this.showOutput = options.showOutput ?? false;\n\n    this.cdk = options.cdk ?? makeEngine(options);\n    this.cdkOutDir = options.integOutDir ?? this.test.temporaryOutputDir;\n\n    const testRunCommand = this.test.appCommand;\n    this.cdkApp = testRunCommand.replace('{filePath}', path.relative(this.directory, this.test.fileName));\n  }\n\n  /**\n   * Return the list of expected (i.e. existing) test cases for this integration test\n   */\n  public async expectedTests(): Promise<{ [testName: string]: TestCase } | undefined> {\n    return (await this.expectedTestSuite())?.testSuite;\n  }\n\n  /**\n   * Return the list of actual (i.e. new) test cases for this integration test\n   */\n  public async actualTests(): Promise<{ [testName: string]: TestCase } | undefined> {\n    return (await this.actualTestSuite()).testSuite;\n  }\n\n  /**\n   * Generate a new \"actual\" snapshot which will be compared to the\n   * existing \"expected\" snapshot\n   * This will synth and then load the integration test manifest\n   */\n  public async generateActualSnapshot(): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    await this.cdk.synth({\n      app: this.cdkApp,\n      // we don't know the \"actual\" context yet (this method is what generates it) so just\n      // use the \"expected\" context. This is only run in order to read the manifest\n      context: this.getContext((await this.expectedTestSuite())?.synthContext),\n      env: DEFAULT_SYNTH_OPTIONS.env,\n      output: path.relative(this.directory, this.cdkOutDir),\n    });\n    const manifest = await this.loadManifest(this.cdkOutDir);\n    // after we load the manifest remove the tmp snapshot\n    // so that it doesn't mess up the real snapshot created later\n    this.cleanup();\n    return manifest;\n  }\n\n  /**\n   * Returns true if a snapshot already exists for this test\n   */\n  public hasSnapshot(): boolean {\n    return fs.existsSync(this.snapshotDir);\n  }\n\n  /**\n   * The test suite from the existing snapshot\n   */\n  protected async expectedTestSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite | undefined> {\n    if (!this._expectedTestSuite && this.hasSnapshot()) {\n      this._expectedTestSuite = await this.loadManifest();\n    }\n    return this._expectedTestSuite;\n  }\n\n  /**\n   * The test suite from the new \"actual\" snapshot\n   */\n  protected async actualTestSuite(): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    if (!this._actualTestSuite) {\n      this._actualTestSuite = await this.generateActualSnapshot();\n    }\n    return this._actualTestSuite;\n  }\n\n  /**\n   * Load the integ manifest which contains information\n   * on how to execute the tests\n   * First we try and load the manifest from the integ manifest (i.e. integ.json)\n   * from the cloud assembly. If it doesn't exist, then we fallback to the\n   * \"legacy mode\" and create a manifest from pragma\n   */\n  protected async loadManifest(dir?: string): Promise<IntegTestSuite | LegacyIntegTestSuite> {\n    const manifest = dir ?? this.snapshotDir;\n    try {\n      const testSuite = IntegTestSuite.fromPath(manifest);\n      return testSuite;\n    } catch (modernError: any) {\n      // Only attempt legacy test case if the integ test manifest was not found\n      // For any other errors, e.g. when parsing the manifest fails, we abort.\n      if (!(modernError instanceof NoManifestError)) {\n        throw modernError;\n      }\n\n      if (this.showOutput) {\n        logger.trace(\n          \"Failed to load integ test manifest for '%s'. Attempting as deprecated legacy test instead. Error was: %s\",\n          manifest,\n          modernError.message ?? String(modernError),\n        );\n      }\n\n      const testCases = await LegacyIntegTestSuite.fromLegacy({\n        cdk: this.cdk,\n        testName: this.test.normalizedTestName,\n        integSourceFilePath: this.test.fileName,\n        listOptions: {\n          ...this.defaultArgs,\n          all: true,\n          app: this.cdkApp,\n          profile: this.profile,\n          output: path.relative(this.directory, this.cdkOutDir),\n        },\n      });\n      this.legacyContext = LegacyIntegTestSuite.getPragmaContext(this.test.fileName);\n      return testCases;\n    }\n  }\n\n  protected cleanup(): void {\n    const cdkOutPath = this.cdkOutDir;\n    if (fs.existsSync(cdkOutPath)) {\n      fs.removeSync(cdkOutPath);\n    }\n  }\n\n  /**\n   * If there are any destructive changes to a stack then this will record\n   * those in the manifest.json file\n   */\n  private renderTraceData(): ManifestTrace {\n    const traceData: ManifestTrace = new Map();\n    const destructiveChanges = this._destructiveChanges ?? [];\n    destructiveChanges.forEach(change => {\n      const trace = traceData.get(change.stackName);\n      if (trace) {\n        trace.set(change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`);\n      } else {\n        traceData.set(change.stackName, new Map([\n          [change.logicalId, `${DESTRUCTIVE_CHANGES} ${change.impact}`],\n        ]));\n      }\n    });\n    return traceData;\n  }\n\n  /**\n   * In cases where we do not want to retain the assets,\n   * for example, if the assets are very large.\n   *\n   * Since it is possible to disable the update workflow for individual test\n   * cases, this needs to first get a list of stacks that have the update workflow\n   * disabled and then delete assets that relate to that stack. It does that\n   * by reading the asset manifest for the stack and deleting the asset source\n   */\n  protected async removeAssetsFromSnapshot(): Promise<void> {\n    const stacks = (await this.actualTestSuite()).getStacksWithoutUpdateWorkflow() ?? [];\n    const manifest = AssemblyManifestReader.fromPath(this.snapshotDir);\n    const assets = flatten(stacks.map(stack => {\n      return manifest.getAssetLocationsForStack(stack) ?? [];\n    }));\n\n    assets.forEach(asset => {\n      const fileName = path.join(this.snapshotDir, asset);\n      if (fs.existsSync(fileName)) {\n        if (fs.lstatSync(fileName).isDirectory()) {\n          fs.removeSync(fileName);\n        } else {\n          fs.unlinkSync(fileName);\n        }\n      }\n    });\n  }\n\n  /**\n   * Remove the asset cache (.cache/) files from the snapshot.\n   * These are a cache of the asset zips, but we are fine with\n   * re-zipping on deploy\n   */\n  protected removeAssetsCacheFromSnapshot(): void {\n    const files = fs.readdirSync(this.snapshotDir);\n    files.forEach(file => {\n      const fileName = path.join(this.snapshotDir, file);\n      if (fs.lstatSync(fileName).isDirectory() && file === '.cache') {\n        fs.emptyDirSync(fileName);\n        fs.rmdirSync(fileName);\n      }\n    });\n  }\n\n  /**\n   * Create the new snapshot.\n   *\n   * If lookups are enabled, then we need create the snapshot by synth'ing again\n   * with the dummy context so that each time the test is run on different machines\n   * (and with different context/env) the diff will not change.\n   *\n   * If lookups are disabled (which means the stack is env agnostic) then just copy\n   * the assembly that was output by the deployment\n   */\n  protected async createSnapshot(): Promise<void> {\n    if (fs.existsSync(this.snapshotDir)) {\n      fs.removeSync(this.snapshotDir);\n    }\n\n    const actualTestSuite = await this.actualTestSuite();\n\n    // if lookups are enabled then we need to synth again\n    // using dummy context and save that as the snapshot\n    await this.cdk.synth({\n      app: this.cdkApp,\n      context: this.getContext(actualTestSuite.enableLookups ? DEFAULT_SYNTH_OPTIONS.context : {}),\n      env: DEFAULT_SYNTH_OPTIONS.env,\n      output: path.relative(this.directory, this.snapshotDir),\n    });\n\n    await this.cleanupSnapshot();\n  }\n\n  /**\n   * Perform some cleanup steps after the snapshot is created\n   * Anytime the snapshot needs to be modified after creation\n   * the logic should live here.\n   */\n  private async cleanupSnapshot(): Promise<void> {\n    if (fs.existsSync(this.snapshotDir)) {\n      await this.removeAssetsFromSnapshot();\n      this.removeAssetsCacheFromSnapshot();\n      const assembly = AssemblyManifestReader.fromPath(this.snapshotDir);\n      assembly.cleanManifest();\n      assembly.recordTrace(this.renderTraceData());\n    }\n\n    // if this is a legacy test then create an integ manifest\n    // in the snapshot directory which can be used for the\n    // update workflow. Save any legacyContext as well so that it can be read\n    // the next time\n    const actualTestSuite = await this.actualTestSuite();\n    if (actualTestSuite.type === 'legacy-test-suite') {\n      (actualTestSuite as LegacyIntegTestSuite).saveManifest(this.snapshotDir, this.legacyContext);\n    }\n  }\n\n  protected getContext(additionalContext?: Record<string, any>): Record<string, any> {\n    return {\n      ...currentlyRecommendedAwsCdkLibFlags(),\n      ...this.legacyContext,\n      ...additionalContext,\n\n      // We originally had PLANNED to set this to ['aws', 'aws-cn'], but due to a programming mistake\n      // it was set to everything. In this PR, set it to everything to not mess up all the snapshots.\n      ['@aws-cdk/core:target-partitions']: undefined,\n\n      /* ---------------- THE FUTURE LIVES BELOW----------------------------\n      // Restricting to these target partitions makes most service principals synthesize to\n      // `service.${URL_SUFFIX}`, which is technically *incorrect* (it's only `amazonaws.com`\n      // or `amazonaws.com.cn`, never UrlSuffix for any of the restricted regions) but it's what\n      // most existing integ tests contain, and we want to disturb as few as possible.\n      // [TARGET_PARTITIONS]: ['aws', 'aws-cn'],\n      /* ---------------- END OF THE FUTURE ------------------------------- */\n    };\n  }\n}\n\n// Default context we run all integ tests with, so they don't depend on the\n// account of the exercising user.\nexport const DEFAULT_SYNTH_OPTIONS = {\n  context: {\n    [AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY]: ['test-region-1a', 'test-region-1b', 'test-region-1c'],\n    'availability-zones:account=12345678:region=test-region': ['test-region-1a', 'test-region-1b', 'test-region-1c'],\n    'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234',\n    'ssm:account=12345678:parameterName=/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2:region=test-region': 'ami-1234',\n    'ssm:account=12345678:parameterName=/aws/service/ecs/optimized-ami/amazon-linux/recommended:region=test-region': '{\"image_id\": \"ami-1234\"}',\n    // eslint-disable-next-line @stylistic/max-len\n    'ami:account=12345678:filters.image-type.0=machine:filters.name.0=amzn-ami-vpc-nat-*:filters.state.0=available:owners.0=amazon:region=test-region': 'ami-1234',\n    'vpc-provider:account=12345678:filter.isDefault=true:region=test-region:returnAsymmetricSubnets=true': {\n      vpcId: 'vpc-60900905',\n      subnetGroups: [\n        {\n          type: 'Public',\n          name: 'Public',\n          subnets: [\n            {\n              subnetId: 'subnet-e19455ca',\n              availabilityZone: 'us-east-1a',\n              routeTableId: 'rtb-e19455ca',\n            },\n            {\n              subnetId: 'subnet-e0c24797',\n              availabilityZone: 'us-east-1b',\n              routeTableId: 'rtb-e0c24797',\n            },\n            {\n              subnetId: 'subnet-ccd77395',\n              availabilityZone: 'us-east-1c',\n              routeTableId: 'rtb-ccd77395',\n            },\n          ],\n        },\n      ],\n    },\n  },\n  env: {\n    CDK_INTEG_ACCOUNT: '12345678',\n    CDK_INTEG_REGION: 'test-region',\n    CDK_INTEG_HOSTED_ZONE_ID: 'Z23ABC4XYZL05B',\n    CDK_INTEG_HOSTED_ZONE_NAME: 'example.com',\n    CDK_INTEG_DOMAIN_NAME: '*.example.com',\n    CDK_INTEG_CERT_ARN: 'arn:aws:acm:test-region:12345678:certificate/86468209-a272-595d-b831-0efb6421265z',\n    CDK_INTEG_SUBNET_ID: 'subnet-0dff1a399d8f6f92c',\n  },\n};\n\n/**\n * Return the currently recommended flags for `aws-cdk-lib`.\n *\n * These have been built into the CLI at build time. If this ever gets changed\n * back to a dynamic load, remember that this source file may be bundled into\n * a JavaScript bundle, and `__dirname` might not point where you think it does.\n */\nexport function currentlyRecommendedAwsCdkLibFlags() {\n  return recommendedFlagsFile;\n}\n"]} |
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is not supported yet
New alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
URL strings
Supply chain riskPackage contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.
Fixed alerts
URL strings
Supply chain riskPackage contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.
Improved metrics
- Lines of code
17211
0.94%Worsened metrics
- Total package byte prevSize
20360138
-6.89%- Number of medium supply chain risk alerts
5
25%Dependency changes
+ Added
aws-cdk@2.1128.1(transitive)- Removed
aws-cdk@2.1128.0(transitive)Updated
aws-cdk@2.1128.1