@cdc/dashboard 4.25.10 → 4.26.1

package/src/helpers/tests/filterResetHelpers.test.ts

@@ -0,0 +1,532 @@
+import { describe, it, expect } from 'vitest'
+import { getFilterResetValue, resetFilterToValue, clearChildFilterDropdowns } from '../filterResetHelpers'
+import { SharedFilter } from '../../types/SharedFilter'
+import { APIFilterDropdowns } from '../../components/DashboardFilters'
+import { FILTER_STYLE } from '../../types/FilterStyles'
+import _ from 'lodash'
+
+describe('getFilterResetValue', () => {
+  const mockAPIFilterDropdowns: APIFilterDropdowns = {
+    'api.example.com/filter1': [
+      { value: 'option1', text: 'Option 1' },
+      { value: 'option2', text: 'Option 2' }
+    ],
+    'api.example.com/filter2': []
+  }
+
+  describe('when forceEmpty is true', () => {
+    it('should return empty string for API filters without resetLabel', () => {
+      const filter: SharedFilter = {
+        key: 'testFilter',
+        apiFilter: {
+          apiEndpoint: 'api.example.com/filter1',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+
+      const result = getFilterResetValue(filter, mockAPIFilterDropdowns, true)
+      expect(result).toBe('')
+    })
+
+    it('should return empty string for API filters with resetLabel', () => {
+      const filter: SharedFilter = {
+        key: 'testFilter',
+        resetLabel: 'Select One',
+        apiFilter: {
+          apiEndpoint: 'api.example.com/filter1',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+
+      const result = getFilterResetValue(filter, mockAPIFilterDropdowns, true)
+      expect(result).toBe('')
+    })
+
+    it('should return empty string for data filters with resetLabel', () => {
+      const filter: SharedFilter = {
+        key: 'testFilter',
+        resetLabel: 'Select One',
+        values: ['value1', 'value2']
+      }
+
+      const result = getFilterResetValue(filter, mockAPIFilterDropdowns, true)
+      expect(result).toBe('')
+    })
+
+    it('should return undefined for data filters without resetLabel', () => {
+      const filter: SharedFilter = {
+        key: 'testFilter',
+        values: ['value1', 'value2']
+      }
+
+      const result = getFilterResetValue(filter, mockAPIFilterDropdowns, true)
+      expect(result).toBe('')
+    })
+  })
+
+  describe('when forceEmpty is false', () => {
+    it('should return defaultValue if it exists', () => {
+      const filter: SharedFilter = {
+        key: 'testFilter',
+        defaultValue: 'defaultVal',
+        resetLabel: 'Select One',
+        apiFilter: {
+          apiEndpoint: 'api.example.com/filter1',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+
+      const result = getFilterResetValue(filter, mockAPIFilterDropdowns, false)
+      expect(result).toBe('defaultVal')
+    })
+
+    it('should return empty string if resetLabel exists (no defaultValue)', () => {
+      const filter: SharedFilter = {
+        key: 'testFilter',
+        resetLabel: 'Select One',
+        apiFilter: {
+          apiEndpoint: 'api.example.com/filter1',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+
+      const result = getFilterResetValue(filter, mockAPIFilterDropdowns, false)
+      expect(result).toBe('')
+    })
+
+    it('should return first API option if no defaultValue or resetLabel', () => {
+      const filter: SharedFilter = {
+        key: 'testFilter',
+        apiFilter: {
+          apiEndpoint: 'api.example.com/filter1',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+
+      const result = getFilterResetValue(filter, mockAPIFilterDropdowns, false)
+      expect(result).toBe('option1')
+    })
+
+    it('should return undefined if API filter has no options', () => {
+      const filter: SharedFilter = {
+        key: 'testFilter',
+        apiFilter: {
+          apiEndpoint: 'api.example.com/filter2',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+
+      const result = getFilterResetValue(filter, mockAPIFilterDropdowns, false)
+      expect(result).toBeUndefined()
+    })
+
+    it('should return undefined if no API filter, defaultValue, or resetLabel', () => {
+      const filter: SharedFilter = {
+        key: 'testFilter',
+        values: ['value1', 'value2']
+      }
+
+      const result = getFilterResetValue(filter, mockAPIFilterDropdowns, false)
+      expect(result).toBeUndefined()
+    })
+  })
+})
+
+describe('resetFilterToValue', () => {
+  const mockAPIFilterDropdowns: APIFilterDropdowns = {
+    'api.example.com/nested': [
+      {
+        value: 'group1',
+        text: 'Group 1',
+        subOptions: [
+          { value: 'sub1', text: 'Sub 1' },
+          { value: 'sub2', text: 'Sub 2' }
+        ]
+      },
+      {
+        value: 'group2',
+        text: 'Group 2',
+        subOptions: [{ value: 'sub3', text: 'Sub 3' }]
+      }
+    ]
+  }
+
+  describe('multi-select filters', () => {
+    it('should reset to array with single value when resetValue is provided', () => {
+      const filter: SharedFilter = {
+        key: 'multiFilter',
+        filterStyle: FILTER_STYLE.multiSelect,
+        active: ['value1', 'value2'],
+        queuedActive: ['value3']
+      }
+
+      resetFilterToValue(filter, 'value1', mockAPIFilterDropdowns)
+
+      expect(filter.active).toEqual(['value1'])
+      expect(filter.queuedActive).toBeUndefined()
+    })
+
+    it('should reset to empty array when resetValue is undefined', () => {
+      const filter: SharedFilter = {
+        key: 'multiFilter',
+        filterStyle: FILTER_STYLE.multiSelect,
+        active: ['value1', 'value2']
+      }
+
+      resetFilterToValue(filter, undefined, mockAPIFilterDropdowns)
+
+      expect(filter.active).toEqual([])
+      expect(filter.queuedActive).toBeUndefined()
+    })
+
+    it('should reset to empty array when resetValue is empty string', () => {
+      const filter: SharedFilter = {
+        key: 'multiFilter',
+        filterStyle: FILTER_STYLE.multiSelect,
+        active: ['value1', 'value2']
+      }
+
+      resetFilterToValue(filter, '', mockAPIFilterDropdowns)
+
+      expect(filter.active).toEqual([])
+      expect(filter.queuedActive).toBeUndefined()
+    })
+  })
+
+  describe('nested dropdown filters', () => {
+    it('should clear both group and subgroup when resetValue is empty string', () => {
+      const filter: SharedFilter = {
+        key: 'nestedFilter',
+        filterStyle: FILTER_STYLE.nestedDropdown,
+        active: 'group1',
+        subGrouping: {
+          active: 'sub1'
+        },
+        apiFilter: {
+          apiEndpoint: 'api.example.com/nested',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+
+      resetFilterToValue(filter, '', mockAPIFilterDropdowns)
+
+      expect(filter.active).toBe('')
+      expect(filter.subGrouping.active).toBe('')
+      expect(filter.queuedActive).toBeUndefined()
+    })
+
+    it('should clear both group and subgroup when resetValue is undefined', () => {
+      const filter: SharedFilter = {
+        key: 'nestedFilter',
+        filterStyle: FILTER_STYLE.nestedDropdown,
+        active: 'group1',
+        subGrouping: {
+          active: 'sub1'
+        },
+        apiFilter: {
+          apiEndpoint: 'api.example.com/nested',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+
+      resetFilterToValue(filter, undefined, mockAPIFilterDropdowns)
+
+      expect(filter.active).toBe('')
+      expect(filter.subGrouping.active).toBe('')
+      expect(filter.queuedActive).toBeUndefined()
+    })
+
+    it('should set to resetValue and first suboption when resetValue is provided', () => {
+      const filter: SharedFilter = {
+        key: 'nestedFilter',
+        filterStyle: FILTER_STYLE.nestedDropdown,
+        active: 'oldValue',
+        subGrouping: {
+          active: 'oldSub'
+        },
+        apiFilter: {
+          apiEndpoint: 'api.example.com/nested',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+
+      resetFilterToValue(filter, 'group2', mockAPIFilterDropdowns)
+
+      expect(filter.active).toBe('group2')
+      expect(filter.subGrouping.active).toBe('sub3')
+      expect(filter.queuedActive).toBeUndefined()
+    })
+
+    it('should fallback to first option when no resetValue and options exist', () => {
+      const filter: SharedFilter = {
+        key: 'nestedFilter',
+        filterStyle: FILTER_STYLE.nestedDropdown,
+        active: 'oldValue',
+        subGrouping: {
+          active: 'oldSub'
+        },
+        apiFilter: {
+          apiEndpoint: 'api.example.com/nested',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+
+      resetFilterToValue(filter, undefined, mockAPIFilterDropdowns)
+
+      expect(filter.active).toBe('')
+      expect(filter.subGrouping.active).toBe('')
+      expect(filter.queuedActive).toBeUndefined()
+    })
+  })
+
+  describe('standard dropdown filters', () => {
+    it('should reset to provided resetValue', () => {
+      const filter: SharedFilter = {
+        key: 'standardFilter',
+        active: 'oldValue',
+        queuedActive: 'queuedValue'
+      }
+
+      resetFilterToValue(filter, 'newValue', mockAPIFilterDropdowns)
+
+      expect(filter.active).toBe('newValue')
+      expect(filter.queuedActive).toBeUndefined()
+    })
+
+    it('should reset to empty string when resetValue is empty string', () => {
+      const filter: SharedFilter = {
+        key: 'standardFilter',
+        active: 'oldValue'
+      }
+
+      resetFilterToValue(filter, '', mockAPIFilterDropdowns)
+
+      expect(filter.active).toBe('')
+      expect(filter.queuedActive).toBeUndefined()
+    })
+
+    it('should reset to undefined when resetValue is undefined', () => {
+      const filter: SharedFilter = {
+        key: 'standardFilter',
+        active: 'oldValue'
+      }
+
+      resetFilterToValue(filter, undefined, mockAPIFilterDropdowns)
+
+      expect(filter.active).toBeUndefined()
+      expect(filter.queuedActive).toBeUndefined()
+    })
+  })
+})
+
+describe('clearChildFilterDropdowns', () => {
+  it('should clear dropdowns for filters with parents', () => {
+    const sharedFilters: SharedFilter[] = [
+      {
+        key: 'parentFilter',
+        apiFilter: {
+          apiEndpoint: 'api.example.com/parent',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      },
+      {
+        key: 'childFilter',
+        parents: ['parentFilter'],
+        apiFilter: {
+          apiEndpoint: 'api.example.com/child',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+    ]
+
+    const apiFilterDropdowns: APIFilterDropdowns = {
+      'api.example.com/parent': [
+        { value: 'parent1', text: 'Parent 1' },
+        { value: 'parent2', text: 'Parent 2' }
+      ],
+      'api.example.com/child': [
+        { value: 'child1', text: 'Child 1' },
+        { value: 'child2', text: 'Child 2' }
+      ]
+    }
+
+    const result = clearChildFilterDropdowns(sharedFilters, apiFilterDropdowns)
+
+    // Parent filter dropdown should remain unchanged
+    expect(result['api.example.com/parent']).toEqual([
+      { value: 'parent1', text: 'Parent 1' },
+      { value: 'parent2', text: 'Parent 2' }
+    ])
+
+    // Child filter dropdown should be cleared to empty array
+    expect(result['api.example.com/child']).toEqual([])
+  })
+
+  it('should not clear dropdowns for filters without parents', () => {
+    const sharedFilters: SharedFilter[] = [
+      {
+        key: 'filter1',
+        apiFilter: {
+          apiEndpoint: 'api.example.com/filter1',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      },
+      {
+        key: 'filter2',
+        apiFilter: {
+          apiEndpoint: 'api.example.com/filter2',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+    ]
+
+    const apiFilterDropdowns: APIFilterDropdowns = {
+      'api.example.com/filter1': [{ value: 'val1', text: 'Value 1' }],
+      'api.example.com/filter2': [{ value: 'val2', text: 'Value 2' }]
+    }
+
+    const result = clearChildFilterDropdowns(sharedFilters, apiFilterDropdowns)
+
+    // Both should remain unchanged since neither has parents
+    expect(result['api.example.com/filter1']).toEqual([{ value: 'val1', text: 'Value 1' }])
+    expect(result['api.example.com/filter2']).toEqual([{ value: 'val2', text: 'Value 2' }])
+  })
+
+  it('should handle filters with empty parents array', () => {
+    const sharedFilters: SharedFilter[] = [
+      {
+        key: 'filter1',
+        parents: [],
+        apiFilter: {
+          apiEndpoint: 'api.example.com/filter1',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+    ]
+
+    const apiFilterDropdowns: APIFilterDropdowns = {
+      'api.example.com/filter1': [{ value: 'val1', text: 'Value 1' }]
+    }
+
+    const result = clearChildFilterDropdowns(sharedFilters, apiFilterDropdowns)
+
+    // Should remain unchanged since parents array is empty
+    expect(result['api.example.com/filter1']).toEqual([{ value: 'val1', text: 'Value 1' }])
+  })
+
+  it('should handle mixed filters with and without parents', () => {
+    const sharedFilters: SharedFilter[] = [
+      {
+        key: 'parent',
+        apiFilter: {
+          apiEndpoint: 'api.example.com/parent',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      },
+      {
+        key: 'child1',
+        parents: ['parent'],
+        apiFilter: {
+          apiEndpoint: 'api.example.com/child1',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      },
+      {
+        key: 'independent',
+        apiFilter: {
+          apiEndpoint: 'api.example.com/independent',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      },
+      {
+        key: 'child2',
+        parents: ['child1'],
+        apiFilter: {
+          apiEndpoint: 'api.example.com/child2',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+    ]
+
+    const apiFilterDropdowns: APIFilterDropdowns = {
+      'api.example.com/parent': [{ value: 'p1', text: 'Parent 1' }],
+      'api.example.com/child1': [{ value: 'c1', text: 'Child 1' }],
+      'api.example.com/independent': [{ value: 'i1', text: 'Independent 1' }],
+      'api.example.com/child2': [{ value: 'c2', text: 'Child 2' }]
+    }
+
+    const result = clearChildFilterDropdowns(sharedFilters, apiFilterDropdowns)
+
+    // Parent and independent should remain unchanged
+    expect(result['api.example.com/parent']).toEqual([{ value: 'p1', text: 'Parent 1' }])
+    expect(result['api.example.com/independent']).toEqual([{ value: 'i1', text: 'Independent 1' }])
+
+    // Children should be cleared
+    expect(result['api.example.com/child1']).toEqual([])
+    expect(result['api.example.com/child2']).toEqual([])
+  })
+
+  it('should not mutate original apiFilterDropdowns', () => {
+    const sharedFilters: SharedFilter[] = [
+      {
+        key: 'child',
+        parents: ['parent'],
+        apiFilter: {
+          apiEndpoint: 'api.example.com/child',
+          valueSelector: 'value',
+          textSelector: 'text'
+        }
+      }
+    ]
+
+    const apiFilterDropdowns: APIFilterDropdowns = {
+      'api.example.com/child': [{ value: 'child1', text: 'Child 1' }]
+    }
+
+    const originalDropdowns = _.cloneDeep(apiFilterDropdowns)
+    const result = clearChildFilterDropdowns(sharedFilters, apiFilterDropdowns)
+
+    // Original should remain unchanged
+    expect(apiFilterDropdowns).toEqual(originalDropdowns)
+    // Result should have cleared child
+    expect(result['api.example.com/child']).toEqual([])
+  })
+
+  it('should handle filters without apiFilter', () => {
+    const sharedFilters: SharedFilter[] = [
+      {
+        key: 'dataFilter',
+        parents: ['parent'],
+        values: ['value1', 'value2']
+      }
+    ]
+
+    const apiFilterDropdowns: APIFilterDropdowns = {
+      'api.example.com/other': [{ value: 'val1', text: 'Value 1' }]
+    }
+
+    const result = clearChildFilterDropdowns(sharedFilters, apiFilterDropdowns)
+
+    // Should remain unchanged since dataFilter doesn't have apiFilter
+    expect(result).toEqual(apiFilterDropdowns)
+  })
+})

package/src/helpers/tests/updatesChildFilters.test.ts

@@ -2,55 +2,86 @@ import { SharedFilter } from '../../types/SharedFilter'
 import { updateChildFilters } from '../updateChildFilters'
 
 describe('updateChildFilters', () => {
-  it('should filter data based on the provided filters', () => {
+  it('should filter data based on a single parent filter', () => {
     const filters = [
       {
         tier: 1,
         columnName: 'name',
         active: 'John',
         key: 'Parent Filter',
-        values: ['John', 'Kelly', 'Norman', 'Jane']
+        values: ['John', 'Kelly', 'Norman', 'Jane'],
+        type: 'datafilter'
       },
       {
         tier: 2,
         columnName: 'lastName',
         active: '',
         key: 'Child Filter',
-        parents: 'Parent Filter',
-        values: ['Deer', 'Roberts']
+        parents: ['Parent Filter'],
+        values: ['Deer', 'Roberts'],
+        type: 'datafilter'
       }
     ] as SharedFilter[]
     const data = {
       vizKey: [
-        [
-          { name: 'John', lastName: 'Deer' },
-          { name: 'John', lastName: 'Roberts' },
-          { name: 'Kelly', lastName: 'Adams' },
-          { name: 'Norman', lastName: 'Sally' },
-          { name: 'Jane', lastName: 'Gorman' }
-        ]
+        { name: 'John', lastName: 'Deer' },
+        { name: 'John', lastName: 'Roberts' },
+        { name: 'Kelly', lastName: 'Adams' },
+        { name: 'Norman', lastName: 'Sally' },
+        { name: 'Jane', lastName: 'Gorman' }
       ]
     }
 
-    let exprectedResult = [
+    const result = updateChildFilters(filters, data)
+
+    expect(result[0]).toEqual(filters[0]) // Parent unchanged
+    expect(result[1].values).toEqual(['Deer', 'Roberts']) // Child values filtered
+    expect(result[1].active).toBe('Deer') // Active set to first value when empty
+  })
+
+  it('should filter data based on multiple parent filters', () => {
+    const filters = [
       {
         tier: 1,
-        columnName: 'name',
-        active: 'John',
-        key: 'Parent Filter',
-        values: ['John', 'Kelly', 'Norman', 'Jane']
+        columnName: 'state',
+        active: 'CA',
+        key: 'State Filter',
+        values: ['CA', 'NY', 'TX'],
+        type: 'datafilter'
+      },
+      {
+        tier: 1,
+        columnName: 'year',
+        active: '2023',
+        key: 'Year Filter',
+        values: ['2022', '2023', '2024'],
+        type: 'datafilter'
       },
       {
         tier: 2,
-        columnName: 'lastName',
+        columnName: 'city',
         active: '',
-        key: 'Child Filter',
-        parents: 'Parent Filter',
-        values: ['Deer', 'Roberts'] // updated values only
+        key: 'City Filter',
+        parents: ['State Filter', 'Year Filter'],
+        values: [],
+        type: 'datafilter'
       }
-    ]
+    ] as SharedFilter[]
+    const data = {
+      vizKey: [
+        { state: 'CA', year: '2023', city: 'Los Angeles' },
+        { state: 'CA', year: '2023', city: 'San Francisco' },
+        { state: 'CA', year: '2022', city: 'Sacramento' },
+        { state: 'NY', year: '2023', city: 'New York City' },
+        { state: 'TX', year: '2023', city: 'Austin' }
+      ]
+    }
+
     const result = updateChildFilters(filters, data)
 
-    expect(result).toEqual(exprectedResult)
+    // Should only include cities where state=CA AND year=2023
+    expect(result[2].values).toEqual(['Los Angeles', 'San Francisco'])
+    expect(result[2].values).not.toContain('Sacramento') // Different year
+    expect(result[2].values).not.toContain('New York City') // Different state
   })
 })