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.

5.1 KB
Raw Blame
import { InsightQueryNode, NodeKind } from '~/queries/schema/schema-general'
import { BaseMathType, ChartDisplayType, FilterLogicalOperator } from '~/types'

import { ActionNames, ResultSeries, ResultSeriesRow, getResultSeries } from './resultSeries'

describe('getResultSeries()', () => {
    const pageviews = { kind: NodeKind.EventsNode as const, event: '$pageview', name: '$pageview' }
    const signups = { kind: NodeKind.ActionsNode as const, id: 7, name: 'Signed up' }

    const signedUpNames: ActionNames = { '7': 'Signed up' }

    it.each<{
        case: string
        query: InsightQueryNode
        row: ResultSeriesRow
        actionNames?: ActionNames
        expected: ResultSeries
    }>([
        {
            case: 'a formula row to no series, although its order is a valid series index',
            query: {
                kind: NodeKind.TrendsQuery,
                series: [pageviews, signups],
                trendsFilter: { formulaNodes: [{ formula: 'A+B' }, { formula: 'A/B' }] },
            },
            row: { order: 1 },
            expected: { order: 1, node: null, math: null },
        },
        {
            case: 'a calendar heatmap row to series 0, although the query keeps its formulas',
            query: {
                kind: NodeKind.TrendsQuery,
                series: [pageviews, signups],
                trendsFilter: { display: ChartDisplayType.CalendarHeatmap, formulaNodes: [{ formula: 'A+B' }] },
            },
            row: { order: 0 },
            expected: { order: 0, node: pageviews, math: {} },
        },
        {
            case: 'a stickiness row by its order',
            query: { kind: NodeKind.StickinessQuery, series: [pageviews, signups] },
            row: { order: 1 },
            expected: { order: 1, node: signups, math: {} },
        },
        {
            case: 'weekly active users on a weekly interval to the daily math the runner applies',
            query: {
                kind: NodeKind.TrendsQuery,
                interval: 'week',
                series: [{ ...pageviews, math: BaseMathType.WeeklyActiveUsers }],
            },
            row: { order: 0 },
            expected: {
                order: 0,
                node: { ...pageviews, math: BaseMathType.WeeklyActiveUsers },
                math: { math: BaseMathType.UniqueUsers },
            },
        },
        {
            case: 'an events series saved without a name to its event',
            query: { kind: NodeKind.TrendsQuery, series: [{ kind: NodeKind.EventsNode, event: '$autocapture' }] },
            row: { order: 0 },
            expected: {
                order: 0,
                node: { kind: NodeKind.EventsNode, event: '$autocapture', name: '$autocapture' },
                math: {},
            },
        },
        {
            case: 'an action series saved without a name to its name in action_names',
            query: { kind: NodeKind.TrendsQuery, series: [{ kind: NodeKind.ActionsNode, id: 7 }] },
            row: { order: 0 },
            actionNames: signedUpNames,
            expected: { order: 0, node: { kind: NodeKind.ActionsNode, id: 7, name: 'Signed up' }, math: {} },
        },
        {
            case: 'a group series with an action saved without a name to its members, by their names in action_names',
            query: {
                kind: NodeKind.TrendsQuery,
                series: [
                    {
                        kind: NodeKind.GroupNode,
                        operator: FilterLogicalOperator.Or,
                        nodes: [pageviews, { kind: NodeKind.ActionsNode, id: 7 }],
                    },
                ],
            },
            row: { order: 0 },
            actionNames: signedUpNames,
            expected: {
                order: 0,
                node: {
                    kind: NodeKind.GroupNode,
                    operator: FilterLogicalOperator.Or,
                    nodes: [pageviews, { kind: NodeKind.ActionsNode, id: 7 }],
                    name: '$pageview, Signed up',
                },
                math: {},
            },
        },
        {
            case: 'a group series saved without a name to its members, as the runner labels it',
            query: {
                kind: NodeKind.TrendsQuery,
                series: [
                    {
                        kind: NodeKind.GroupNode,
                        operator: FilterLogicalOperator.Or,
                        nodes: [pageviews, { kind: NodeKind.EventsNode, event: '$screen' }],
                    },
                ],
            },
            row: { order: 0 },
            expected: {
                order: 0,
                node: {
                    kind: NodeKind.GroupNode,
                    operator: FilterLogicalOperator.Or,
                    nodes: [pageviews, { kind: NodeKind.EventsNode, event: '$screen' }],
                    name: '$pageview, $screen',
                },
                math: {},
            },
        },
    ])('resolves $case', ({ query, row, actionNames, expected }) => {
        expect(getResultSeries(query, row, actionNames)).toEqual(expected)
    })
})