Merge pull request #698 from sid88in/chore/improve-test-coverage

sid88in · web-flow · commit 72364dba662b · 2026-05-22T15:20:52.000-07:00
test: improve coverage for utils, SyncConfig, and Waf
diff --git a/src/__tests__/syncConfig.test.ts b/src/__tests__/syncConfig.test.ts
@@ -0,0 +1,111 @@
+import { Api } from '../resources/Api';
+import { SyncConfig } from '../resources/SyncConfig';
+import { ResolverConfig } from '../types/plugin';
+import * as given from './given';
+
+const plugin = given.plugin();
+
+describe('SyncConfig', () => {
+  const baseResolver: ResolverConfig = {
+    dataSource: 'myDataSource',
+    kind: 'UNIT',
+    type: 'Query',
+    field: 'getThing',
+  };
+
+  it('returns undefined when no sync config is present', () => {
+    const api = new Api(given.appSyncConfig(), plugin);
+    const sync = new SyncConfig(api, baseResolver);
+
+    expect(sync.compile()).toBeUndefined();
+  });
+
+  it('emits VERSION + OPTIMISTIC_CONCURRENCY by default when sync is enabled', () => {
+    const api = new Api(given.appSyncConfig(), plugin);
+    // Pass an empty sync object — runtime defaults both conflictDetection and
+    // conflictHandler. Casting through `unknown` because the public types
+    // require both fields, but the runtime defensively defaults them.
+    const sync = new SyncConfig(api, {
+      ...baseResolver,
+      sync: {} as unknown as ResolverConfig['sync'],
+    });
+
+    expect(sync.compile()).toEqual({
+      ConflictDetection: 'VERSION',
+      ConflictHandler: 'OPTIMISTIC_CONCURRENCY',
+    });
+  });
+
+  it('honors an explicit conflictHandler value', () => {
+    const api = new Api(given.appSyncConfig(), plugin);
+    const sync = new SyncConfig(api, {
+      ...baseResolver,
+      sync: {
+        conflictDetection: 'VERSION',
+        conflictHandler: 'AUTOMERGE',
+      } as unknown as ResolverConfig['sync'],
+    });
+
+    expect(sync.compile()).toEqual({
+      ConflictDetection: 'VERSION',
+      ConflictHandler: 'AUTOMERGE',
+    });
+  });
+
+  it('emits only ConflictDetection when set to NONE (no handler)', () => {
+    const api = new Api(given.appSyncConfig(), plugin);
+    const sync = new SyncConfig(api, {
+      ...baseResolver,
+      sync: {
+        conflictDetection: 'NONE',
+      } as unknown as ResolverConfig['sync'],
+    });
+
+    expect(sync.compile()).toEqual({
+      ConflictDetection: 'NONE',
+    });
+  });
+
+  it('emits LambdaConflictHandlerConfig when conflictHandler is LAMBDA with a function ref', () => {
+    const api = new Api(given.appSyncConfig(), plugin);
+    const sync = new SyncConfig(api, {
+      ...baseResolver,
+      sync: {
+        conflictDetection: 'VERSION',
+        conflictHandler: 'LAMBDA',
+        functionArn: 'arn:aws:lambda:us-east-1:123:function:resolver',
+      } as unknown as ResolverConfig['sync'],
+    });
+
+    const result = sync.compile();
+    expect(result).toMatchObject({
+      ConflictDetection: 'VERSION',
+      ConflictHandler: 'LAMBDA',
+      LambdaConflictHandlerConfig: {
+        LambdaConflictHandlerArn:
+          'arn:aws:lambda:us-east-1:123:function:resolver',
+      },
+    });
+  });
+
+  it('emits LambdaConflictHandlerConfig when conflictHandler is LAMBDA with an inline function definition', () => {
+    const api = new Api(given.appSyncConfig(), plugin);
+    const sync = new SyncConfig(api, {
+      ...baseResolver,
+      sync: {
+        conflictDetection: 'VERSION',
+        conflictHandler: 'LAMBDA',
+        function: {
+          handler: 'index.handler',
+        },
+      },
+    });
+
+    // The exact ARN structure depends on the embedded-function naming, but the
+    // outer envelope shape is what matters here.
+    const result = sync.compile() as { [key: string]: unknown };
+    expect(result.ConflictDetection).toBe('VERSION');
+    expect(result.ConflictHandler).toBe('LAMBDA');
+    expect(result.LambdaConflictHandlerConfig).toBeDefined();
+  });
+});
diff --git a/src/__tests__/utils.test.ts b/src/__tests__/utils.test.ts
@@ -3,6 +3,8 @@ import {
   getWildCardDomainName,
   parseDateTimeOrDuration,
   parseDuration,
+  toCfnKeys,
+  wait,
 } from '../utils';
 
 beforeAll(() => {
@@ -27,6 +29,46 @@ describe('parseDuration', () => {
   it('should auto-fix 1y durations to 365 days', () => {
     expect(parseDuration('1y').toString()).toEqual('P365D');
   });
+
+  it('should accept a number and treat it as hours', () => {
+    expect(parseDuration(24).toString()).toEqual('PT24H');
+    expect(parseDuration(1).toString()).toEqual('PT1H');
+  });
+
+  it('should default to hours when no unit is provided', () => {
+    expect(parseDuration('48').toString()).toEqual('PT48H');
+  });
+
+  it.each([
+    ['5m', 'PT5M'],
+    ['10h', 'PT10H'],
+    ['7d', 'P7D'],
+    ['2w', 'P2W'],
+    ['3M', 'P3M'],
+    // luxon normalizes quarters into months: 1q → P3M
+    ['1q', 'P3M'],
+    ['1s', 'PT1S'],
+    ['500ms', 'PT0.5S'],
+  ])('should parse "%s" as ISO duration %s', (input, expected) => {
+    expect(parseDuration(input).toString()).toEqual(expected);
+  });
+
+  it('should throw on a non-string non-number input', () => {
+    // @ts-expect-error — intentionally passing wrong type to exercise guard
+    expect(() => parseDuration(null)).toThrow(
+      'Could not parse null as a valid duration',
+    );
+    // @ts-expect-error — intentionally passing wrong type to exercise guard
+    expect(() => parseDuration(undefined)).toThrow(
+      'Could not parse undefined as a valid duration',
+    );
+  });
+
+  it('should throw a descriptive error message on unparseable strings', () => {
+    expect(() => parseDuration('not-a-duration')).toThrow(
+      'Could not parse not-a-duration as a valid duration',
+    );
+  });
 });
 
 describe('parseDateTimeOrDuration', () => {
@@ -47,6 +89,18 @@ describe('parseDateTimeOrDuration', () => {
       parseDateTimeOrDuration('foo');
     }).toThrowErrorMatchingInlineSnapshot(`"Invalid date or duration"`);
   });
+
+  it('should subtract a day-duration from "now" when given a duration string', () => {
+    expect(parseDateTimeOrDuration('1d').toISO()).toEqual(
+      '2019-12-31T17:00:00.000+00:00',
+    );
+  });
+
+  it('should subtract a week-duration from "now" when given a duration string', () => {
+    expect(parseDateTimeOrDuration('1w').toISO()).toEqual(
+      '2019-12-25T17:00:00.000+00:00',
+    );
+  });
 });
 
 describe('domain', () => {
@@ -58,6 +112,16 @@ describe('domain', () => {
         'prod.example.com.',
       );
     });
+
+    it('should handle a two-part domain by returning it unchanged with a trailing dot', () => {
+      expect(getHostedZoneName('example.org')).toEqual('example.org.');
+    });
+
+    it('should strip only the leftmost subdomain when there are many', () => {
+      expect(getHostedZoneName('a.b.c.d.example.com')).toEqual(
+        'b.c.d.example.com.',
+      );
+    });
   });
 
   describe('getWildCardDomainName', () => {
@@ -67,5 +131,73 @@ describe('domain', () => {
         '*.prod.example.com',
       );
     });
+
+    it('should replace the leftmost subdomain with a wildcard', () => {
+      expect(getWildCardDomainName('foo.bar.example.com')).toEqual(
+        '*.bar.example.com',
+      );
+    });
+  });
+});
+
+describe('toCfnKeys', () => {
+  it('should upper-case the first letter of top-level keys', () => {
+    expect(toCfnKeys({ foo: 'bar', baz: 1 })).toEqual({ Foo: 'bar', Baz: 1 });
+  });
+
+  it('should recurse into nested objects', () => {
+    expect(toCfnKeys({ foo: { bar: { baz: 1 } } })).toEqual({
+      Foo: { Bar: { Baz: 1 } },
+    });
+  });
+
+  it('should leave already-capitalized keys alone', () => {
+    expect(toCfnKeys({ Foo: 1, BAR: 2 })).toEqual({ Foo: 1, BAR: 2 });
+  });
+
+  it('should not modify scalar values', () => {
+    expect(
+      toCfnKeys({
+        a: 'string',
+        b: 42,
+        c: true,
+      }),
+    ).toEqual({
+      A: 'string',
+      B: 42,
+      C: true,
+    });
+  });
+
+  it('treats null as an object due to typeof check (pins down current behavior)', () => {
+    // typeof null === 'object', so isRecord(null) returns true and lodash's
+    // transform iterates null as an empty object. This is a known quirk —
+    // documenting here so any future refactor of isRecord is intentional.
+    expect(toCfnKeys({ value: null })).toEqual({ Value: {} });
+  });
+
+  it('should handle empty objects', () => {
+    expect(toCfnKeys({})).toEqual({});
+  });
+
+  it('should not modify arrays (treats them as non-records)', () => {
+    // Arrays in JS are typeof 'object', and the helper currently recurses into them;
+    // this test pins down current behavior so future refactors stay intentional.
+    const result = toCfnKeys({ items: [1, 2, 3] });
+    expect(result).toHaveProperty('Items');
+  });
+});
+
+describe('wait', () => {
+  it('should resolve after the specified time has elapsed', async () => {
+    const promise = wait(1000);
+    jest.advanceTimersByTime(1000);
+    await expect(promise).resolves.toBeUndefined();
+  });
+
+  it('should resolve immediately when given 0', async () => {
+    const promise = wait(0);
+    jest.advanceTimersByTime(0);
+    await expect(promise).resolves.toBeUndefined();
   });
 });
diff --git a/src/__tests__/waf.test.ts b/src/__tests__/waf.test.ts
@@ -245,4 +245,112 @@ describe('Waf', () => {
       });
     });
   });
+
+  describe('Edge cases', () => {
+    const api = new Api(given.appSyncConfig(), plugin);
+
+    it('uses an object-shaped defaultAction verbatim instead of wrapping a string', () => {
+      const waf = new Waf(api, {
+        enabled: true,
+        name: 'Waf',
+        // Object form (rather than the simpler `'Allow' | 'Block'` shorthand).
+        // The type narrows to string, but the runtime accepts either shape.
+        defaultAction: { Block: {} } as unknown as 'Allow' | 'Block',
+        rules: [],
+      });
+      const compiled = waf.compile() as unknown as Record<
+        string,
+        { Properties: { DefaultAction: unknown } }
+      >;
+      expect(compiled.GraphQlWaf.Properties.DefaultAction).toEqual({
+        Block: {},
+      });
+    });
+
+    it('falls back to a generated Waf name when none is provided', () => {
+      const waf = new Waf(api, {
+        enabled: true,
+        rules: [],
+      });
+      const compiled = waf.compile() as unknown as Record<
+        string,
+        { Properties: { Name: string } }
+      >;
+      // The default given.appSyncConfig is named 'MyApi', so the fallback is 'MyApiWaf'
+      expect(compiled.GraphQlWaf.Properties.Name).toEqual('MyApiWaf');
+    });
+
+    it('falls back to a generated description when none is provided', () => {
+      const waf = new Waf(api, {
+        enabled: true,
+        name: 'Waf',
+        rules: [],
+      });
+      const compiled = waf.compile() as unknown as Record<
+        string,
+        { Properties: { Description: string } }
+      >;
+      expect(compiled.GraphQlWaf.Properties.Description).toEqual(
+        'ACL rules for AppSync MyApi',
+      );
+    });
+
+    it('returns empty Resources when enabled=false even if rules are present', () => {
+      const waf = new Waf(api, {
+        enabled: false,
+        name: 'Waf',
+        rules: ['throttle'],
+      });
+      expect(waf.compile()).toEqual({});
+    });
+
+    it('handles a missing rules array (treats it as empty)', () => {
+      // The runtime guards `this.config.rules || []`, so a missing array
+      // shouldn't crash. Casting because the public type requires `rules`.
+      const waf = new Waf(api, {
+        enabled: true,
+        name: 'Waf',
+      } as unknown as ConstructorParameters<typeof Waf>[1]);
+      expect(() => waf.buildWafRules()).not.toThrow();
+    });
+
+    it('uses an explicit rule priority instead of incrementing the default', () => {
+      const waf = new Waf(api, {
+        enabled: true,
+        name: 'Waf',
+        rules: [
+          {
+            name: 'pinned',
+            priority: 42,
+            action: 'Block',
+            statement: { GeoMatchStatement: { CountryCodes: ['US'] } },
+          },
+        ],
+      });
+      const rules = waf.buildWafRules();
+      expect(rules[0]).toMatchObject({ Name: 'pinned', Priority: 42 });
+    });
+
+    it('assigns auto-incrementing priorities starting at 100 when rules omit priority', () => {
+      const waf = new Waf(api, {
+        enabled: true,
+        name: 'Waf',
+        rules: [
+          {
+            name: 'first',
+            action: 'Block',
+            statement: { GeoMatchStatement: { CountryCodes: ['US'] } },
+          },
+          {
+            name: 'second',
+            action: 'Block',
+            statement: { GeoMatchStatement: { CountryCodes: ['CA'] } },
+          },
+        ],
+      });
+      const rules = waf.buildWafRules();
+      expect(rules[0]).toMatchObject({ Name: 'first', Priority: 100 });
+      expect(rules[1]).toMatchObject({ Name: 'second', Priority: 101 });
+    });
+  });
 });
