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.

20.6 KB
Raw Blame
import { buildNotebookNodeClipboardHTML, sortProperties } from './utils'

// Mock dependencies for Group revenue utilities
jest.mock('lib/utils/numbers', () => ({
    ...jest.requireActual('lib/utils/numbers'),
    percentage: jest.fn((value: number) => `${(value * 100).toFixed(1)}%`),
}))

jest.mock('lib/utils/currency', () => ({
    formatCurrency: jest.fn((value: number) => `$${value.toFixed(2)}`),
}))

describe('notebook node utils', () => {
    jest.useFakeTimers()

    describe('buildNotebookNodeClipboardHTML', () => {
        // Reads back an attribute the same way the per-attribute parseHTML in `createPostHogWidgetNode`
        // does, so each round-trip exercises the actual paste path end-to-end.
        function roundTrip(value: unknown): unknown {
            const html = buildNotebookNodeClipboardHTML('ph-test-node', { x: value })
            const parsed = new DOMParser().parseFromString(html, 'text/html')
            const element = parsed.querySelector('ph-test-node')!
            const raw = element.getAttribute('x')
            return raw === null ? null : JSON.parse(raw)
        }

        it('uses the given tag name', () => {
            const html = buildNotebookNodeClipboardHTML('ph-query-node', {})
            expect(html.startsWith('<ph-query-node')).toBe(true)
            expect(html.endsWith('</ph-query-node>')).toBe(true)
        })

        it('always includes the ProseMirror slice marker', () => {
            const html = buildNotebookNodeClipboardHTML('ph-query-node', {})
            expect(html).toContain('data-pm-slice="0 0 []"')
        })

        it('skips nodeId so paste does not duplicate IDs', () => {
            const html = buildNotebookNodeClipboardHTML('ph-query-node', { nodeId: 'abc-123', kind: 'X' })
            expect(html).not.toContain('abc-123')
            expect(html).toContain('kind=')
        })

        it('skips internal __-prefixed keys', () => {
            const html = buildNotebookNodeClipboardHTML('ph-query-node', {
                __init: true,
                __anything: 'private',
                kind: 'X',
            })
            expect(html).not.toContain('__init')
            expect(html).not.toContain('__anything')
            expect(html).toContain('kind=')
        })

        it('skips null and undefined values', () => {
            const html = buildNotebookNodeClipboardHTML('ph-query-node', {
                absent: null,
                missing: undefined,
                kind: 'X',
            })
            expect(html).not.toContain('absent')
            expect(html).not.toContain('missing')
            expect(html).toContain('kind=')
        })

        it.each([
            ['object', { kind: 'DataTableNode', source: { kind: 'HogQLQuery' } }],
            ['nested object', { a: { b: { c: 'deep' } } }],
            ['array', [1, 2, 3]],
            ['array of objects', [{ id: 1 }, { id: 2 }]],
            ['string', 'print(1)'],
            ['empty string', ''],
            ['number', 42],
            ['zero', 0],
            ['negative number', -7.5],
            ['boolean true', true],
            ['boolean false', false],
            ['string with apostrophe', "don't"],
            ['string with double quotes', 'say "hi"'],
            ['string with both quotes', `it's "fine"`],
            ['string with angle brackets', '<div>x</div>'],
            ['string with ampersand', 'a & b'],
        ])('round-trips %s through copy and paste', (_label, value) => {
            expect(roundTrip(value)).toEqual(value)
        })

        it('produces HTML that a DOMParser parses without errors', () => {
            const html = buildNotebookNodeClipboardHTML('ph-query-node', {
                query: { kind: 'X', source: { value: 'it\'s "tricky"' } },
                count: 5,
            })
            const doc = new DOMParser().parseFromString(html, 'text/html')
            expect(doc.querySelector('parsererror')).toBeNull()
            expect(doc.querySelector('ph-query-node')).not.toBeNull()
        })
    })

    describe('sortProperties', () => {
        describe('pinned properties take priority', () => {
            it('should place pinned properties before non-pinned ones', () => {
                const entries: [string, any][] = [
                    ['name', 'John'],
                    ['email', '[email protected]'],
                    ['age', 25],
                ]
                const pinnedProperties = ['email']

                const result = sortProperties(entries, pinnedProperties)

                expect(result).toEqual([
                    ['email', '[email protected]'],
                    ['age', 25],
                    ['name', 'John'],
                ])
            })

            it('should maintain pinned properties in their specified order', () => {
                const entries: [string, any][] = [
                    ['name', 'John'],
                    ['email', '[email protected]'],
                    ['userId', '123'],
                    ['timestamp', '2023-01-01'],
                ]
                const pinnedProperties = ['userId', 'email', 'name']

                const result = sortProperties(entries, pinnedProperties)

                expect(result).toEqual([
                    ['userId', '123'],
                    ['email', '[email protected]'],
                    ['name', 'John'],
                    ['timestamp', '2023-01-01'],
                ])
            })

            it('should sort non-pinned properties alphabetically after pinned ones', () => {
                const entries: [string, any][] = [
                    ['zebra', 'value1'],
                    ['apple', 'value2'],
                    ['priority', 'value3'],
                    ['banana', 'value4'],
                ]
                const pinnedProperties = ['priority']

                const result = sortProperties(entries, pinnedProperties)

                expect(result).toEqual([
                    ['priority', 'value3'],
                    ['apple', 'value2'],
                    ['banana', 'value4'],
                    ['zebra', 'value1'],
                ])
            })
        })

        describe('alphabetical sorting for non-pinned properties', () => {
            it('should sort all properties alphabetically when none are pinned', () => {
                const entries: [string, any][] = [
                    ['zebra', 'last'],
                    ['apple', 'first'],
                    ['middle', 'second'],
                    ['banana', 'third'],
                ]

                const result = sortProperties(entries, [])

                expect(result).toEqual([
                    ['apple', 'first'],
                    ['banana', 'third'],
                    ['middle', 'second'],
                    ['zebra', 'last'],
                ])
            })

            it('should handle case sensitivity in alphabetical sorting', () => {
                const entries: [string, any][] = [
                    ['Apple', 'capital'],
                    ['apple', 'lowercase'],
                    ['Zebra', 'capital-z'],
                ]

                const result = sortProperties(entries, [])

                expect(result).toEqual([
                    ['apple', 'lowercase'],
                    ['Apple', 'capital'],
                    ['Zebra', 'capital-z'],
                ])
            })

            it('should handle special characters properly', () => {
                const entries: [string, any][] = [
                    ['normal', 'regular'],
                    ['$special', 'dollar'],
                    ['_underscore', 'underscore'],
                    ['regular', 'alphabetic'],
                ]

                const result = sortProperties(entries, [])

                expect(result).toEqual([
                    ['_underscore', 'underscore'],
                    ['$special', 'dollar'],
                    ['normal', 'regular'],
                    ['regular', 'alphabetic'],
                ])
            })
        })

        describe('edge cases', () => {
            it('should handle empty entries array', () => {
                const result = sortProperties([], ['some', 'pinned'])
                expect(result).toEqual([])
            })

            it('should handle empty pinned properties', () => {
                const entries: [string, any][] = [
                    ['zebra', 'last'],
                    ['apple', 'first'],
                ]

                const result = sortProperties(entries, [])

                expect(result).toEqual([
                    ['apple', 'first'],
                    ['zebra', 'last'],
                ])
            })

            it('should handle properties not in pinned array', () => {
                const entries: [string, any][] = [
                    ['notPinned1', 'value1'],
                    ['notPinned2', 'value2'],
                ]
                const pinnedProperties = ['somethingElse']

                const result = sortProperties(entries, pinnedProperties)

                expect(result).toEqual([
                    ['notPinned1', 'value1'],
                    ['notPinned2', 'value2'],
                ])
            })

            it('should handle duplicate property names gracefully', () => {
                const entries: [string, any][] = [
                    ['same', 'value1'],
                    ['same', 'value2'],
                ]

                const result = sortProperties(entries, [])

                expect(result).toEqual([
                    ['same', 'value1'],
                    ['same', 'value2'],
                ])
            })
        })

        describe('real-world scenarios', () => {
            it('should sort PostHog event properties correctly', () => {
                const entries: [string, any][] = [
                    ['timestamp', '2023-01-01T10:00:00Z'],
                    ['$current_url', 'https://example.com'],
                    ['name', 'Button Click'],
                    ['$browser', 'Chrome'],
                    ['user_id', '12345'],
                ]
                const pinnedProperties = ['$current_url', '$browser']

                const result = sortProperties(entries, pinnedProperties)

                expect(result).toEqual([
                    ['$current_url', 'https://example.com'],
                    ['$browser', 'Chrome'],
                    ['name', 'Button Click'],
                    ['timestamp', '2023-01-01T10:00:00Z'],
                    ['user_id', '12345'],
                ])
            })

            it('should handle complex pinned order with many properties', () => {
                const entries: [string, any][] = [
                    ['prop5', 'value5'],
                    ['prop1', 'value1'],
                    ['unpinned', 'valueX'],
                    ['prop3', 'value3'],
                    ['another', 'valueY'],
                ]
                const pinnedProperties = ['prop1', 'prop2', 'prop3', 'prop4', 'prop5']

                const result = sortProperties(entries, pinnedProperties)

                expect(result).toEqual([
                    ['prop1', 'value1'],
                    ['prop3', 'value3'],
                    ['prop5', 'value5'],
                    ['another', 'valueY'],
                    ['unpinned', 'valueX'],
                ])
            })
        })
    })

    describe('Group revenue utilities', () => {
        const baseGroupData = {
            created_at: '2024-01-15T10:00:00Z',
            group_key: 'test-key',
            group_type_index: 0,
            group_properties: {},
            notebook: null,
        }

        describe('calculateMRRData', () => {
            test.each([
                {
                    name: 'returns null when mrr is missing',
                    group: baseGroupData,
                    expected: null,
                },
                {
                    name: 'returns null when mrr is null',
                    group: { ...baseGroupData, group_properties: { mrr: null } },
                    expected: null,
                },
                {
                    name: 'returns null when mrr is NaN',
                    group: { ...baseGroupData, group_properties: { mrr: 'not a number' } },
                    expected: null,
                },
                {
                    name: 'returns zero when mrr is zero',
                    group: { ...baseGroupData, group_properties: { mrr: 0 } },
                    expected: {
                        mrr: 0,
                        forecastedMrr: null,
                        percentageDiff: null,
                        tooltipText: null,
                        trendDirection: null,
                    },
                },
                {
                    name: 'returns data without forecast',
                    group: { ...baseGroupData, group_properties: { mrr: 1000 } },
                    expected: {
                        mrr: 1000,
                        forecastedMrr: null,
                        percentageDiff: null,
                        tooltipText: null,
                        trendDirection: null,
                    },
                },
                {
                    name: 'calculates positive trend',
                    group: { ...baseGroupData, group_properties: { mrr: 1000, forecasted_mrr: 1200 } },
                    expected: {
                        mrr: 1000,
                        forecastedMrr: 1200,
                        percentageDiff: 0.2,
                        tooltipText: '20.0% MRR growth forecasted to $1200.00',
                        trendDirection: 'up',
                    },
                },
                {
                    name: 'calculates negative trend',
                    group: { ...baseGroupData, group_properties: { mrr: 1000, forecasted_mrr: 800 } },
                    expected: {
                        mrr: 1000,
                        forecastedMrr: 800,
                        percentageDiff: -0.2,
                        tooltipText: '20.0% MRR decrease forecasted to $800.00',
                        trendDirection: 'down',
                    },
                },
                {
                    name: 'calculates flat trend',
                    group: { ...baseGroupData, group_properties: { mrr: 1000, forecasted_mrr: 1000 } },
                    expected: {
                        mrr: 1000,
                        forecastedMrr: 1000,
                        percentageDiff: 0,
                        tooltipText: 'No MRR change forecasted, flat at $1000.00',
                        trendDirection: 'flat',
                    },
                },
                {
                    name: 'handles negative MRR',
                    group: { ...baseGroupData, group_properties: { mrr: -100 } },
                    expected: {
                        mrr: -100,
                        forecastedMrr: null,
                        percentageDiff: null,
                        tooltipText: null,
                        trendDirection: null,
                    },
                },
            ])('$name', ({ group, expected }) => {
                const { calculateMRRData } = require('./utils')
                const result = calculateMRRData(group, 'USD')
                expect(result).toEqual(expected)
            })
        })

        describe('getPaidProducts', () => {
            test.each([
                {
                    name: 'returns empty array when mrr_per_product is missing',
                    group: baseGroupData,
                    expected: [],
                },
                {
                    name: 'returns empty array when mrr_per_product is empty',
                    group: { ...baseGroupData, group_properties: { mrr_per_product: {} } },
                    expected: [],
                },
                {
                    name: 'returns empty array when all products have zero MRR',
                    group: {
                        ...baseGroupData,
                        group_properties: { mrr_per_product: { product_a: 0, product_b: 0 } },
                    },
                    expected: [],
                },
                {
                    name: 'returns single formatted product',
                    group: {
                        ...baseGroupData,
                        group_properties: { mrr_per_product: { product_analytics: 100 } },
                    },
                    expected: ['Product analytics'],
                },
                {
                    name: 'returns multiple formatted products',
                    group: {
                        ...baseGroupData,
                        group_properties: {
                            mrr_per_product: { product_analytics: 100, feature_flags: 200, session_replay: 150 },
                        },
                    },
                    expected: ['Product analytics', 'Feature flags', 'Session replay'],
                },
                {
                    name: 'filters out zero MRR products and formats names',
                    group: {
                        ...baseGroupData,
                        group_properties: {
                            mrr_per_product: { product_analytics: 100, feature_flags: 0, session_replay: 150 },
                        },
                    },
                    expected: ['Product analytics', 'Session replay'],
                },
                {
                    name: 'filters out negative MRR products and formats names',
                    group: {
                        ...baseGroupData,
                        group_properties: { mrr_per_product: { product_a: -100, product_b: 200 } },
                    },
                    expected: ['Product b'],
                },
                {
                    name: 'formats complex product names with underscores',
                    group: {
                        ...baseGroupData,
                        group_properties: { mrr_per_product: { data_warehouse_analytics: 500 } },
                    },
                    expected: ['Data warehouse analytics'],
                },
                {
                    name: 'formats single word product names',
                    group: {
                        ...baseGroupData,
                        group_properties: { mrr_per_product: { experiments: 300 } },
                    },
                    expected: ['Experiments'],
                },
                {
                    name: 'filters out products with invalid MRR values',
                    group: {
                        ...baseGroupData,
                        group_properties: { mrr_per_product: { valid_product: 100, invalid_product: 'not_a_number' } },
                    },
                    expected: ['Valid product'],
                },
            ])('$name', ({ group, expected }) => {
                const { getPaidProducts } = require('./utils')
                const result = getPaidProducts(group)
                expect(result).toEqual(expected)
            })
        })

        describe('getLifetimeValue', () => {
            test.each([
                {
                    name: 'returns null when customer_lifetime_value is missing',
                    group: baseGroupData,
                    expected: null,
                },
                {
                    name: 'returns null when customer_lifetime_value is null',
                    group: { ...baseGroupData, group_properties: { customer_lifetime_value: null } },
                    expected: null,
                },
                {
                    name: 'returns null when customer_lifetime_value is not a number',
                    group: { ...baseGroupData, group_properties: { customer_lifetime_value: 'invalid' } },
                    expected: null,
                },
                {
                    name: 'returns lifetime value when present',
                    group: { ...baseGroupData, group_properties: { customer_lifetime_value: 5000 } },
                    expected: 5000,
                },
                {
                    name: 'returns zero when customer_lifetime_value is zero',
                    group: { ...baseGroupData, group_properties: { customer_lifetime_value: 0 } },
                    expected: 0,
                },
                {
                    name: 'returns negative value when customer_lifetime_value is negative',
                    group: { ...baseGroupData, group_properties: { customer_lifetime_value: -100 } },
                    expected: -100,
                },
            ])('$name', ({ group, expected }) => {
                const { getLifetimeValue } = require('./utils')
                expect(getLifetimeValue(group)).toBe(expected)
            })
        })
    })
})