@cdc/core 4.26.1 → 4.26.3

package/helpers/tests/markupProcessor.test.ts

@@ -21,7 +21,7 @@ describe('processMarkupVariables', () => {
       ]
 
       const content = 'The state is {{state}}'
-      const result = processMarkupVariables(content, testData, variables)
+      const result = processMarkupVariables(content, testData, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('The state is California, Texas, and Florida')
       expect(result.shouldHideSection).toBe(false)
@@ -35,7 +35,7 @@ describe('processMarkupVariables', () => {
       ]
 
       const content = 'Data for {{state}} in {{year}}'
-      const result = processMarkupVariables(content, testData, variables)
+      const result = processMarkupVariables(content, testData, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toContain('California, Texas, and Florida')
       expect(result.processedContent).toContain('2023')
@@ -43,18 +43,16 @@ describe('processMarkupVariables', () => {
 
     it('should return original content if no variables defined', () => {
       const content = 'Text with {{undefined}}'
-      const result = processMarkupVariables(content, testData, [])
+      const result = processMarkupVariables(content, testData, [], { locale: 'en-US' })
 
       expect(result.processedContent).toBe('Text with {{undefined}}')
     })
 
     it('should leave unknown variable tags unchanged', () => {
-      const variables: MarkupVariable[] = [
-        { name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }]
 
       const content = 'Known: {{state}}, Unknown: {{unknown}}'
-      const result = processMarkupVariables(content, testData, variables)
+      const result = processMarkupVariables(content, testData, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toContain('California, Texas, and Florida')
       expect(result.processedContent).toContain('{{unknown}}')
@@ -74,7 +72,7 @@ describe('processMarkupVariables', () => {
       ]
 
       const content = 'Population: {{population}}'
-      const result = processMarkupVariables(content, testData, variables)
+      const result = processMarkupVariables(content, testData, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toContain('39,538,223')
       expect(result.processedContent).toContain('29,145,505')
@@ -93,7 +91,7 @@ describe('processMarkupVariables', () => {
       ]
 
       const content = 'Population: {{population}}'
-      const result = processMarkupVariables(content, testData, variables)
+      const result = processMarkupVariables(content, testData, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toContain('39538223')
       expect(result.processedContent).not.toContain('39,538,223')
@@ -107,14 +105,12 @@ describe('processMarkupVariables', () => {
           name: 'State',
           tag: '{{state}}',
           columnName: 'state',
-          conditions: [
-            { columnName: 'state', isOrIsNotEqualTo: 'is', value: 'California' }
-          ]
+          conditions: [{ columnName: 'state', isOrIsNotEqualTo: 'is', value: 'California' }]
         }
       ]
 
       const content = 'The state is {{state}}'
-      const result = processMarkupVariables(content, testData, variables)
+      const result = processMarkupVariables(content, testData, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('The state is California')
     })
@@ -125,14 +121,12 @@ describe('processMarkupVariables', () => {
           name: 'State',
           tag: '{{state}}',
           columnName: 'state',
-          conditions: [
-            { columnName: 'state', isOrIsNotEqualTo: 'is not', value: 'California' }
-          ]
+          conditions: [{ columnName: 'state', isOrIsNotEqualTo: 'is not', value: 'California' }]
         }
       ]
 
       const content = 'States: {{state}}'
-      const result = processMarkupVariables(content, testData, variables)
+      const result = processMarkupVariables(content, testData, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('States: Texas and Florida')
       expect(result.processedContent).not.toContain('California')
@@ -158,7 +152,7 @@ describe('processMarkupVariables', () => {
       ]
 
       const content = 'State: {{state}}'
-      const result = processMarkupVariables(content, dataWithYears, variables)
+      const result = processMarkupVariables(content, dataWithYears, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('State: California')
     })
@@ -169,14 +163,12 @@ describe('processMarkupVariables', () => {
           name: 'State',
           tag: '{{state}}',
           columnName: 'state',
-          conditions: [
-            { columnName: 'state', isOrIsNotEqualTo: 'is', value: 'NonExistent' }
-          ]
+          conditions: [{ columnName: 'state', isOrIsNotEqualTo: 'is', value: 'NonExistent' }]
         }
       ]
 
       const content = 'State: {{state}}'
-      const result = processMarkupVariables(content, testData, variables)
+      const result = processMarkupVariables(content, testData, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('State: ')
     })
@@ -184,70 +176,45 @@ describe('processMarkupVariables', () => {
 
   describe('Empty Values and Null Handling', () => {
     it('should filter out empty string values', () => {
-      const dataWithEmpty = [
-        { name: 'Alice' },
-        { name: '' },
-        { name: 'Bob' },
-        { name: '' }
-      ]
+      const dataWithEmpty = [{ name: 'Alice' }, { name: '' }, { name: 'Bob' }, { name: '' }]
 
-      const variables: MarkupVariable[] = [
-        { name: 'Name', tag: '{{name}}', columnName: 'name', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'Name', tag: '{{name}}', columnName: 'name', conditions: [] }]
 
       const content = 'Names: {{name}}'
-      const result = processMarkupVariables(content, dataWithEmpty, variables)
+      const result = processMarkupVariables(content, dataWithEmpty, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('Names: Alice and Bob')
     })
 
     it('should handle null values gracefully', () => {
-      const dataWithNull = [
-        { value: 'A' },
-        { value: null },
-        { value: 'B' }
-      ]
+      const dataWithNull = [{ value: 'A' }, { value: null }, { value: 'B' }]
 
-      const variables: MarkupVariable[] = [
-        { name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }]
 
       const content = 'Values: {{value}}'
-      const result = processMarkupVariables(content, dataWithNull, variables)
+      const result = processMarkupVariables(content, dataWithNull, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('Values: A and B')
     })
 
     it('should handle undefined values', () => {
-      const dataWithUndefined = [
-        { value: 'A' },
-        { value: undefined },
-        { value: 'B' }
-      ]
+      const dataWithUndefined = [{ value: 'A' }, { value: undefined }, { value: 'B' }]
 
-      const variables: MarkupVariable[] = [
-        { name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }]
 
       const content = 'Values: {{value}}'
-      const result = processMarkupVariables(content, dataWithUndefined, variables)
+      const result = processMarkupVariables(content, dataWithUndefined, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('Values: A and B')
     })
 
     it('should return empty when all values are empty/null', () => {
-      const dataEmpty = [
-        { value: '' },
-        { value: null },
-        { value: undefined }
-      ]
+      const dataEmpty = [{ value: '' }, { value: null }, { value: undefined }]
 
-      const variables: MarkupVariable[] = [
-        { name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }]
 
       const content = 'Values: {{value}}'
-      const result = processMarkupVariables(content, dataEmpty, variables)
+      const result = processMarkupVariables(content, dataEmpty, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('Values: ')
     })
@@ -256,36 +223,30 @@ describe('processMarkupVariables', () => {
   describe('List Formatting', () => {
     it('should format two items with "and" in production mode', () => {
       const data = [{ state: 'CA' }, { state: 'TX' }]
-      const variables: MarkupVariable[] = [
-        { name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }]
 
       const content = '{{state}}'
-      const result = processMarkupVariables(content, data, variables, { isEditor: false })
+      const result = processMarkupVariables(content, data, variables, { isEditor: false, locale: 'en-US' })
 
       expect(result.processedContent).toBe('CA and TX')
     })
 
     it('should format three items with Oxford comma and "and"', () => {
       const data = [{ state: 'CA' }, { state: 'TX' }, { state: 'FL' }]
-      const variables: MarkupVariable[] = [
-        { name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }]
 
       const content = '{{state}}'
-      const result = processMarkupVariables(content, data, variables, { isEditor: false })
+      const result = processMarkupVariables(content, data, variables, { isEditor: false, locale: 'en-US' })
 
       expect(result.processedContent).toBe('CA, TX, and FL')
     })
 
     it('should use "or" conjunction in editor mode', () => {
       const data = [{ state: 'CA' }, { state: 'TX' }]
-      const variables: MarkupVariable[] = [
-        { name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }]
 
       const content = '{{state}}'
-      const result = processMarkupVariables(content, data, variables, { isEditor: true })
+      const result = processMarkupVariables(content, data, variables, { isEditor: true, locale: 'en-US' })
 
       expect(result.processedContent).toBe('CA or TX')
     })
@@ -293,17 +254,12 @@ describe('processMarkupVariables', () => {
 
   describe('XSS Prevention and Security', () => {
     it('should handle data with HTML tags safely', () => {
-      const maliciousData = [
-        { value: '<script>alert("xss")</script>' },
-        { value: '<img src=x onerror=alert(1)>' }
-      ]
+      const maliciousData = [{ value: '<script>alert("xss")</script>' }, { value: '<img src=x onerror=alert(1)>' }]
 
-      const variables: MarkupVariable[] = [
-        { name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }]
 
       const content = 'Data: {{value}}'
-      const result = processMarkupVariables(content, maliciousData, variables)
+      const result = processMarkupVariables(content, maliciousData, variables, { locale: 'en-US' })
 
       // Should return the raw strings, parsing responsibility is on the component using html-react-parser
       expect(result.processedContent).toContain('<script>')
@@ -311,17 +267,12 @@ describe('processMarkupVariables', () => {
     })
 
     it('should handle special characters in data', () => {
-      const specialData = [
-        { value: 'Test & Value' },
-        { value: 'Price: $100 < $200' }
-      ]
+      const specialData = [{ value: 'Test & Value' }, { value: 'Price: $100 < $200' }]
 
-      const variables: MarkupVariable[] = [
-        { name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }]
 
       const content = '{{value}}'
-      const result = processMarkupVariables(content, specialData, variables)
+      const result = processMarkupVariables(content, specialData, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toContain('Test & Value')
       expect(result.processedContent).toContain('Price: $100 < $200')
@@ -331,14 +282,13 @@ describe('processMarkupVariables', () => {
   describe('Hide Section Logic', () => {
     it('should set shouldHideSection when allowHideSection is true and values are empty', () => {
       const emptyData = [{ value: '' }]
-      const variables: MarkupVariable[] = [
-        { name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }]
 
       const content = '{{value}}'
       const result = processMarkupVariables(content, emptyData, variables, {
         allowHideSection: true,
-        isEditor: false
+        isEditor: false,
+        locale: 'en-US'
       })
 
       expect(result.shouldHideSection).toBe(true)
@@ -346,14 +296,13 @@ describe('processMarkupVariables', () => {
 
     it('should not hide section in editor mode even if values are empty', () => {
       const emptyData = [{ value: '' }]
-      const variables: MarkupVariable[] = [
-        { name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }]
 
       const content = '{{value}}'
       const result = processMarkupVariables(content, emptyData, variables, {
         allowHideSection: true,
-        isEditor: true
+        isEditor: true,
+        locale: 'en-US'
       })
 
       expect(result.shouldHideSection).toBe(false)
@@ -363,67 +312,268 @@ describe('processMarkupVariables', () => {
   describe('No Data Message Logic', () => {
     it('should set shouldShowNoDataMessage when enabled and values are empty', () => {
       const emptyData = [{ value: '' }]
-      const variables: MarkupVariable[] = [
-        { name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }]
 
       const content = '{{value}}'
       const result = processMarkupVariables(content, emptyData, variables, {
         showNoDataMessage: true,
-        isEditor: false
+        isEditor: false,
+        locale: 'en-US'
       })
 
       expect(result.shouldShowNoDataMessage).toBe(true)
     })
   })
 
-  describe('Edge Cases', () => {
-    it('should handle empty data array', () => {
+  describe('Metadata-Sourced Variables', () => {
+    it('should resolve metadata variable from dataMetadata', () => {
+      const variables: MarkupVariable[] = [
+        {
+          name: 'Last Updated',
+          tag: '{{lastUpdated}}',
+          metadataKey: 'lastUpdated',
+          conditions: []
+        }
+      ]
+
+      const content = 'Data last updated {{lastUpdated}}'
+      const result = processMarkupVariables(content, testData, variables, {
+        dataMetadata: { lastUpdated: 'January 15, 2026' }
+      })
+
+      expect(result.processedContent).toBe('Data last updated January 15, 2026')
+      expect(result.shouldHideSection).toBe(false)
+      expect(result.shouldShowNoDataMessage).toBe(false)
+    })
+
+    it('should return empty string when dataMetadata does not contain the key', () => {
+      const variables: MarkupVariable[] = [
+        {
+          name: 'Last Updated',
+          tag: '{{lastUpdated}}',
+          metadataKey: 'lastUpdated',
+          conditions: []
+        }
+      ]
+
+      const content = 'Data last updated {{lastUpdated}}'
+      const result = processMarkupVariables(content, testData, variables, {
+        dataMetadata: { source: 'CDC' }
+      })
+
+      expect(result.processedContent).toBe('Data last updated ')
+    })
+
+    it('should resolve metadata variable even when conditions are defined', () => {
+      const variables: MarkupVariable[] = [
+        {
+          name: 'Last Updated',
+          tag: '{{lastUpdated}}',
+          metadataKey: 'lastUpdated',
+          conditions: [{ columnName: 'state', isOrIsNotEqualTo: 'is', value: 'California' }]
+        }
+      ]
+
+      const content = '{{lastUpdated}}'
+      const result = processMarkupVariables(content, testData, variables, {
+        dataMetadata: { lastUpdated: 'January 15, 2026' }
+      })
+
+      expect(result.processedContent).toBe('January 15, 2026')
+    })
+
+    it('should handle mixed metadata and column variables in the same content', () => {
+      const variables: MarkupVariable[] = [
+        {
+          name: 'Last Updated',
+          tag: '{{lastUpdated}}',
+          metadataKey: 'lastUpdated',
+          conditions: []
+        },
+        {
+          name: 'State',
+          tag: '{{state}}',
+          columnName: 'state',
+          conditions: [{ columnName: 'state', isOrIsNotEqualTo: 'is', value: 'California' }]
+        }
+      ]
+
+      const content = '{{state}} data last updated {{lastUpdated}}'
+      const result = processMarkupVariables(content, testData, variables, {
+        dataMetadata: { lastUpdated: 'January 15, 2026' }
+      })
+
+      expect(result.processedContent).toBe('California data last updated January 15, 2026')
+    })
+
+    it('should not trigger columnName warning for metadata variable without columnName', () => {
+      const variables: MarkupVariable[] = [
+        {
+          name: 'Source',
+          tag: '{{source}}',
+          metadataKey: 'source',
+          conditions: []
+        }
+      ]
+
+      const content = 'Source: {{source}}'
+      const result = processMarkupVariables(content, testData, variables, {
+        dataMetadata: { source: 'CDC NREVSS' }
+      })
+
+      expect(result.processedContent).toBe('Source: CDC NREVSS')
+    })
+
+    it('should return empty string for metadata variable when dataMetadata is empty', () => {
+      const variables: MarkupVariable[] = [
+        {
+          name: 'Last Updated',
+          tag: '{{lastUpdated}}',
+          metadataKey: 'lastUpdated',
+          conditions: []
+        }
+      ]
+
+      const content: string = 'Updated: {{lastUpdated}}'
+      const result = processMarkupVariables(content, testData, variables, {
+        dataMetadata: {}
+      })
+
+      expect(result.processedContent).toBe('Updated: ')
+    })
+
+    it('should return empty string for metadata variable when dataMetadata is undefined', () => {
+      const variables: MarkupVariable[] = [
+        {
+          name: 'Last Updated',
+          tag: '{{lastUpdated}}',
+          metadataKey: 'lastUpdated',
+          conditions: []
+        }
+      ]
+
+      const content = 'Updated: {{lastUpdated}}'
+      const result = processMarkupVariables(content, testData, variables)
+
+      expect(result.processedContent).toBe('Updated: ')
+    })
+
+    it('should format numeric metadata value with commas when addCommas is true', () => {
+      const variables: MarkupVariable[] = [
+        {
+          name: 'Count',
+          tag: '{{count}}',
+          metadataKey: 'count',
+          conditions: [],
+          addCommas: true
+        }
+      ]
+
+      const content = 'Total: {{count}}'
+      const result = processMarkupVariables(content, testData, variables, {
+        dataMetadata: { count: '1234567' }
+      })
+
+      expect(result.processedContent).toBe('Total: 1,234,567')
+    })
+
+    it('should not format non-numeric metadata value even when addCommas is true', () => {
       const variables: MarkupVariable[] = [
-        { name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }
+        {
+          name: 'Source',
+          tag: '{{source}}',
+          metadataKey: 'source',
+          conditions: [],
+          addCommas: true
+        }
       ]
 
+      const content = 'Source: {{source}}'
+      const result = processMarkupVariables(content, testData, variables, {
+        dataMetadata: { source: 'CDC' }
+      })
+
+      expect(result.processedContent).toBe('Source: CDC')
+    })
+
+    it('should set shouldHideSection when metadata value is empty and allowHideSection is true', () => {
+      const variables: MarkupVariable[] = [
+        {
+          name: 'Last Updated',
+          tag: '{{lastUpdated}}',
+          metadataKey: 'lastUpdated',
+          conditions: [],
+          hideOnNull: true
+        }
+      ]
+
+      const content = '{{lastUpdated}}'
+      const result = processMarkupVariables(content, testData, variables, {
+        dataMetadata: {},
+        allowHideSection: true,
+        isEditor: false
+      })
+
+      expect(result.shouldHideSection).toBe(true)
+    })
+
+    it('should not set shouldHideSection when metadata value exists', () => {
+      const variables: MarkupVariable[] = [
+        {
+          name: 'Last Updated',
+          tag: '{{lastUpdated}}',
+          metadataKey: 'lastUpdated',
+          conditions: [],
+          hideOnNull: true
+        }
+      ]
+
+      const content = '{{lastUpdated}}'
+      const result = processMarkupVariables(content, testData, variables, {
+        dataMetadata: { lastUpdated: 'Jan 2026' },
+        allowHideSection: true,
+        isEditor: false
+      })
+
+      expect(result.shouldHideSection).toBe(false)
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('should handle empty data array', () => {
+      const variables: MarkupVariable[] = [{ name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }]
+
       const content = '{{value}}'
-      const result = processMarkupVariables(content, [], variables)
+      const result = processMarkupVariables(content, [], variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('')
     })
 
     it('should handle empty content string', () => {
-      const variables: MarkupVariable[] = [
-        { name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'Value', tag: '{{value}}', columnName: 'value', conditions: [] }]
 
-      const result = processMarkupVariables('', testData, variables)
+      const result = processMarkupVariables('', testData, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('')
     })
 
     it('should handle single item (no conjunction)', () => {
       const data = [{ state: 'California' }]
-      const variables: MarkupVariable[] = [
-        { name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }]
 
       const content = '{{state}}'
-      const result = processMarkupVariables(content, data, variables)
+      const result = processMarkupVariables(content, data, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('California')
     })
 
     it('should remove duplicate values from list', () => {
-      const duplicateData = [
-        { state: 'California' },
-        { state: 'Texas' },
-        { state: 'California' }
-      ]
+      const duplicateData = [{ state: 'California' }, { state: 'Texas' }, { state: 'California' }]
 
-      const variables: MarkupVariable[] = [
-        { name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }
-      ]
+      const variables: MarkupVariable[] = [{ name: 'State', tag: '{{state}}', columnName: 'state', conditions: [] }]
 
       const content = '{{state}}'
-      const result = processMarkupVariables(content, duplicateData, variables)
+      const result = processMarkupVariables(content, duplicateData, variables, { locale: 'en-US' })
 
       expect(result.processedContent).toBe('California and Texas')
     })
@@ -431,9 +581,7 @@ describe('processMarkupVariables', () => {
 })
 
 describe('validateMarkupVariables', () => {
-  const testData = [
-    { state: 'CA', population: '1000' }
-  ]
+  const testData = [{ state: 'CA', population: '1000' }]
 
   it('should return no errors for valid configuration', () => {
     const variables: MarkupVariable[] = [
@@ -535,4 +683,47 @@ describe('validateMarkupVariables', () => {
     const errors3 = validateMarkupVariables('not an array' as any, testData)
     expect(errors3).toHaveLength(0)
   })
-})
+
+  it('should skip columnName validation when variable has metadataKey', () => {
+    const variables: MarkupVariable[] = [
+      {
+        name: 'Last Updated',
+        tag: '{{lastUpdated}}',
+        metadataKey: 'lastUpdated',
+        conditions: []
+      }
+    ]
+
+    const errors = validateMarkupVariables(variables, testData)
+    expect(errors).toHaveLength(0)
+    expect(errors).not.toContain('Variable 1: Column name is required')
+  })
+
+  it('should still require columnName when neither metadataKey nor columnName is set', () => {
+    const variables: MarkupVariable[] = [
+      {
+        name: 'Bad Variable',
+        tag: '{{bad}}',
+        conditions: []
+      }
+    ]
+
+    const errors = validateMarkupVariables(variables, testData)
+    expect(errors).toContain('Variable 1: Column name is required')
+  })
+
+  it('should skip column-not-found validation when variable has metadataKey', () => {
+    const variables: MarkupVariable[] = [
+      {
+        name: 'Source',
+        tag: '{{source}}',
+        metadataKey: 'source',
+        conditions: []
+      }
+    ]
+
+    const errors = validateMarkupVariables(variables, testData)
+    expect(errors).toHaveLength(0)
+    expect(errors.find(e => e.includes('not found in data'))).toBeUndefined()
+  })
+})