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.

4.9 KB
Raw Blame
import { beforeAll, describe, expect, it } from 'vitest'

import {
    TEST_ORG_ID,
    TEST_PROJECT_ID,
    createTestClient,
    createTestContext,
    parseToolResponse,
    setActiveProjectAndOrg,
    validateEnvironmentVariables,
} from '@/shared/test-utils'
import { GENERATED_TOOLS } from '@/tools/generated/platform_features'
import type { Context } from '@/tools/types'

describe('Activity Logs', { concurrent: false }, () => {
    let context: Context

    beforeAll(async () => {
        validateEnvironmentVariables()
        const client = createTestClient()
        context = createTestContext(client)
        await setActiveProjectAndOrg(context, TEST_PROJECT_ID!, TEST_ORG_ID!)
    })

    describe('advanced-activity-logs-list tool', () => {
        const listTool = GENERATED_TOOLS['advanced-activity-logs-list']!()

        it('should list activity logs with default parameters', async () => {
            const result = await listTool.handler(context, {})
            const response = parseToolResponse(result)

            expect(response).toHaveProperty('results')
            expect(Array.isArray(response.results)).toBe(true)
            expect(response._posthogUrl).toContain('/activity')
        })

        it('should return results with expected structure', async () => {
            const result = await listTool.handler(context, { page: 1, page_size: 5 })
            const response = parseToolResponse(result)

            expect(Array.isArray(response.results)).toBe(true)

            for (const log of response.results) {
                expect(log).toHaveProperty('id')
                expect(log).toHaveProperty('activity')
                expect(log).toHaveProperty('scope')
                expect(log).toHaveProperty('created_at')
                // user can be null for system-generated activity entries
            }
        })

        it('should support page-based pagination', async () => {
            const page1 = await listTool.handler(context, { page: 1, page_size: 2 })
            const page1Data = parseToolResponse(page1)

            expect(Array.isArray(page1Data.results)).toBe(true)
            expect(page1Data.results.length).toBeLessThanOrEqual(2)

            if (page1Data.results.length === 2) {
                const page2 = await listTool.handler(context, { page: 2, page_size: 2 })
                const page2Data = parseToolResponse(page2)

                expect(Array.isArray(page2Data.results)).toBe(true)

                if (page2Data.results.length > 0) {
                    const page1Ids = page1Data.results.map((r: any) => r.id)
                    const page2Ids = page2Data.results.map((r: any) => r.id)
                    const overlap = page1Ids.filter((id: string) => page2Ids.includes(id))
                    expect(overlap).toHaveLength(0)
                }
            }
        })

        // Guards the array-filter fix: the MCP client sends `scopes` as a JSON-encoded
        // array, which the advanced endpoint must parse (JSONTolerantListField) rather
        // than treat as one literal value that matches nothing.
        it('should filter by scopes', async () => {
            const result = await listTool.handler(context, {
                scopes: ['FeatureFlag', 'Insight'],
                page: 1,
                page_size: 10,
            })
            const response = parseToolResponse(result)

            expect(Array.isArray(response.results)).toBe(true)
            for (const log of response.results) {
                expect(['FeatureFlag', 'Insight']).toContain(log.scope)
            }
        })

        it('should filter by item_ids', async () => {
            // First get a log to find a real item_id
            const seed = await listTool.handler(context, { page: 1, page_size: 1 })
            const seedData = parseToolResponse(seed)

            if (seedData.results.length === 0) {
                return
            }

            const targetItemId = seedData.results[0].item_id
            if (!targetItemId) {
                return
            }

            const result = await listTool.handler(context, {
                item_ids: [targetItemId],
                page: 1,
                page_size: 10,
            })
            const response = parseToolResponse(result)

            expect(Array.isArray(response.results)).toBe(true)
            for (const log of response.results) {
                expect(log.item_id).toBe(targetItemId)
            }
        })

        it('should return empty results for a non-existent item_id filter', async () => {
            const result = await listTool.handler(context, {
                item_ids: ['999999999'],
                scopes: ['FeatureFlag'],
                page: 1,
                page_size: 10,
            })
            const response = parseToolResponse(result)

            expect(Array.isArray(response.results)).toBe(true)
            expect(response.results).toHaveLength(0)
        })
    })
})