fix(pipelines): changing synth action doesn't restart pipeline

packages/@aws-cdk/assert/lib/assertions/have-resource-matchers.ts

@@ -281,6 +281,90 @@ export function notMatching(matcher: any): PropertyMatcher {
   });
 }
 
+export type TypeValidator<T> = (x: any) => x is T;
+
+/**
+ * Captures a value onto an object if it matches a given inner matcher
+ *
+ * @example
+ *
+ * const someValue = Capture.aString();
+ * expect(stack).toHaveResource({
+ *    // ...
+ *    Value: someValue.capture(stringMatching('*a*')),
+ * });
+ * console.log(someValue.capturedValue);
+ */
+export class Capture<T=any> {
+  /**
+   * A Capture object that captures any type
+   */
+  public static anyType(): Capture<any> {
+    return new Capture();
+  }
+
+  /**
+   * A Capture object that captures a custom type
+   */
+  public static aString(): Capture<string> {
+    return new Capture((x: any): x is string => {
+      if (typeof x !== 'string') {
+        throw new Error(`Expected to capture a string, got '${x}'`);
+      }
+      return true;
+    });
+  }
+
+  /**
+   * A Capture object that captures a custom type
+   */
+  public static a<T>(validator: TypeValidator<T>): Capture<T> {
+    return new Capture(validator);
+  }
+
+  private _value?: T;
+  private _didCapture = false;
+  private _wasInvoked = false;
+
+  protected constructor(private readonly typeValidator?: TypeValidator<T>) {
+  }
+
+  /**
+   * Capture the value if the inner matcher successfully matches it
+   *
+   * If no matcher is given, `anything()` is assumed.
+   */
+  public capture(matcher?: any): PropertyMatcher {
+    if (matcher === undefined) {
+      matcher = anything();
+    }
+
+    return annotateMatcher({ $capture: matcher }, (value: any, failure: InspectionFailure) => {
+      this._wasInvoked = true;
+      const result = matcherFrom(matcher)(value, failure);
+      if (result) {
+        if (this.typeValidator && !this.typeValidator(value)) {
+          throw new Error(`Value not of the expected type: ${value}`);
+        }
+        this._didCapture = true;
+        this._value = value;
+      }
+      return result;
+    });
+  }
+
+  public get didCapture() {
+    return this._didCapture;
+  }
+
+  public get capturedValue(): T {
+    if (!this.didCapture) {
+      throw new Error(`Did not capture a value: ${this._wasInvoked ? 'inner matcher failed' : 'never invoked'}`);
+    }
+    return this._value!;
+  }
+}
+
 /**
  * Match on the innards of a JSON string, instead of the complete string
  */

packages/@aws-cdk/assert/test/have-resource.test.ts

@@ -2,7 +2,7 @@ import { writeFileSync } from 'fs';
 import { join } from 'path';
 import * as cxschema from '@aws-cdk/cloud-assembly-schema';
 import * as cxapi from '@aws-cdk/cx-api';
-import { ABSENT, arrayWith, exactValue, expect as cdkExpect, haveResource, haveResourceLike } from '../lib/index';
+import { ABSENT, arrayWith, exactValue, expect as cdkExpect, haveResource, haveResourceLike, Capture, anything } from '../lib/index';
 
 test('support resource with no properties', () => {
   const synthStack = mkStack({
@@ -238,6 +238,19 @@ describe('property absence', () => {
       }));
     }).not.toThrowError();
   });
+
+  test('test capturing', () => {
+    const synthStack = mkSomeResource({
+      Prop: 'somevalue',
+    });
+
+    const propValue = Capture.aString();
+    cdkExpect(synthStack).to(haveResourceLike('Some::Resource', {
+      Prop: propValue.capture(anything()),
+    }));
+
+    expect(propValue.capturedValue).toEqual('somevalue');
+  });
 });
 
 function mkStack(template: any): cxapi.CloudFormationStackArtifact {

packages/@aws-cdk/pipelines/lib/synths/simple-synth-action.ts

@@ -1,3 +1,4 @@
+import * as crypto from 'crypto';
 import * as path from 'path';
 import * as codebuild from '@aws-cdk/aws-codebuild';
 import * as codepipeline from '@aws-cdk/aws-codepipeline';
@@ -262,32 +263,47 @@ export class SimpleSynthAction implements codepipeline.IAction {
     const testCommands = this.props.testCommands ?? [];
     const synthCommand = this.props.synthCommand;
 
-    const project = new codebuild.PipelineProject(scope, 'CdkBuildProject', {
-      projectName: this.props.projectName ?? this.props.projectName,
-      environment: { buildImage: codebuild.LinuxBuildImage.STANDARD_4_0, ...this.props.environment },
-      buildSpec: codebuild.BuildSpec.fromObject({
-        version: '0.2',
-        phases: {
-          pre_build: {
-            commands: filterEmpty([
-              this.props.subdirectory ? `cd ${this.props.subdirectory}` : '',
-              ...installCommands,
-            ]),
-          },
-          build: {
-            commands: filterEmpty([
-              ...buildCommands,
-              ...testCommands,
-              synthCommand,
-            ]),
-          },
+    const buildSpec = codebuild.BuildSpec.fromObject({
+      version: '0.2',
+      phases: {
+        pre_build: {
+          commands: filterEmpty([
+            this.props.subdirectory ? `cd ${this.props.subdirectory}` : '',
+            ...installCommands,
+          ]),
+        },
+        build: {
+          commands: filterEmpty([
+            ...buildCommands,
+            ...testCommands,
+            synthCommand,
+          ]),
         },
-        artifacts: renderArtifacts(this),
-      }),
-      environmentVariables: {
-        ...copyEnvironmentVariables(...this.props.copyEnvironmentVariables || []),
-        ...this.props.environmentVariables,
       },
+      artifacts: renderArtifacts(this),
+    });
+
+    const environment = { buildImage: codebuild.LinuxBuildImage.STANDARD_4_0, ...this.props.environment };
+
+    const environmentVariables = {
+      ...copyEnvironmentVariables(...this.props.copyEnvironmentVariables || []),
+      ...this.props.environmentVariables,
+    };
+
+    // A hash over the values that make the CodeBuild Project unique (and necessary
+    // to restart the pipeline if one of them changes). projectName is not necessary to include
+    // here because the pipeline will definitely restart if projectName changes.
+    const projectConfigHash = hash({
+      environment,
+      buildSpecString: buildSpec.toBuildSpec(),
+      environmentVariables,
+    });
+
+    const project = new codebuild.PipelineProject(scope, 'CdkBuildProject', {
+      projectName: this.props.projectName ?? this.props.projectName,
+      environment,
+      buildSpec,
+      environmentVariables,
     });
 
     if (this.props.rolePolicyStatements !== undefined) {
@@ -300,6 +316,13 @@ export class SimpleSynthAction implements codepipeline.IAction {
       actionName: this.actionProperties.actionName,
       input: this.props.sourceArtifact,
       outputs: [this.props.cloudAssemblyArtifact, ...(this.props.additionalArtifacts ?? []).map(a => a.artifact)],
+
+      // Inclusion of the hash here will lead to the pipeline structure changing if the
+      // buildspec changes, and hence the pipeline being restarted. This is necessary if
+      // the users adds (for example) build or test commands to the buildspec.
+      environmentVariables: {
+        _PROJECT_CONFIG_HASH: { value: projectConfigHash },
+      },
       project,
     });
     this._actionProperties = this._action.actionProperties;
@@ -411,4 +434,10 @@ export interface StandardYarnSynthOptions extends SimpleSynthOptions {
    * @default 'npx cdk synth'
    */
   readonly synthCommand?: string;
+}
+
+function hash<A>(obj: A) {
+  const d = crypto.createHash('sha256');
+  d.update(JSON.stringify(obj));
+  return d.digest('hex');
 }

packages/@aws-cdk/pipelines/test/builds.test.ts

@@ -1,5 +1,6 @@
-import { arrayWith, deepObjectLike, encodedJson } from '@aws-cdk/assert';
+import { arrayWith, deepObjectLike, encodedJson, objectLike, Capture } from '@aws-cdk/assert';
 import '@aws-cdk/assert/jest';
+import * as cbuild from '@aws-cdk/aws-codebuild';
 import * as codepipeline from '@aws-cdk/aws-codepipeline';
 import { Stack } from '@aws-cdk/core';
 import * as cdkp from '../lib';
@@ -219,6 +220,75 @@ test('Standard (NPM) synth can output additional artifacts', () => {
   });
 });
 
+test('Pipeline action contains a hash that changes as the buildspec changes', () => {
+  const hash1 = synthWithAction((sa, cxa) => cdkp.SimpleSynthAction.standardNpmSynth({
+    sourceArtifact: sa,
+    cloudAssemblyArtifact: cxa,
+  }));
+  const hash2 = synthWithAction((sa, cxa) => cdkp.SimpleSynthAction.standardNpmSynth({
+    sourceArtifact: sa,
+    cloudAssemblyArtifact: cxa,
+    installCommand: 'do install',
+  }));
+  const hash3 = synthWithAction((sa, cxa) => cdkp.SimpleSynthAction.standardNpmSynth({
+    sourceArtifact: sa,
+    cloudAssemblyArtifact: cxa,
+    environment: {
+      computeType: cbuild.ComputeType.LARGE,
+    },
+  }));
+  const hash4 = synthWithAction((sa, cxa) => cdkp.SimpleSynthAction.standardNpmSynth({
+    sourceArtifact: sa,
+    cloudAssemblyArtifact: cxa,
+    environmentVariables: {
+      xyz: { value: 'SOME-VALUE' },
+    },
+  }));
+
+  expect(hash1).not.toEqual(hash2);
+  expect(hash1).not.toEqual(hash3);
+  expect(hash1).not.toEqual(hash4);
+  expect(hash2).not.toEqual(hash3);
+  expect(hash2).not.toEqual(hash4);
+  expect(hash3).not.toEqual(hash4);
+
+  function synthWithAction(cb: (sourceArtifact: codepipeline.Artifact, cloudAssemblyArtifact: codepipeline.Artifact) => codepipeline.IAction) {
+    const _app = new TestApp({ outdir: 'testcdk.out' });
+    const _pipelineStack = new Stack(_app, 'PipelineStack', { env: PIPELINE_ENV });
+    const _sourceArtifact = new codepipeline.Artifact();
+    const _cloudAssemblyArtifact = new codepipeline.Artifact('CloudAsm');
+
+    new TestGitHubNpmPipeline(_pipelineStack, 'Cdk', {
+      sourceArtifact: _sourceArtifact,
+      cloudAssemblyArtifact: _cloudAssemblyArtifact,
+      synthAction: cb(_sourceArtifact, _cloudAssemblyArtifact),
+    });
+
+    const theHash = Capture.aString();
+    expect(_pipelineStack).toHaveResourceLike('AWS::CodePipeline::Pipeline', {
+      Stages: arrayWith({
+        Name: 'Build',
+        Actions: [
+          objectLike({
+            Name: 'Synth',
+            Configuration: objectLike({
+              EnvironmentVariables: encodedJson([
+                {
+                  name: '_PROJECT_CONFIG_HASH',
+                  type: 'PLAINTEXT',
+                  value: theHash.capture(),
+                },
+              ]),
+            }),
+          }),
+        ],
+      }),
+    });
+
+    return theHash.capturedValue;
+  }
+});
+
 function npmYarnBuild(npmYarn: string) {
   if (npmYarn === 'npm') { return cdkp.SimpleSynthAction.standardNpmSynth; }
   if (npmYarn === 'yarn') { return cdkp.SimpleSynthAction.standardYarnSynth; }