sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ AWS/ CloudFront/ MergeObservedConfig.test.ts

import { mergeWithObservedConfig } from "@alchemy.run/aws/CloudFront/Distribution";
import { describe, expect, test } from "@alchemy.run/test";
import type * as cloudfront from "@distilled.cloud/aws/cloudfront";

/**
 * A live distribution config as returned by `GetDistributionConfig` for a
 * distribution CloudFront has normalized — every member present, including
 * the ones `DistributionProps` cannot express (per-origin `CustomHeaders`,
 * per-behavior `TrustedSigners`, `GrpcConfig`, …). `UpdateDistribution`
 * rejects requests missing any of these with `IllegalUpdate`.
 */
const observed: cloudfront.DistributionConfig = {
  CallerReference: "caller-ref",
  Aliases: { Quantity: 0 },
  DefaultRootObject: "",
  Origins: {
    Quantity: 1,
    Items: [
      {
        Id: "s3",
        DomainName: "bucket.s3.us-east-1.amazonaws.com",
        OriginPath: "",
        CustomHeaders: { Quantity: 0 },
        S3OriginConfig: { OriginAccessIdentity: "", OriginReadTimeout: 30 },
        ConnectionAttempts: 3,
        ConnectionTimeout: 10,
        OriginShield: { Enabled: false },
        OriginAccessControlId: "OAC_OBSERVED",
      },
    ],
  },
  OriginGroups: { Quantity: 0 },
  DefaultCacheBehavior: {
    TargetOriginId: "s3",
    TrustedSigners: { Enabled: false, Quantity: 0 },
    TrustedKeyGroups: { Enabled: false, Quantity: 0 },
    ViewerProtocolPolicy: "redirect-to-https",
    AllowedMethods: {
      Quantity: 2,
      Items: ["HEAD", "GET"],
      CachedMethods: { Quantity: 2, Items: ["HEAD", "GET"] },
    },
    SmoothStreaming: false,
    Compress: true,
    LambdaFunctionAssociations: { Quantity: 0 },
    FunctionAssociations: { Quantity: 0 },
    FieldLevelEncryptionId: "",
    CachePolicyId: "cache-policy-id",
    GrpcConfig: { Enabled: false },
  },
  CacheBehaviors: {
    Quantity: 1,
    Items: [
      {
        PathPattern: "*.webp",
        TargetOriginId: "s3",
        TrustedSigners: { Enabled: false, Quantity: 0 },
        TrustedKeyGroups: { Enabled: false, Quantity: 0 },
        ViewerProtocolPolicy: "redirect-to-https",
        AllowedMethods: {
          Quantity: 2,
          Items: ["HEAD", "GET"],
          CachedMethods: { Quantity: 2, Items: ["HEAD", "GET"] },
        },
        SmoothStreaming: false,
        Compress: true,
        LambdaFunctionAssociations: { Quantity: 0 },
        FunctionAssociations: { Quantity: 0 },
        FieldLevelEncryptionId: "",
        CachePolicyId: "cache-policy-id",
        GrpcConfig: { Enabled: false },
      },
    ],
  },
  CustomErrorResponses: { Quantity: 0 },
  Comment: "",
  Logging: { Enabled: false, IncludeCookies: false, Bucket: "", Prefix: "" },
  PriceClass: "PriceClass_100",
  Enabled: true,
  ViewerCertificate: {
    CloudFrontDefaultCertificate: true,
    SSLSupportMethod: "vip",
    MinimumProtocolVersion: "TLSv1",
  },
  Restrictions: { GeoRestriction: { RestrictionType: "none", Quantity: 0 } },
  WebACLId: "",
  HttpVersion: "http2",
  IsIPV6Enabled: false,
  ContinuousDeploymentPolicyId: "",
  Staging: false,
};

/**
 * The sparse config `toConfig` builds from props — only what the props
 * express, everything else `undefined` (i.e. omitted from the request).
 */
const desired: cloudfront.DistributionConfig = {
  CallerReference: "caller-ref",
  Aliases: { Quantity: 0, Items: [] },
  Origins: {
    Quantity: 1,
    Items: [
      {
        Id: "s3",
        DomainName: "bucket.s3.us-east-1.amazonaws.com",
        OriginAccessControlId: "OAC_DESIRED",
        S3OriginConfig: { OriginAccessIdentity: "" },
      },
    ],
  },
  DefaultCacheBehavior: {
    TargetOriginId: "s3",
    ViewerProtocolPolicy: "redirect-to-https",
    AllowedMethods: {
      Quantity: 2,
      Items: ["GET", "HEAD"],
      CachedMethods: { Quantity: 2, Items: ["GET", "HEAD"] },
    },
    Compress: true,
    CachePolicyId: "cache-policy-id",
    FunctionAssociations: {
      Quantity: 1,
      Items: [
        { FunctionARN: "arn:aws:cloudfront::123:function/deny-all", EventType: "viewer-request" },
      ],
    },
  },
  CacheBehaviors: {
    Quantity: 1,
    Items: [
      {
        PathPattern: "*.webp",
        TargetOriginId: "s3",
        ViewerProtocolPolicy: "redirect-to-https",
        AllowedMethods: {
          Quantity: 2,
          Items: ["GET", "HEAD"],
          CachedMethods: { Quantity: 2, Items: ["GET", "HEAD"] },
        },
        Compress: true,
        CachePolicyId: "cache-policy-id",
      },
    ],
  },
  Comment: "",
  Enabled: false,
  Restrictions: { GeoRestriction: { RestrictionType: "none", Quantity: 0 } },
  IsIPV6Enabled: true,
} as cloudfront.DistributionConfig;

describe(
  "mergeWithObservedConfig",
  { tags: ["unit", "provider:aws", "provider:aws:cloudfront", "local"] },
  () => {
    const merged = mergeWithObservedConfig(desired, observed);

    test("desired values win over observed ones", () => {
      expect(merged.Enabled).toBe(false);
      expect(merged.IsIPV6Enabled).toBe(true);
      expect(merged.Origins?.Items?.[0]?.OriginAccessControlId).toBe("OAC_DESIRED");
      expect(merged.DefaultCacheBehavior?.FunctionAssociations?.Quantity).toBe(1);
    });

    test("top-level members the desired config omits are filled from observed", () => {
      expect(merged.DefaultRootObject).toBe("");
      expect(merged.WebACLId).toBe("");
      expect(merged.ContinuousDeploymentPolicyId).toBe("");
      expect(merged.Staging).toBe(false);
      expect(merged.PriceClass).toBe("PriceClass_100");
      expect(merged.Logging).toEqual(observed.Logging);
      expect(merged.OriginGroups).toEqual({ Quantity: 0 });
      expect(merged.CustomErrorResponses).toEqual({ Quantity: 0 });
    });

    test("nested members inside origin items are filled by Id", () => {
      const origin = merged.Origins?.Items?.[0];
      expect(origin?.CustomHeaders).toEqual({ Quantity: 0 });
      expect(origin?.OriginPath).toBe("");
      expect(origin?.ConnectionAttempts).toBe(3);
      expect(origin?.ConnectionTimeout).toBe(10);
      expect(origin?.OriginShield).toEqual({ Enabled: false });
      expect(origin?.S3OriginConfig?.OriginReadTimeout).toBe(30);
    });

    test("nested members inside behaviors are filled (default + by PathPattern)", () => {
      for (const behavior of [merged.DefaultCacheBehavior, merged.CacheBehaviors?.Items?.[0]]) {
        expect(behavior?.TrustedSigners).toEqual({ Enabled: false, Quantity: 0 });
        expect(behavior?.TrustedKeyGroups).toEqual({ Enabled: false, Quantity: 0 });
        expect(behavior?.SmoothStreaming).toBe(false);
        expect(behavior?.FieldLevelEncryptionId).toBe("");
        expect(behavior?.GrpcConfig).toEqual({ Enabled: false });
        expect(behavior?.LambdaFunctionAssociations).toEqual({ Quantity: 0 });
      }
    });

    test("partial nested objects are completed member-wise, not replaced", () => {
      // Desired sets CloudFrontDefaultCertificate only; the observed
      // SSLSupportMethod / MinimumProtocolVersion carry over.
      const mergedWithCert = mergeWithObservedConfig(
        { ...desired, ViewerCertificate: { CloudFrontDefaultCertificate: true } },
        observed,
      );
      expect(mergedWithCert.ViewerCertificate).toEqual({
        CloudFrontDefaultCertificate: true,
        SSLSupportMethod: "vip",
        MinimumProtocolVersion: "TLSv1",
      });
    });

    test("desired arrays are never extended by observed items", () => {
      // Observed has one origin; a desired config that removes it must win.
      const withoutOrigins = mergeWithObservedConfig(
        { ...desired, Origins: { Quantity: 0, Items: [] } },
        observed,
      );
      expect(withoutOrigins.Origins).toEqual({ Quantity: 0, Items: [] });
    });

    test("a Quantity-only desired list never resurrects observed Items", () => {
      // Dropping a geo whitelist produces `{ RestrictionType: "none",
      // Quantity: 0 }` with no `Items`; filling `Items` from the observed
      // whitelist would desynchronize Quantity/Items and CloudFront rejects
      // the update with `InconsistentQuantities`.
      const withWhitelist = {
        ...observed,
        Restrictions: {
          GeoRestriction: { RestrictionType: "whitelist", Quantity: 2, Items: ["US", "GB"] },
        },
      } as cloudfront.DistributionConfig;
      const dropped = mergeWithObservedConfig(
        {
          ...desired,
          Restrictions: { GeoRestriction: { RestrictionType: "none", Quantity: 0 } },
        } as cloudfront.DistributionConfig,
        withWhitelist,
      );
      expect(dropped.Restrictions).toEqual({
        GeoRestriction: { RestrictionType: "none", Quantity: 0 },
      });
    });

    test("an origin absent from observed is passed through unchanged", () => {
      const withNewOrigin = mergeWithObservedConfig(
        {
          ...desired,
          Origins: {
            Quantity: 1,
            Items: [{ Id: "brand-new", DomainName: "new.example.com" } as cloudfront.Origin],
          },
        },
        observed,
      );
      expect(withNewOrigin.Origins?.Items?.[0]).toEqual({
        Id: "brand-new",
        DomainName: "new.example.com",
      });
    });

    // A site switching between a server and S3 keeps the origin id but
    // changes its kind. The old kind's config and OAC must not carry over
    // (CloudFront rejects both kinds at once); shared members still fill.
    test("an origin that changes kind keeps only the members both kinds share", () => {
      const custom = mergeWithObservedConfig(
        {
          ...desired,
          Origins: {
            Quantity: 1,
            Items: [
              {
                Id: "s3",
                DomainName: "server.example.com",
                CustomOriginConfig: {
                  HTTPPort: 80,
                  HTTPSPort: 443,
                  OriginProtocolPolicy: "https-only",
                },
              } as cloudfront.Origin,
            ],
          },
        },
        observed,
      ).Origins?.Items?.[0];
      expect(custom?.S3OriginConfig).toBeUndefined();
      expect(custom?.OriginAccessControlId).toBeUndefined();
      expect(custom?.CustomOriginConfig?.OriginProtocolPolicy).toBe("https-only");
      expect(custom?.CustomHeaders).toEqual({ Quantity: 0 });
      expect(custom?.ConnectionAttempts).toBe(3);
    });
  },
);