test: improve domain coverage

__tests__/entities/policies.test.ts

@@ -0,0 +1,39 @@
+import {
+  isValidMatchPolicy,
+  isValidTTL,
+  StackNamePolicy,
+  TagPolicy
+} from '@entities/policies'
+
+describe('isValidTTL', () => {
+  it('returns true for valid TTL policies', () => {
+    expect(isValidTTL({days: 1})).toEqual(true)
+    expect(isValidTTL({hours: 1})).toEqual(true)
+    expect(isValidTTL({minutes: 1})).toEqual(true)
+  })
+
+  it('treats 0 time units as valid', () => {
+    expect(isValidTTL({days: 0})).toEqual(true)
+    expect(isValidTTL({hours: 0})).toEqual(true)
+    expect(isValidTTL({minutes: 0})).toEqual(true)
+  })
+
+  it('returns false for invalid TTL policies', () => {
+    expect(isValidTTL({})).toEqual(false)
+  })
+})
+
+describe('isValidMatchPolicy', () => {
+  const namePolicy: StackNamePolicy = {pattern: 'dev'}
+  const tagPolicy: TagPolicy = {tag: 'env', pattern: 'dev'}
+
+  it('returns true for valid match policies', () => {
+    expect(isValidMatchPolicy({name: namePolicy})).toEqual(true)
+    expect(isValidMatchPolicy({tags: [tagPolicy]})).toEqual(true)
+  })
+
+  it('returns false for invalid match policies', () => {
+    expect(isValidMatchPolicy({})).toEqual(false)
+    expect(isValidMatchPolicy({tags: []})).toEqual(false)
+  })
+})

__tests__/usecases/checks/stack-age-check.test.ts

@@ -35,6 +35,16 @@ describe('StackAgeCheck', () => {
     })
   })
 
+  it('passes when the stack is exactly the age of the ttl policy', async () => {
+    const threeHoursAgo = sub(now, {hours: 3, minutes: 30})
+    const result = await check(stack(threeHoursAgo))
+    expect(result).toEqual({
+      isLegacy: false,
+      description:
+        'checked stack age [2021-01-01T08:30:00.000Z] against ttl [3 hours 30 minutes]'
+    })
+  })
+
   it('fails when the stack is older than the ttl policy', async () => {
     const fourHoursAgo = sub(now, {hours: 4})
     const result = await check(stack(fourHoursAgo))

__tests__/usecases/parse-policies.test.ts

@@ -5,7 +5,7 @@ describe('parsePolicies', () => {
   it('parses valid yaml', () => {
     const yaml = `
       policies:
-        clean-staging:
+        clean-dev:
           match:
             tags:
               environment: 'dev*'
@@ -20,7 +20,7 @@ describe('parsePolicies', () => {
     const policy = parsePolicies(yaml)
     expect(policy).toEqual([
       {
-        name: 'clean-staging',
+        name: 'clean-dev',
         match: {
           tags: [{pattern: 'dev*', tag: 'environment'}]
         },
@@ -151,5 +151,36 @@ describe('parsePolicies', () => {
         ])
       )
     })
+
+    it('requires a valid tags policy', () => {
+      const yaml = `
+      policies:
+        invalid-match:
+          ttl:
+            hours: 3
+          match: {
+            tags: {}
+          }
+      `
+      expect(() => parsePolicies(yaml)).toThrowError(
+        new z.ZodError([
+          {
+            code: 'custom',
+            message: 'Policy must match on at least one tag',
+            path: ['policies', 'invalid-match', 'match', 'tags']
+          },
+          {
+            code: 'custom',
+            message: 'Policy must match on either name or tags',
+            path: ['policies', 'invalid-match', 'match']
+          },
+          {
+            code: 'custom',
+            message: 'At least one policy must be defined',
+            path: []
+          }
+        ])
+      )
+    })
   })
 })

src/domain/entities/policies.ts

@@ -28,6 +28,6 @@ export type StackPolicy = {
 }
 
 export const isValidMatchPolicy = ({name, tags}: MatchPolicy): boolean =>
-  !(name === undefined && tags === undefined)
+  name !== undefined || (tags !== undefined && tags.length > 0)
 
 export type PolicyParser = (input: string) => StackPolicy[]

src/domain/usecases/parse-policies.ts

@@ -17,6 +17,9 @@ const TagsPolicyParser = z
   .transform(arg =>
     Object.entries(arg).map(([tag, pattern]) => ({tag, pattern}))
   )
+  .refine(policies => policies.length > 0, {
+    message: 'Policy must match on at least one tag'
+  })
 
 const MatchPolicy = z
   .object({