sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ AWS/ KinesisAnalyticsV2/ ApplicationCloudWatchLoggingOption.test.ts

import * as AWS from "@alchemy.run/aws";
import {
  Application,
  ApplicationCloudWatchLoggingOption,
} from "@alchemy.run/aws/KinesisAnalyticsV2";
import { describe, expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as analytics from "@distilled.cloud/aws/kinesis-analytics-v2";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
import { codeKey, deleteCodeBucketIdempotent, provisionCodeBucket } from "./code-bucket.ts";

const { test } = Test.make({ providers: AWS.providers() });

// Deterministic out-of-band code bucket (see code-bucket.ts) — an in-stack
// bucket orphans on a crashed run because its generated name is lost with
// the state.
const loggingCodeBucket = "alchemy-test-kav2-logging-code";

class ApplicationStillExists extends Data.TaggedError("ApplicationStillExists") {}

const assertApplicationDeleted = Effect.fn(function* (applicationName: string) {
  yield* analytics.describeApplication({ ApplicationName: applicationName }).pipe(
    Effect.flatMap(() => Effect.fail(new ApplicationStillExists())),
    Effect.retry({
      while: (e: { _tag: string }) => e._tag === "ApplicationStillExists",
      schedule: Schedule.max([Schedule.fixed("3 seconds"), Schedule.recurs(40)]),
    }),
    Effect.catchTag("ResourceNotFoundException", () => Effect.void),
  );
});

describe.skipIf(!!process.env.FAST)(
  "AWS.KinesisAnalyticsV2.ApplicationCloudWatchLoggingOption",
  {
    tags: [
      "provider:aws",
      "provider:aws:kinesisanalyticsv2",
      "provider:aws:logs",
      "provider:aws:s3",
      "live",
    ],
  },
  () => {
    test.provider(
      "attach a CloudWatch logging option, detach it, destroy",
      (stack) =>
        Effect.gen(function* () {
          yield* stack.destroy();

          // Stage the code object BEFORE the application exists — the service
          // reads (and hashes) the object at create/update time.
          const codeBucketArn = yield* provisionCodeBucket(loggingCodeBucket);

          const makeBase = Effect.gen(function* () {
            const logGroup = yield* AWS.Logs.LogGroup("FlinkLogGroup", {});
            const logStream = yield* AWS.Logs.LogStream("FlinkLogStream", {
              logGroupName: logGroup.logGroupName,
            });
            const app = yield* Application("LoggedFlinkApp", {
              runtimeEnvironment: "FLINK-1_20",
              code: { bucketArn: codeBucketArn, fileKey: codeKey },
            });
            return { logGroup, logStream, app };
          });

          const deployed = yield* stack.deploy(
            Effect.gen(function* () {
              const base = yield* makeBase;
              const logging = yield* ApplicationCloudWatchLoggingOption("FlinkLogging", {
                applicationName: base.app.applicationName,
                logStreamArn: base.logStream.logStreamArn.as<string>(),
              });
              return { ...base, logging };
            }),
          );

          expect(deployed.logging.applicationName).toEqual(deployed.app.applicationName);
          expect(deployed.logging.cloudWatchLoggingOptionId).toBeDefined();
          expect(deployed.logging.logStreamArn).toContain(":log-stream:");

          // Out-of-band: the option is visible on the application.
          const described = yield* analytics.describeApplication({
            ApplicationName: deployed.app.applicationName,
          });
          const options = described.ApplicationDetail.CloudWatchLoggingOptionDescriptions ?? [];
          expect(options).toHaveLength(1);
          expect(options[0]?.LogStreamARN).toEqual(deployed.logging.logStreamArn);

          // Remove the option while the application stays deployed — the
          // engine deletes just the sub-resource.
          const detached = yield* stack.deploy(makeBase);
          expect(detached.app.applicationName).toEqual(deployed.app.applicationName);

          const afterDetach = yield* analytics.describeApplication({
            ApplicationName: deployed.app.applicationName,
          });
          expect(
            afterDetach.ApplicationDetail.CloudWatchLoggingOptionDescriptions ?? [],
          ).toHaveLength(0);

          yield* stack.destroy();

          yield* assertApplicationDeleted(deployed.app.applicationName);
        }).pipe(Effect.ensuring(deleteCodeBucketIdempotent(loggingCodeBucket))),
      { timeout: 300_000 },
    );
  },
);