Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

12.4 KB
Raw Blame
import {
    dropDuplicatesOfOverrides,
    getDateRangeOverrideDisplay,
    getEffectiveFilterOverrides,
} from './insightDetailsFilterOverrides'

const browserChrome = { key: '$browser', value: 'Chrome', type: 'event', operator: 'exact' }
const browserSafari = { key: '$browser', value: 'Safari', type: 'event', operator: 'exact' }
const countryUS = { key: '$country', value: 'US', type: 'event', operator: 'exact' }

describe('InsightDetails', () => {
    describe('getDateRangeOverrideDisplay', () => {
        it.each([
            {
                label: 'backend-resolved tile date includes the replaced dashboard date',
                insightDateRange: { date_from: '-14d' },
                filterOverrideContext: {
                    dashboard: null,
                    tile: { date_from: '-7d' },
                    overridden_dashboard: { date_from: '-30d' },
                },
                filtersOverride: { date_from: '-30d' },
                tileFiltersOverride: { date_from: '-3d' },
                expected: {
                    source: 'tile',
                    dateFrom: '-7d',
                    dateTo: undefined,
                    replaced: { source: 'dashboard', dateFrom: '-30d', dateTo: undefined },
                },
            },
            {
                label: 'tile date beats the insight range when no dashboard date (replaced = insight)',
                insightDateRange: { date_from: '-14d' },
                filtersOverride: undefined,
                tileFiltersOverride: { date_from: '-7d' },
                expected: {
                    source: 'tile',
                    dateFrom: '-7d',
                    dateTo: undefined,
                    replaced: { source: 'insight', dateFrom: '-14d', dateTo: undefined },
                },
            },
            {
                label: 'dashboard date beats the insight range (replaced = insight)',
                insightDateRange: { date_from: '-14d' },
                filtersOverride: { date_from: '-30d' },
                tileFiltersOverride: undefined,
                expected: {
                    source: 'dashboard',
                    dateFrom: '-30d',
                    dateTo: undefined,
                    replaced: { source: 'insight', dateFrom: '-14d', dateTo: undefined },
                },
            },
            {
                label: 'no override when only the insight has a date',
                insightDateRange: { date_from: '-14d' },
                filtersOverride: undefined,
                tileFiltersOverride: undefined,
                expected: null,
            },
            {
                label: 'no replaced value when the overridden layers have no date',
                insightDateRange: undefined,
                filtersOverride: undefined,
                tileFiltersOverride: { date_from: '-7d' },
                expected: { source: 'tile', dateFrom: '-7d', dateTo: undefined, replaced: undefined },
            },
            {
                label: 'replaced dropped when identical to the winning range',
                insightDateRange: { date_from: '-7d' },
                filtersOverride: undefined,
                tileFiltersOverride: { date_from: '-7d' },
                expected: { source: 'tile', dateFrom: '-7d', dateTo: undefined, replaced: undefined },
            },
        ])('$label', ({ insightDateRange, filterOverrideContext, filtersOverride, tileFiltersOverride, expected }) => {
            expect(
                getDateRangeOverrideDisplay(
                    insightDateRange,
                    filterOverrideContext,
                    filtersOverride,
                    tileFiltersOverride
                )
            ).toEqual(expected)
        })
    })

    describe('dropDuplicatesOfOverrides', () => {
        it.each([
            {
                label: 'flat list: exact duplicate of an override is dropped',
                base: [browserChrome, countryUS],
                overrides: [browserChrome],
                expected: [countryUS],
            },
            {
                label: 'flat list: same key with a different value is kept (both genuinely AND)',
                base: [browserChrome, countryUS],
                overrides: [browserSafari],
                expected: [browserChrome, countryUS],
            },
            {
                label: 'flat list: same key+value but different operator is kept (identity includes operator)',
                base: [browserChrome],
                overrides: [{ ...browserChrome, operator: 'is_not' }],
                expected: [browserChrome],
            },
            {
                label: 'scalar and single-element-array values of the same filter are treated as duplicates',
                base: [{ key: '$email', value: '[email protected]', type: 'person', operator: 'exact' }],
                overrides: [{ key: '$email', value: ['[email protected]'], type: 'person', operator: 'exact' }],
                expected: [],
            },
            {
                label: 'multi-value filters in a different order are treated as duplicates (values are a set)',
                base: [{ key: '$browser', value: ['Chrome', 'Safari'], type: 'event', operator: 'exact' }],
                overrides: [{ key: '$browser', value: ['Safari', 'Chrome'], type: 'event', operator: 'exact' }],
                expected: [],
            },
            {
                label: 'no overrides: base returned unchanged',
                base: [browserChrome],
                overrides: [],
                expected: [browserChrome],
            },
        ])('$label', ({ base, overrides, expected }) => {
            expect(dropDuplicatesOfOverrides(base as any, overrides as any)).toEqual(expected)
        })

        it('nested group: dedupes the matching leaf and prunes a subgroup left empty', () => {
            const base = {
                type: 'AND',
                values: [
                    { type: 'AND', values: [browserChrome, countryUS] },
                    { type: 'AND', values: [browserChrome] },
                ],
            }

            const result = dropDuplicatesOfOverrides(base as any, [browserChrome] as any) as any

            // The lone-duplicate subgroup is pruned; the mixed subgroup keeps its non-duplicate leaf.
            expect(result.values).toEqual([{ type: 'AND', values: [countryUS] }])
        })
    })

    describe('getEffectiveFilterOverrides', () => {
        it('renders the backend-resolved filter layers without recalculating conflicts', () => {
            const result = getEffectiveFilterOverrides(
                {
                    dashboard: { properties: [countryUS] } as any,
                    tile: { properties: [browserChrome] } as any,
                    overridden_dashboard: { properties: [browserSafari] } as any,
                },
                { properties: [browserSafari, countryUS] } as any,
                { properties: [browserChrome] } as any
            )

            expect(result.overriddenByTile).toEqual([browserSafari])
            expect(result.propertyGroups).toEqual([
                { properties: [countryUS], source: 'dashboard' },
                { properties: [browserChrome], source: 'tile' },
            ])
        })

        it('falls back to raw layers when no backend context exists', () => {
            const result = getEffectiveFilterOverrides(
                undefined,
                { properties: [countryUS] } as any,
                { properties: [browserChrome] } as any
            )

            expect(result.overriddenByTile).toEqual([])
            expect(result.propertyGroups).toEqual([
                { properties: [countryUS], source: 'dashboard' },
                { properties: [browserChrome], source: 'tile' },
            ])
        })

        it.each([
            {
                label: 'dashboard-only test account override',
                filtersOverride: { filterTestAccounts: true },
                tileFiltersOverride: undefined,
                expected: {
                    filterTestAccounts: { value: true, source: 'dashboard' },
                    interval: null,
                    compareFilter: null,
                },
            },
            {
                label: 'force-off (false) still counts as a test account override',
                filtersOverride: { filterTestAccounts: false },
                tileFiltersOverride: undefined,
                expected: {
                    filterTestAccounts: { value: false, source: 'dashboard' },
                    interval: null,
                    compareFilter: null,
                },
            },
            {
                label: 'dashboard-only interval override',
                filtersOverride: { interval: 'month' },
                tileFiltersOverride: undefined,
                expected: {
                    filterTestAccounts: null,
                    interval: { value: 'month', source: 'dashboard' },
                    compareFilter: null,
                },
            },
            {
                label: 'dashboard-only compare override',
                filtersOverride: { compareFilter: { compare: true, compare_to: '-1m' } },
                tileFiltersOverride: undefined,
                expected: {
                    filterTestAccounts: null,
                    interval: null,
                    compareFilter: { value: { compare: true, compare_to: '-1m' }, source: 'dashboard' },
                },
            },
            {
                label: 'tile scalar overrides beat dashboard ones',
                filtersOverride: { filterTestAccounts: true, interval: 'week', compareFilter: { compare: true } },
                tileFiltersOverride: { filterTestAccounts: false, interval: 'day', compareFilter: { compare: false } },
                expected: {
                    filterTestAccounts: { value: false, source: 'tile' },
                    interval: { value: 'day', source: 'tile' },
                    compareFilter: { value: { compare: false }, source: 'tile' },
                },
            },
            {
                label: 'no scalar overrides set',
                filtersOverride: { properties: [countryUS] },
                tileFiltersOverride: undefined,
                expected: { filterTestAccounts: null, interval: null, compareFilter: null },
            },
        ])('$label', ({ filtersOverride, tileFiltersOverride, expected }) => {
            const result = getEffectiveFilterOverrides(undefined, filtersOverride as any, tileFiltersOverride as any)

            expect(result.filterTestAccounts).toEqual(expected.filterTestAccounts)
            expect(result.interval).toEqual(expected.interval)
            expect(result.compareFilter).toEqual(expected.compareFilter)
        })

        it('resolves scalar overrides from the backend context layers, ignoring raw props', () => {
            const result = getEffectiveFilterOverrides(
                { dashboard: { filterTestAccounts: true, interval: 'week' }, tile: null } as any,
                { filterTestAccounts: false } as any,
                undefined
            )

            expect(result.filterTestAccounts).toEqual({ value: true, source: 'dashboard' })
            expect(result.interval).toEqual({ value: 'week', source: 'dashboard' })
        })

        it('drops the whole dashboard layer when the tile ignores dashboard filters (raw-props fallback)', () => {
            const result = getEffectiveFilterOverrides(
                undefined,
                { properties: [countryUS], filterTestAccounts: true, interval: 'month' } as any,
                { ignoreDashboardFilters: true, properties: [browserChrome] } as any
            )

            expect(result.ignoresDashboardFilters).toBe(true)
            expect(result.propertyGroups).toEqual([{ properties: [browserChrome], source: 'tile' }])
            expect(result.filterTestAccounts).toBeNull()
            expect(result.interval).toBeNull()
        })

        it('reports the ignore flag from the backend context tile layer', () => {
            const result = getEffectiveFilterOverrides(
                {
                    dashboard: null,
                    tile: { ignoreDashboardFilters: true },
                    overridden_dashboard: { filterTestAccounts: true },
                } as any,
                { filterTestAccounts: true } as any,
                undefined
            )

            expect(result.ignoresDashboardFilters).toBe(true)
            expect(result.filterTestAccounts).toBeNull()
        })
    })
})