Merge branch 'beta' into beta-v1-launch-prep-part-1

src/__test__/TestableProjectStack.ts

@@ -1,4 +1,5 @@
 import * as cdk from "aws-cdk-lib";
+import { Construct } from "constructs";
 import {
   Project,
   SmartStack,
@@ -14,9 +15,25 @@ interface TestStackInSharedAccountProps {
   accountType: AccountType;
   environmentType?: string;
   stackProps?: cdk.StackProps;
+  appContext?: Record<string, any>;
+}
+
+class TestContextProvider extends Construct {
+  constructor(
+    scope: Construct,
+    id: string,
+    appContext: Record<string, any> = {},
+  ) {
+    super(scope, id);
+
+    Object.entries(appContext).forEach(([key, value]) => {
+      this.node.setContext(key, value);
+    });
+  }
 }
 
 export class TestableProjectStack extends SmartStack {
+  public readonly project: Project;
   public readonly projectName: string;
   public readonly stackConstructId: string;
 
@@ -27,6 +44,7 @@ export class TestableProjectStack extends SmartStack {
       environmentType,
       defaultRegion,
       stackProps,
+      appContext,
     } = props;
 
     const projectName = "test-project";
@@ -41,18 +59,31 @@ export class TestableProjectStack extends SmartStack {
       accounts,
     });
 
-    project.node.setContext("account-type", accountType);
-    project.node.setContext("account", accountType);
+    const ctx: Record<string, any> = {};
+
+    if (typeof environmentType === "string") {
+      ctx["environment-type"] = environmentType;
+      ctx.environment = environmentType;
+      ctx.env = environmentType;
+    }
+
+    const testContextProvider = new TestContextProvider(
+      project,
+      "TestContextProvider",
+      {
+        ...appContext,
+        "account-type": accountType,
+        account: accountType,
+        ...ctx,
+      },
+    );
 
     let wrapper: AccountWrapper | EnvironmentWrapper;
 
-    if (environmentType) {
-      project.node.setContext("environment-type", environmentType);
-      project.node.setContext("environment", environmentType);
-      project.node.setContext("env", environmentType);
-      wrapper = new EnvironmentWrapper(project);
+    if (typeof environmentType === "string") {
+      wrapper = new EnvironmentWrapper(testContextProvider);
     } else {
-      wrapper = new AccountWrapper(project);
+      wrapper = new AccountWrapper(testContextProvider);
     }
 
     const stackConstructId = "TestStack";
@@ -62,6 +93,7 @@ export class TestableProjectStack extends SmartStack {
       ...stackProps,
     });
 
+    this.project = project;
     this.projectName = projectName;
     this.stackConstructId = stackConstructId;
   }

src/project/index.ts

@@ -1,5 +1,5 @@
 export * from "./interfaces";
-export { Project, ProjectProps } from "./project";
+export { Project, ProjectProps, Acknowledgeable } from "./project";
 export { ProjectContext, ProjectContext as PC } from "./project-context";
 export { AccountType } from "./account-type";
 export { EnvironmentType } from "./environment-type";

src/project/project.test.ts

@@ -0,0 +1,50 @@
+import { Annotations } from "aws-cdk-lib";
+import * as assertions from "aws-cdk-lib/assertions";
+import { Construct } from "constructs";
+import { TestableProjectStack } from "../__test__/TestableProjectStack";
+
+describe("Acknowledge warnings", () => {
+  test("warning present if not acknowledged", () => {
+    const stack = new TestableProjectStack({
+      accounts: {
+        shared: {
+          id: "111111111111",
+        },
+      },
+      accountType: "shared",
+    });
+
+    const warningId = "my-test-warning";
+
+    const withWarning = new Construct(stack, "WithWarning");
+    Annotations.of(withWarning).addWarningV2(warningId, "don't do this");
+
+    assertions.Annotations.fromStack(stack).hasWarning(
+      "*",
+      assertions.Match.stringLikeRegexp(warningId),
+    );
+  });
+
+  test("acknowledges warnings", () => {
+    const stack = new TestableProjectStack({
+      accounts: {
+        shared: {
+          id: "111111111111",
+        },
+      },
+      accountType: "shared",
+    });
+
+    const warningId = "my-test-warning";
+
+    const withWarning = new Construct(stack, "WithWarning");
+    Annotations.of(withWarning).addWarningV2(warningId, "don't do this");
+
+    stack.project.acknowledgeWarnings([{ id: warningId, message: "is okay" }]);
+
+    assertions.Annotations.fromStack(stack).hasNoWarning(
+      "*",
+      assertions.Match.stringLikeRegexp(warningId),
+    );
+  });
+});

src/project/project.ts

@@ -1,9 +1,16 @@
-import { App, AppProps } from "aws-cdk-lib";
+import { Annotations, App, AppProps, Stack } from "aws-cdk-lib";
 import { Construct } from "constructs";
 import { Account, ProjectConfiguration } from "./interfaces";
 import { resolveDefaultRegion } from "./resolve-region";
 import { addError } from "../error";
-import { warnAboutDeprecatedTags } from "./deprecation-warnings";
+
+/**
+ * Interface for acknowledging warnings.
+ */
+export interface Acknowledgeable {
+  readonly id: string;
+  readonly message?: string;
+}
 
 /** Props given to `Project`.
  *
@@ -96,7 +103,19 @@ export class Project extends App {
         [Project.CONTEXT_SCOPE]: config, // and inject project context
       },
     });
+  }
 
-    warnAboutDeprecatedTags(this);
+  /**
+   * Acknowledge warnings for all stacks in the project.
+   */
+  public acknowledgeWarnings(acknowledgements: Acknowledgeable[]) {
+    const stacks = this.node
+      .findAll()
+      .filter((x): x is Stack => x instanceof Stack);
+    stacks.map((stack) => {
+      acknowledgements.map((ack) => {
+        Annotations.of(stack).acknowledgeWarning(ack.id, ack.message);
+      });
+    });
   }
 }

src/smartstack/stack.test.ts

@@ -4,6 +4,7 @@ import { TestableProjectStack } from "../__test__/TestableProjectStack";
 import { AccountStrategy } from "../configurations";
 import { SmartStack } from "./stack";
 import { AccountType } from "../configurations/accounts";
+import { LEGACY_TAGS_CONTEXT_KEY, V0_TAGS_CONTEXT_KEY } from "../feature-flags";
 
 test("TestableProjectStack is instance of SmartStack", () => {
   const stack = new TestableProjectStack({
@@ -162,3 +163,44 @@ describe("env", () => {
     expect(stack.region).toEqual("eu-central-1");
   });
 });
+
+describe("deprecation warnings", () => {
+  test("warns about legacy tags", () => {
+    const stack = new TestableProjectStack({
+      accounts: AccountStrategy.one({
+        shared: { id: "111111111111" },
+      }),
+      accountType: AccountType.SHARED,
+      appContext: {
+        [LEGACY_TAGS_CONTEXT_KEY]: true,
+      },
+    });
+
+    expectErrorMetadata(
+      stack,
+      expect.stringContaining("@alma-cdk/project@v1:legacy-tags"),
+    );
+  });
+
+  test("warns about compatibility v0 tags", () => {
+    const stack = new TestableProjectStack({
+      accounts: AccountStrategy.one({ shared: { id: "111111111111" } }),
+      accountType: AccountType.SHARED,
+      appContext: { [V0_TAGS_CONTEXT_KEY]: true },
+    });
+
+    expectErrorMetadata(
+      stack,
+      expect.stringContaining("@alma-cdk/project@v1:compatibility-v0-tags"),
+    );
+  });
+
+  test("does not warn if no legacy or compatibility v0 tags", () => {
+    const stack = new TestableProjectStack({
+      accounts: AccountStrategy.one({ shared: { id: "111111111111" } }),
+      accountType: AccountType.SHARED,
+    });
+
+    expectErrorMetadata(stack, undefined);
+  });
+});