: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
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)
})
})
})
})