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.

37.0 KB
Raw Blame
import { NoSuchKey, S3Client } from '@aws-sdk/client-s3'
import { ClickHouseClient } from '@clickhouse/client'
import sodium from 'libsodium-wrappers'
import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import snappy from 'snappy'

import { PostgresRouter } from '~/common/utils/db/postgres'
import * as envUtils from '~/common/utils/env-utils'
import { SodiumRecordingDecryptor, SodiumRecordingEncryptor } from '~/ingestion/pipelines/sessionreplay/shared/crypto'
import { SessionFeatureStore } from '~/ingestion/pipelines/sessionreplay/shared/features/session-feature-store'
import { SessionMetadataStore } from '~/ingestion/pipelines/sessionreplay/shared/metadata/session-metadata-store'
import { SessionKey } from '~/ingestion/pipelines/sessionreplay/shared/types'

import { ClickHouseCredential } from './clickhouse-credential'
import { RecordingService } from './recording-service'
import { KeyStore, RecordingDecryptor, SessionKeyDeletedError } from './types'

describe('RecordingService', () => {
    let service: RecordingService
    let mockS3Send: jest.Mock
    let mockS3Client: S3Client
    let mockKeyStore: jest.Mocked<KeyStore>
    let mockDecryptor: jest.Mocked<RecordingDecryptor>
    let mockMetadataStore: jest.Mocked<SessionMetadataStore>
    let mockFeatureStore: jest.Mocked<SessionFeatureStore>
    let mockPostgres: jest.Mocked<PostgresRouter>
    let mockClickhouse: jest.Mocked<ClickHouseClient>

    beforeEach(() => {
        mockS3Send = jest.fn()
        mockS3Client = {
            send: mockS3Send,
        } as unknown as S3Client

        mockKeyStore = {
            start: jest.fn(),
            generateKey: jest.fn(),
            getKey: jest.fn(),
            deleteKey: jest.fn(),
            stop: jest.fn(),
        } as unknown as jest.Mocked<KeyStore>

        mockDecryptor = {
            start: jest.fn(),
            decryptBlock: jest.fn(),
            decryptBlockWithKey: jest.fn(),
        } as unknown as jest.Mocked<RecordingDecryptor>

        mockMetadataStore = {
            storeSessionBlocks: jest.fn().mockResolvedValue(undefined),
        } as unknown as jest.Mocked<SessionMetadataStore>

        mockFeatureStore = {
            storeSessionFeatures: jest.fn().mockResolvedValue(undefined),
            storeDeletionMarkers: jest.fn().mockResolvedValue(undefined),
        } as unknown as jest.Mocked<SessionFeatureStore>

        mockPostgres = {
            query: jest.fn().mockResolvedValue({ rows: [] }),
        } as unknown as jest.Mocked<PostgresRouter>

        mockClickhouse = {
            query: jest.fn(),
        } as unknown as jest.Mocked<ClickHouseClient>

        service = new RecordingService(
            mockS3Client,
            'test-bucket',
            'session_recordings',
            mockKeyStore,
            mockDecryptor,
            mockMetadataStore,
            mockFeatureStore,
            mockPostgres,
            { client: mockClickhouse, credential: new ClickHouseCredential('recording_api', 'static', '') },
            new SodiumRecordingEncryptor(mockKeyStore)
        )
    })

    afterEach(() => {
        jest.clearAllMocks()
    })

    describe('validateS3Key', () => {
        it.each([
            ['session_recordings/30d/1764634738680-3cca0f5d3c7cc7ee', true],
            ['session_recordings/90d/1764634738680-abcdef0123456789', true],
            ['session_recordings/1y/1764634738680-0000000000000000', true],
            ['session_recordings/5y/1764634738680-ffffffffffffffff', true],
            ['../etc/passwd', false],
            ['other_prefix/30d/123-abcdef0123456789', false],
            ['session_recordings/7d/123-abcdef0123456789', false],
            ['session_recordings/30d/file', false],
            ['session_recordings/30d/123', false],
            ['session_recordings/30d/123-abc', false],
            ['session_recordings/30d/123-abcdef012345678z', false],
            ['session_recordings/30d/-abcdef0123456789', false],
        ])('validates key "%s" as %s', (key, expected) => {
            expect(service.validateS3Key(key)).toBe(expected)
        })
    })

    describe('formatS3KeyError', () => {
        it('returns formatted error message', () => {
            const error = service.formatS3KeyError()

            expect(error).toContain('session_recordings')
            expect(error).toContain('30d')
            expect(error).toContain('90d')
            expect(error).toContain('1y')
            expect(error).toContain('5y')
        })
    })

    describe('getBlock', () => {
        const validParams = {
            sessionId: 'session-123',
            teamId: 1,
            key: 'session_recordings/30d/1764634738680-3cca0f5d3c7cc7ee',
            startByte: 0,
            endByte: 100,
        }

        it('returns decrypted data on success', async () => {
            const mockBody = {
                transformToByteArray: jest.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
            }
            mockS3Send.mockResolvedValue({ Body: mockBody })
            mockDecryptor.decryptBlock.mockResolvedValue({
                data: Buffer.from('decrypted data'),
                sessionState: 'ciphertext',
            })

            const result = await service.getBlock(validParams)

            expect(result).toEqual({ ok: true, data: Buffer.from('decrypted data') })
            expect(mockDecryptor.decryptBlock).toHaveBeenCalledWith('session-123', 1, expect.any(Buffer))
        })

        it('returns decompressed data when decompress is true', async () => {
            const originalData = '{"type": 3, "data": {}}'
            const compressed = await snappy.compress(Buffer.from(originalData))
            const mockBody = {
                transformToByteArray: jest.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
            }
            mockS3Send.mockResolvedValue({ Body: mockBody })
            mockDecryptor.decryptBlock.mockResolvedValue({
                data: Buffer.from(compressed),
                sessionState: 'ciphertext',
            })

            const result = await service.getBlock({ ...validParams, decompress: true })

            expect(result).toEqual({ ok: true, data: Buffer.from(originalData) })
        })

        it('returns not_found when S3 returns no body', async () => {
            mockS3Send.mockResolvedValue({ Body: null })

            const result = await service.getBlock(validParams)

            expect(result).toEqual({ ok: false, error: 'not_found' })
        })

        it('returns deleted with timestamp when session key was deleted', async () => {
            const mockBody = {
                transformToByteArray: jest.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
            }
            mockS3Send.mockResolvedValue({ Body: mockBody })
            mockDecryptor.decryptBlock.mockRejectedValue(new SessionKeyDeletedError('session-123', 1, 1700000000))

            const result = await service.getBlock(validParams)

            expect(result).toEqual({ ok: false, error: 'deleted', deletedAt: 1700000000, deletedBy: '' })
        })

        it('returns deleted with undefined timestamp when not available', async () => {
            const mockBody = {
                transformToByteArray: jest.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
            }
            mockS3Send.mockResolvedValue({ Body: mockBody })
            mockDecryptor.decryptBlock.mockRejectedValue(new SessionKeyDeletedError('session-123', 1, undefined))

            const result = await service.getBlock(validParams)

            expect(result).toEqual({ ok: false, error: 'deleted', deletedAt: undefined, deletedBy: '' })
        })

        it('returns not_found when S3 throws NoSuchKey', async () => {
            mockS3Send.mockRejectedValue(new NoSuchKey({ message: 'The specified key does not exist.', $metadata: {} }))

            const result = await service.getBlock(validParams)

            expect(result).toEqual({ ok: false, error: 'not_found' })
        })

        it('propagates unexpected S3 errors', async () => {
            mockS3Send.mockRejectedValue(new Error('S3 network error'))

            await expect(service.getBlock(validParams)).rejects.toThrow('S3 network error')
        })

        it('propagates unexpected decryption errors', async () => {
            const mockBody = {
                transformToByteArray: jest.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
            }
            mockS3Send.mockResolvedValue({ Body: mockBody })
            mockDecryptor.decryptBlock.mockRejectedValue(new Error('crypto: bad nonce'))

            await expect(service.getBlock(validParams)).rejects.toThrow('crypto: bad nonce')
        })

        it('calls S3 with correct parameters', async () => {
            const mockBody = {
                transformToByteArray: jest.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
            }
            mockS3Send.mockResolvedValue({ Body: mockBody })
            mockDecryptor.decryptBlock.mockResolvedValue({ data: Buffer.from('data'), sessionState: 'ciphertext' })

            await service.getBlock(validParams)

            expect(mockS3Send).toHaveBeenCalledWith(
                expect.objectContaining({
                    input: {
                        Bucket: 'test-bucket',
                        Key: 'session_recordings/30d/1764634738680-3cca0f5d3c7cc7ee',
                        Range: 'bytes=0-100',
                    },
                })
            )
        })
    })

    describe('parseBlockUrl', () => {
        it.each([
            [
                's3://posthog/session_recordings/30d/1000-abc123?range=bytes=0-5000',
                { key: 'session_recordings/30d/1000-abc123', start_byte: 0, end_byte: 5000 },
            ],
            [
                's3://bucket/session_recordings/90d/2000-def456?range=bytes=100-6000',
                { key: 'session_recordings/90d/2000-def456', start_byte: 100, end_byte: 6000 },
            ],
        ])('parses "%s"', (url, expected) => {
            expect(RecordingService.parseBlockUrl(url)).toEqual(expected)
        })

        it.each([
            ['s3://posthog/key?no-range', 'missing range'],
            ['not-a-url', 'invalid URL'],
        ])('returns null for invalid URL: %s', (url) => {
            expect(RecordingService.parseBlockUrl(url)).toBeNull()
        })
    })

    describe('buildBlockList', () => {
        it('returns sorted blocks when arrays match and first block matches start_time', () => {
            const row = {
                start_time: '2024-01-01 00:00:00.000000',
                block_first_timestamps: ['2024-01-01 00:00:00.000000', '2024-01-01 00:01:00.000000'],
                block_last_timestamps: ['2024-01-01 00:00:59.000000', '2024-01-01 00:01:59.000000'],
                block_urls: [
                    's3://b/session_recordings/30d/1000-aaa?range=bytes=0-100',
                    's3://b/session_recordings/30d/2000-bbb?range=bytes=0-200',
                ],
            }

            const blocks = RecordingService.buildBlockList('sess-1', 1, row)

            expect(blocks).toEqual([
                {
                    key: 'session_recordings/30d/1000-aaa',
                    start_byte: 0,
                    end_byte: 100,
                    start_timestamp: '2024-01-01 00:00:00.000000',
                    end_timestamp: '2024-01-01 00:00:59.000000',
                },
                {
                    key: 'session_recordings/30d/2000-bbb',
                    start_byte: 0,
                    end_byte: 200,
                    start_timestamp: '2024-01-01 00:01:00.000000',
                    end_timestamp: '2024-01-01 00:01:59.000000',
                },
            ])
        })

        it('sorts blocks by start timestamp', () => {
            const row = {
                start_time: '2024-01-01 00:00:00.000000',
                block_first_timestamps: ['2024-01-01 00:01:00.000000', '2024-01-01 00:00:00.000000'],
                block_last_timestamps: ['2024-01-01 00:01:59.000000', '2024-01-01 00:00:59.000000'],
                block_urls: [
                    's3://b/session_recordings/30d/2000-bbb?range=bytes=0-200',
                    's3://b/session_recordings/30d/1000-aaa?range=bytes=0-100',
                ],
            }

            const blocks = RecordingService.buildBlockList('sess-1', 1, row)

            expect(blocks[0]).toEqual({
                key: 'session_recordings/30d/1000-aaa',
                start_byte: 0,
                end_byte: 100,
                start_timestamp: '2024-01-01 00:00:00.000000',
                end_timestamp: '2024-01-01 00:00:59.000000',
            })
            expect(blocks[1]).toEqual({
                key: 'session_recordings/30d/2000-bbb',
                start_byte: 0,
                end_byte: 200,
                start_timestamp: '2024-01-01 00:01:00.000000',
                end_timestamp: '2024-01-01 00:01:59.000000',
            })
        })

        it('returns empty when first block start_time does not match recording start_time', () => {
            const row = {
                start_time: '2024-01-01 00:00:00.000000',
                block_first_timestamps: ['2024-01-01 00:01:00.000000'],
                block_last_timestamps: ['2024-01-01 00:01:59.000000'],
                block_urls: ['s3://b/session_recordings/30d/2000-bbb?range=bytes=0-200'],
            }

            expect(RecordingService.buildBlockList('sess-1', 1, row)).toEqual([])
        })

        it('returns empty when array lengths do not match', () => {
            const row = {
                start_time: '2024-01-01 00:00:00.000000',
                block_first_timestamps: ['2024-01-01 00:00:00.000000'],
                block_last_timestamps: ['2024-01-01 00:00:59.000000', '2024-01-01 00:01:59.000000'],
                block_urls: ['s3://b/session_recordings/30d/1000-aaa?range=bytes=0-100'],
            }

            expect(RecordingService.buildBlockList('sess-1', 1, row)).toEqual([])
        })

        it('returns empty when arrays are empty', () => {
            const row = {
                start_time: '2024-01-01 00:00:00.000000',
                block_first_timestamps: [],
                block_last_timestamps: [],
                block_urls: [],
            }

            expect(RecordingService.buildBlockList('sess-1', 1, row)).toEqual([])
        })

        it('skips blocks with unparseable URLs', () => {
            const row = {
                start_time: '2024-01-01 00:00:00.000000',
                block_first_timestamps: ['2024-01-01 00:00:00.000000', '2024-01-01 00:01:00.000000'],
                block_last_timestamps: ['2024-01-01 00:00:59.000000', '2024-01-01 00:01:59.000000'],
                block_urls: ['s3://b/session_recordings/30d/1000-aaa?range=bytes=0-100', 'not-a-url'],
            }

            const blocks = RecordingService.buildBlockList('sess-1', 1, row)

            expect(blocks).toEqual([
                {
                    key: 'session_recordings/30d/1000-aaa',
                    start_byte: 0,
                    end_byte: 100,
                    start_timestamp: '2024-01-01 00:00:00.000000',
                    end_timestamp: '2024-01-01 00:00:59.000000',
                },
            ])
        })
    })

    describe('block refs', () => {
        const sessionKey = (sessionState: 'ciphertext' | 'cleartext' | 'deleted'): SessionKey => ({
            plaintextKey: Buffer.alloc(32, 7),
            encryptedKey: Buffer.alloc(0),
            sessionState,
        })
        const block = {
            key: 'session_recordings/30d/1764634738680-3cca0f5d3c7cc7ee',
            start_byte: 100,
            end_byte: 250,
            start_timestamp: '2024-01-01T00:00:00Z',
            end_timestamp: '2024-01-01T00:01:00Z',
        }

        beforeAll(async () => {
            await sodium.ready
        })

        it('reports a shredded key in place of the blocks', async () => {
            mockKeyStore.getKey.mockResolvedValue({
                ...sessionKey('deleted'),
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })

            expect(await service.annotateBlocks('sess-1', 1, [block])).toEqual({
                ok: false,
                error: 'deleted',
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })
        })

        it('gives a pre-encryption recording no refs', async () => {
            mockKeyStore.getKey.mockResolvedValue(sessionKey('cleartext'))

            expect(await service.annotateBlocks('sess-1', 1, [block])).toEqual([block])
            expect(mockKeyStore.getKey).toHaveBeenCalledWith('sess-1', 1)
        })

        it('fetches the byte range a listed ref names', async () => {
            mockKeyStore.getKey.mockResolvedValue(sessionKey('ciphertext'))
            const [listed] = (await service.annotateBlocks('sess-1', 1, [block])) as { ref: string }[]
            mockS3Send.mockResolvedValue({
                Body: { transformToByteArray: jest.fn().mockResolvedValue(new Uint8Array([1])) },
            })
            mockDecryptor.decryptBlockWithKey = jest
                .fn()
                .mockReturnValue({ data: Buffer.from('data'), sessionState: 'ciphertext' })
            mockKeyStore.getKey.mockClear()

            const result = await service.getBlockByRef(1, 'sess-1', listed.ref)

            expect(result).toEqual({ ok: true, data: Buffer.from('data') })
            expect(mockKeyStore.getKey).toHaveBeenCalledTimes(1)
            expect(mockKeyStore.getKey).toHaveBeenCalledWith('sess-1', 1)
            expect(mockDecryptor.decryptBlock).not.toHaveBeenCalled()
            expect(mockS3Send).toHaveBeenCalledWith(
                expect.objectContaining({ input: { Bucket: 'test-bucket', Key: block.key, Range: 'bytes=100-250' } })
            )
        })

        it.each([
            ['a deleted session', 'deleted', 'deleted'],
            ['a pre-encryption session', 'cleartext', 'not_found'],
        ] as const)('serves no block by ref for %s', async (_, sessionState, expectedError) => {
            mockKeyStore.getKey.mockResolvedValue(sessionKey('ciphertext'))
            const [listed] = (await service.annotateBlocks('sess-1', 1, [block])) as { ref: string }[]
            mockKeyStore.getKey.mockResolvedValue(sessionKey(sessionState))

            const result = await service.getBlockByRef(1, 'sess-1', listed.ref)

            expect(result).toMatchObject({ ok: false, error: expectedError })
            expect(mockS3Send).not.toHaveBeenCalled()
        })
    })

    describe('listBlocks', () => {
        function mockClickhouseResult(rows: any[]): void {
            mockClickhouse.query.mockResolvedValue({
                json: jest.fn().mockResolvedValue(rows),
            } as any)
        }

        it('returns parsed blocks from ClickHouse result', async () => {
            mockClickhouseResult([
                {
                    start_time: '2024-01-01 00:00:00.000000',
                    block_first_timestamps: ['2024-01-01 00:00:00.000000', '2024-01-01 00:01:00.000000'],
                    block_last_timestamps: ['2024-01-01 00:00:59.000000', '2024-01-01 00:01:59.000000'],
                    block_urls: [
                        's3://b/session_recordings/30d/1000-aaa?range=bytes=0-100',
                        's3://b/session_recordings/30d/2000-bbb?range=bytes=0-200',
                    ],
                },
            ])

            const blocks = await service.listBlocks('sess-1', 1)

            expect(blocks).toEqual([
                {
                    key: 'session_recordings/30d/1000-aaa',
                    start_byte: 0,
                    end_byte: 100,
                    start_timestamp: '2024-01-01 00:00:00.000000',
                    end_timestamp: '2024-01-01 00:00:59.000000',
                },
                {
                    key: 'session_recordings/30d/2000-bbb',
                    start_byte: 0,
                    end_byte: 200,
                    start_timestamp: '2024-01-01 00:01:00.000000',
                    end_timestamp: '2024-01-01 00:01:59.000000',
                },
            ])
            expect(mockClickhouse.query).toHaveBeenCalledWith(
                expect.objectContaining({
                    query_params: { team_id: 1, session_id: 'sess-1' },
                    format: 'JSONEachRow',
                    clickhouse_settings: expect.objectContaining({
                        date_time_output_format: 'iso',
                        log_comment: expect.stringContaining('"team_id":1'),
                        max_execution_time: 30,
                        max_threads: 45,
                        max_bytes_to_read: '10000000000',
                    }),
                })
            )
        })

        it('returns empty array when ClickHouse returns no rows', async () => {
            mockClickhouseResult([])

            const blocks = await service.listBlocks('sess-1', 1)

            expect(blocks).toEqual([])
        })

        it('throws when ClickHouse client is not initialized', async () => {
            const serviceWithoutCH = new RecordingService(
                mockS3Client,
                'test-bucket',
                'session_recordings',
                mockKeyStore,
                mockDecryptor
            )

            await expect(serviceWithoutCH.listBlocks('sess-1', 1)).rejects.toThrow('ClickHouse client not initialized')
        })

        it('propagates ClickHouse query errors', async () => {
            mockClickhouse.query.mockRejectedValue(new Error('Connection refused'))

            await expect(service.listBlocks('sess-1', 1)).rejects.toThrow('Connection refused')
        })

        it('sends the token file contents as they are when each query runs', async () => {
            const dir = mkdtempSync(join(tmpdir(), 'recording-service-'))
            try {
                const tokenFile = join(dir, 'token')
                const serviceWithToken = new RecordingService(
                    mockS3Client,
                    'test-bucket',
                    'session_recordings',
                    mockKeyStore,
                    mockDecryptor,
                    mockMetadataStore,
                    mockFeatureStore,
                    mockPostgres,
                    {
                        client: mockClickhouse,
                        credential: new ClickHouseCredential('recording_api', 'static', tokenFile),
                    }
                )
                mockClickhouseResult([])

                for (const token of ['first-token', 'rotated-token']) {
                    writeFileSync(tokenFile, token)
                    await serviceWithToken.listBlocks('sess-1', 1)
                    expect(mockClickhouse.query).toHaveBeenLastCalledWith(
                        expect.objectContaining({ auth: { username: 'recording_api', password: token } })
                    )
                }
            } finally {
                rmSync(dir, { recursive: true, force: true })
            }
        })
    })

    describe('deleteRecordings', () => {
        it('returns empty array when no session IDs provided', async () => {
            const result = await service.deleteRecordings([], 1, '[email protected]')

            expect(result).toEqual([])
            expect(mockKeyStore.deleteKey).not.toHaveBeenCalled()
            expect(mockPostgres.query).not.toHaveBeenCalled()
        })

        it('returns ok for all when all succeed', async () => {
            mockKeyStore.deleteKey.mockResolvedValue({
                status: 'deleted',
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })

            const result = await service.deleteRecordings(['session-1', 'session-2'], 1, '[email protected]')

            expect(result).toEqual([
                {
                    sessionId: 'session-1',
                    ok: true,
                    status: 'deleted',
                    deletedAt: 1700000000,
                    deletedBy: '[email protected]',
                },
                {
                    sessionId: 'session-2',
                    ok: true,
                    status: 'deleted',
                    deletedAt: 1700000000,
                    deletedBy: '[email protected]',
                },
            ])
        })

        it('emits kafka events for newly deleted sessions only', async () => {
            mockKeyStore.deleteKey
                .mockResolvedValueOnce({ status: 'deleted', deletedAt: 1700000000, deletedBy: '[email protected]' })
                .mockResolvedValueOnce({
                    status: 'already_deleted',
                    deletedAt: 1700000000,
                    deletedBy: '[email protected]',
                })

            await service.deleteRecordings(['new', 'already-deleted'], 1, '[email protected]')

            expect(mockMetadataStore.storeSessionBlocks).toHaveBeenCalledTimes(1)
            expect(mockMetadataStore.storeSessionBlocks).toHaveBeenCalledWith([
                expect.objectContaining({ sessionId: 'new', teamId: 1, isDeleted: true }),
            ])
        })

        it('batches postgres deletes for all shredded sessions', async () => {
            mockKeyStore.deleteKey.mockResolvedValue({
                status: 'deleted',
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })

            await service.deleteRecordings(['session-1', 'session-2'], 1, '[email protected]')

            // 4 DELETE statements + 1 asset expiry UPDATE + 1 activity log INSERT
            expect(mockPostgres.query).toHaveBeenCalledTimes(6)
            expect(mockPostgres.query).toHaveBeenCalledWith(
                expect.anything(),
                expect.stringContaining('ee_single_session_summary'),
                [1, ['session-1', 'session-2']],
                'deleteSessionSummaries'
            )
            expect(mockPostgres.query).toHaveBeenCalledWith(
                expect.anything(),
                expect.stringContaining('replay_vision_replayobservation'),
                [1, ['session-1', 'session-2']],
                'deleteReplayVisionObservations'
            )
            expect(mockPostgres.query).toHaveBeenCalledWith(
                expect.anything(),
                expect.stringContaining('posthog_exportedasset'),
                [1, ['"session-1"', '"session-2"']],
                'expireRecordingExports'
            )
        })

        it('still cleans up derived data for an already_deleted session', async () => {
            mockKeyStore.deleteKey
                .mockResolvedValueOnce({ status: 'deleted', deletedAt: 1700000000, deletedBy: '[email protected]' })
                .mockResolvedValueOnce({
                    status: 'already_deleted',
                    deletedAt: 1700000000,
                    deletedBy: '[email protected]',
                })

            await service.deleteRecordings(['new-session', 'already-deleted-session'], 1, '[email protected]')

            // 4 DELETE statements + 1 asset expiry UPDATE + 1 activity log INSERT
            expect(mockPostgres.query).toHaveBeenCalledTimes(6)
            // Cleanup is best-effort, so a shred that already happened still gets another pass;
            // otherwise a failed one is never retried.
            expect(mockPostgres.query).toHaveBeenCalledWith(
                expect.anything(),
                expect.stringContaining('ee_single_session_summary'),
                [1, ['new-session', 'already-deleted-session']],
                'deleteSessionSummaries'
            )
        })

        it('returns delete_failed for sessions where key shred throws', async () => {
            mockKeyStore.deleteKey
                .mockResolvedValueOnce({ status: 'deleted', deletedAt: 1700000000, deletedBy: '[email protected]' })
                .mockRejectedValueOnce(new Error('DynamoDB error'))

            const result = await service.deleteRecordings(['session-1', 'session-2'], 1, '[email protected]')

            expect(result).toEqual([
                {
                    sessionId: 'session-1',
                    ok: true,
                    status: 'deleted',
                    deletedAt: 1700000000,
                    deletedBy: '[email protected]',
                },
                { sessionId: 'session-2', ok: false, status: 'delete_failed' },
            ])
        })

        it('reports success when kafka emission fails after shred', async () => {
            mockKeyStore.deleteKey.mockResolvedValue({
                status: 'deleted',
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })
            mockMetadataStore.storeSessionBlocks.mockRejectedValue(new Error('Kafka down'))

            const result = await service.deleteRecordings(['session-1'], 1, '[email protected]')

            expect(result).toEqual([
                {
                    sessionId: 'session-1',
                    ok: true,
                    status: 'deleted',
                    deletedAt: 1700000000,
                    deletedBy: '[email protected]',
                },
            ])
        })

        it('inserts activity log entries for newly deleted sessions', async () => {
            mockKeyStore.deleteKey.mockResolvedValue({
                status: 'deleted',
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })

            await service.deleteRecordings(['session-1', 'session-2'], 1, '[email protected]')

            expect(mockPostgres.query).toHaveBeenCalledWith(
                expect.anything(),
                expect.stringContaining('posthog_activitylog'),
                [1, ['session-1', 'session-2'], expect.stringContaining('recording_shredded')],
                'logRecordingDeletion'
            )
        })

        it('does not insert activity log when all sessions were already deleted', async () => {
            mockKeyStore.deleteKey.mockResolvedValue({
                status: 'already_deleted',
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })

            await service.deleteRecordings(['session-1'], 1, '[email protected]')

            expect(mockPostgres.query).not.toHaveBeenCalledWith(
                expect.anything(),
                expect.stringContaining('posthog_activitylog'),
                expect.anything(),
                'logRecordingDeletion'
            )
            // The shred is not repeated, but its derived data still gets a cleanup pass.
            expect(mockPostgres.query).toHaveBeenCalledWith(
                expect.anything(),
                expect.stringContaining('replay_vision_replayobservation'),
                [1, ['session-1']],
                'deleteReplayVisionObservations'
            )
        })

        it('reports success when logActivity fails after shred', async () => {
            mockKeyStore.deleteKey.mockResolvedValue({
                status: 'deleted',
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })
            let callCount = 0
            mockPostgres.query.mockImplementation((() => {
                if (++callCount === 4) {
                    return Promise.reject(new Error('Activity log insert failed'))
                }
                return Promise.resolve({ rows: [] })
            }) as any)

            const result = await service.deleteRecordings(['session-1'], 1, '[email protected]')

            expect(result).toEqual([
                {
                    sessionId: 'session-1',
                    ok: true,
                    status: 'deleted',
                    deletedAt: 1700000000,
                    deletedBy: '[email protected]',
                },
            ])
        })

        it('skips postgres when all shreds fail', async () => {
            mockKeyStore.deleteKey.mockRejectedValue(new Error('DynamoDB error'))

            await service.deleteRecordings(['session-1'], 1, '[email protected]')

            expect(mockPostgres.query).not.toHaveBeenCalled()
        })

        it('reports success when postgres cleanup fails after shred', async () => {
            mockKeyStore.deleteKey.mockResolvedValue({
                status: 'deleted',
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })
            mockPostgres.query.mockRejectedValue(new Error('Postgres down'))

            const result = await service.deleteRecordings(['session-1'], 1, '[email protected]')

            expect(result).toEqual([
                {
                    sessionId: 'session-1',
                    ok: true,
                    status: 'deleted',
                    deletedAt: 1700000000,
                    deletedBy: '[email protected]',
                },
            ])
        })

        it('reports success even when all cleanup steps fail', async () => {
            mockKeyStore.deleteKey.mockResolvedValue({
                status: 'deleted',
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })
            mockMetadataStore.storeSessionBlocks.mockRejectedValue(new Error('Kafka down'))
            mockPostgres.query.mockRejectedValue(new Error('Postgres down'))

            const result = await service.deleteRecordings(['session-1'], 1, '[email protected]')

            expect(result).toEqual([
                {
                    sessionId: 'session-1',
                    ok: true,
                    status: 'deleted',
                    deletedAt: 1700000000,
                    deletedBy: '[email protected]',
                },
            ])
            expect(mockMetadataStore.storeSessionBlocks).toHaveBeenCalled()
            expect(mockPostgres.query).toHaveBeenCalled()
        })
    })

    describe('encryptBlocks', () => {
        const plaintextKey = Buffer.alloc(32, 7)
        const ciphertextKey = {
            plaintextKey,
            encryptedKey: Buffer.from('wrapped'),
            sessionState: 'ciphertext' as const,
        }
        const cleartextKey = {
            plaintextKey: Buffer.alloc(0),
            encryptedKey: Buffer.alloc(0),
            sessionState: 'cleartext' as const,
        }

        beforeAll(async () => {
            await sodium.ready
        })

        beforeEach(() => {
            mockKeyStore.generateKey.mockResolvedValue(ciphertextKey)
        })

        const mockRecordingExists = (exists: boolean): void => {
            mockClickhouse.query.mockResolvedValue({
                json: jest.fn().mockResolvedValue(exists ? [{ '1': 1 }] : []),
            } as any)
        }

        it.each([
            ['an existing key', ciphertextKey, 0],
            ['no key and no recording yet', cleartextKey, 1],
        ])('encrypts with %s so the decryptor can read it back', async (_, existingKey, expectedKeyMints) => {
            mockKeyStore.getKey.mockResolvedValue(existingKey)
            mockRecordingExists(false)

            const result = await service.encryptBlocks('session-1', 1, [Buffer.from('block-a'), Buffer.from('b')], 365)

            expect(result.ok).toBe(true)
            const decryptor = new SodiumRecordingDecryptor(mockKeyStore)
            const decrypted = (result as { blocks: Buffer[] }).blocks.map(
                (b) => decryptor.decryptBlockWithKey('session-1', 1, b, ciphertextKey).data
            )
            expect(decrypted).toEqual([Buffer.from('block-a'), Buffer.from('b')])
            expect(mockKeyStore.generateKey).toHaveBeenCalledTimes(expectedKeyMints)
        })

        it.each([
            ['a recording that predates encryption', cleartextKey],
            ['an ingested encrypted recording', ciphertextKey],
        ])('refuses to encrypt into %s', async (_, existingKey) => {
            mockKeyStore.getKey.mockResolvedValue(existingKey)
            mockRecordingExists(true)

            const result = await service.encryptBlocks('session-1', 1, [Buffer.from('block')], 365)

            expect(result).toEqual({ ok: false, error: 'recording_exists' })
            expect(mockKeyStore.generateKey).not.toHaveBeenCalled()
        })

        it('refuses to return plaintext when a cloud key mint reads back no key', async () => {
            const isCloud = jest.spyOn(envUtils, 'isCloud').mockReturnValue(true)
            mockRecordingExists(false)
            mockKeyStore.getKey.mockResolvedValue(cleartextKey)
            mockKeyStore.generateKey.mockResolvedValue(cleartextKey)

            const result = await service.encryptBlocks('session-1', 1, [Buffer.from('block')], 365)

            expect(result).toEqual({ ok: false, error: 'key_unavailable' })
            isCloud.mockRestore()
        })

        it('returns deleted when the session key was shredded', async () => {
            mockRecordingExists(false)
            mockKeyStore.getKey.mockResolvedValue({
                ...cleartextKey,
                sessionState: 'deleted',
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })

            const result = await service.encryptBlocks('session-1', 1, [Buffer.from('block')], 365)

            expect(result).toEqual({
                ok: false,
                error: 'deleted',
                deletedAt: 1700000000,
                deletedBy: '[email protected]',
            })
        })
    })
})