posthog-node 4.17.0 → 4.17.2

package/test/extensions/sentry-integration.spec.ts

@@ -1,163 +0,0 @@
-import { PostHog } from '../../src/entrypoints/index.node'
-import { PostHogSentryIntegration } from '../../src/extensions/sentry-integration'
-jest.mock('../../src/fetch')
-import fetch from '../../src/fetch'
-import { waitForPromises } from 'posthog-core/test/test-utils/test-utils'
-
-jest.mock('../../package.json', () => ({ version: '1.2.3' }))
-
-const mockedFetch = jest.mocked(fetch, true)
-
-const getLastBatchEvents = (): any[] | undefined => {
-  expect(mockedFetch).toHaveBeenCalledWith('http://example.com/batch/', expect.objectContaining({ method: 'POST' }))
-
-  // reverse mock calls array to get the last call
-  const call = mockedFetch.mock.calls.reverse().find((x) => (x[0] as string).includes('/batch/'))
-  if (!call) {
-    return undefined
-  }
-  return JSON.parse((call[1] as any).body as any).batch
-}
-
-const createMockSentryException = (): any => ({
-  exception: {
-    values: [
-      {
-        type: 'Error',
-        value: 'example error',
-        stacktrace: {
-          frames: [],
-        },
-        mechanism: { type: 'generic', handled: true },
-      },
-    ],
-  },
-  event_id: '80a7023ac32c47f7acb0adaed600d149',
-  platform: 'node',
-  contexts: {},
-  server_name: 'localhost',
-  timestamp: 1704203482.356,
-  environment: 'production',
-  level: 'error',
-  tags: { posthog_distinct_id: 'EXAMPLE_APP_GLOBAL' },
-  breadcrumbs: [
-    {
-      timestamp: 1704203481.422,
-      category: 'console',
-      level: 'log',
-      message: '⚡: Server is running at http://localhost:8010',
-    },
-    {
-      timestamp: 1704203481.658,
-      category: 'console',
-      level: 'log',
-      message:
-        "PostHog Debug error [ClientError: Your personalApiKey is invalid. Are you sure you're not using your Project API key? More information: https://posthog.com/docs/api/overview]",
-    },
-  ],
-  sdkProcessingMetadata: {
-    propagationContext: { traceId: 'ea26146e5a354cb0b3b1daebb3f90e33', spanId: '8d642089c3daa272' },
-  },
-})
-
-describe('PostHogSentryIntegration', () => {
-  let posthog: PostHog
-  let posthogSentry: PostHogSentryIntegration
-
-  jest.useFakeTimers()
-
-  beforeEach(() => {
-    posthog = new PostHog('TEST_API_KEY', {
-      host: 'http://example.com',
-      fetchRetryCount: 0,
-    })
-
-    posthogSentry = new PostHogSentryIntegration(posthog)
-
-    mockedFetch.mockResolvedValue({
-      status: 200,
-      text: () => Promise.resolve('ok'),
-      json: () =>
-        Promise.resolve({
-          status: 'ok',
-        }),
-    } as any)
-  })
-
-  afterEach(async () => {
-    // ensure clean shutdown & no test interdependencies
-    await posthog.shutdown()
-  })
-
-  it('should forward sentry exceptions to posthog', async () => {
-    expect(mockedFetch).toHaveBeenCalledTimes(0)
-
-    const mockSentry = {
-      getClient: () => ({
-        getDsn: () => ({
-          projectId: 123,
-        }),
-      }),
-    }
-
-    let processorFunction: any
-
-    posthogSentry.setupOnce(
-      (fn) => (processorFunction = fn),
-      () => mockSentry
-    )
-
-    processorFunction(createMockSentryException())
-
-    await waitForPromises() // First flush
-    jest.runOnlyPendingTimers() // Flush timer
-    await waitForPromises() // Second flush
-    const batchEvents = getLastBatchEvents()
-
-    expect(batchEvents).toEqual([
-      {
-        distinct_id: 'EXAMPLE_APP_GLOBAL',
-        event: '$exception',
-        properties: {
-          $exception_level: 'error',
-          $exception_list: [
-            {
-              mechanism: { handled: true, type: 'generic' },
-              stacktrace: { frames: [], type: 'raw' },
-              type: 'Error',
-              value: 'example error',
-            },
-          ],
-          $exception_message: 'example error',
-          $exception_type: 'Error',
-          $exception_personURL: 'http://example.com/project/TEST_API_KEY/person/EXAMPLE_APP_GLOBAL',
-          $sentry_event_id: '80a7023ac32c47f7acb0adaed600d149',
-          $sentry_exception: {
-            values: [
-              {
-                type: 'Error',
-                value: 'example error',
-                stacktrace: { frames: [] },
-                mechanism: { type: 'generic', handled: true },
-              },
-            ],
-          },
-          $sentry_exception_message: 'example error',
-          $sentry_exception_type: 'Error',
-          $sentry_tags: {
-            posthog_distinct_id: 'EXAMPLE_APP_GLOBAL',
-            'PostHog Person URL': 'http://example.com/project/TEST_API_KEY/person/EXAMPLE_APP_GLOBAL',
-          },
-          $lib: 'posthog-node',
-          $lib_version: '1.2.3',
-          $geoip_disable: true,
-        },
-        type: 'capture',
-        library: 'posthog-node',
-        library_version: '1.2.3',
-        timestamp: expect.any(String),
-        uuid: expect.any(String),
-      },
-    ])
-  })
-})

package/test/feature-flags.decide.spec.ts

@@ -1,381 +0,0 @@
-import { PostHog } from '../src/entrypoints/index.node'
-import { PostHogOptions } from '../src/types'
-import fetch from '../src/fetch'
-import { apiImplementation, apiImplementationV4 } from './test-utils'
-import { waitForPromises } from 'posthog-core/test/test-utils/test-utils'
-import { PostHogV4DecideResponse } from 'posthog-core/src/types'
-jest.mock('../src/fetch')
-
-jest.spyOn(console, 'debug').mockImplementation()
-
-const mockedFetch = jest.mocked(fetch, true)
-
-const posthogImmediateResolveOptions: PostHogOptions = {
-  fetchRetryCount: 0,
-}
-
-describe('decide v4', () => {
-  describe('getFeatureFlag v4', () => {
-    it('returns undefined if the flag is not found', async () => {
-      const decideResponse: PostHogV4DecideResponse = {
-        flags: {},
-        errorsWhileComputingFlags: false,
-        requestId: '0152a345-295f-4fba-adac-2e6ea9c91082',
-      }
-      mockedFetch.mockImplementation(apiImplementationV4(decideResponse))
-
-      const posthog = new PostHog('TEST_API_KEY', {
-        host: 'http://example.com',
-        ...posthogImmediateResolveOptions,
-      })
-      let capturedMessage: any
-      posthog.on('capture', (message) => {
-        capturedMessage = message
-      })
-
-      const result = await posthog.getFeatureFlag('non-existent-flag', 'some-distinct-id')
-
-      expect(result).toBe(undefined)
-      expect(mockedFetch).toHaveBeenCalledWith('http://example.com/flags/?v=2', expect.any(Object))
-
-      await waitForPromises()
-      expect(capturedMessage).toMatchObject({
-        distinct_id: 'some-distinct-id',
-        event: '$feature_flag_called',
-        library: posthog.getLibraryId(),
-        library_version: posthog.getLibraryVersion(),
-        properties: {
-          '$feature/non-existent-flag': undefined,
-          $feature_flag: 'non-existent-flag',
-          $feature_flag_response: undefined,
-          $feature_flag_request_id: '0152a345-295f-4fba-adac-2e6ea9c91082',
-          $groups: undefined,
-          $lib: posthog.getLibraryId(),
-          $lib_version: posthog.getLibraryVersion(),
-          locally_evaluated: false,
-        },
-      })
-    })
-
-    it.each([
-      {
-        key: 'variant-flag',
-        expectedResponse: 'variant-value',
-        expectedReason: 'Matched condition set 3',
-        expectedId: 2,
-        expectedVersion: 23,
-      },
-      {
-        key: 'boolean-flag',
-        expectedResponse: true,
-        expectedReason: 'Matched condition set 1',
-        expectedId: 1,
-        expectedVersion: 12,
-      },
-      {
-        key: 'non-matching-flag',
-        expectedResponse: false,
-        expectedReason: 'Did not match any condition',
-        expectedId: 3,
-        expectedVersion: 2,
-      },
-    ])(
-      'captures a feature flag called event with extra metadata when the flag is found',
-      async ({ key, expectedResponse, expectedReason, expectedId, expectedVersion }) => {
-        const decideResponse: PostHogV4DecideResponse = {
-          flags: {
-            'variant-flag': {
-              key: 'variant-flag',
-              enabled: true,
-              variant: 'variant-value',
-              reason: {
-                code: 'variant',
-                condition_index: 2,
-                description: 'Matched condition set 3',
-              },
-              metadata: {
-                id: 2,
-                version: 23,
-                payload: '{"key": "value"}',
-                description: 'description',
-              },
-            },
-            'boolean-flag': {
-              key: 'boolean-flag',
-              enabled: true,
-              variant: undefined,
-              reason: {
-                code: 'boolean',
-                condition_index: 1,
-                description: 'Matched condition set 1',
-              },
-              metadata: {
-                id: 1,
-                version: 12,
-                payload: undefined,
-                description: 'description',
-              },
-            },
-            'non-matching-flag': {
-              key: 'non-matching-flag',
-              enabled: false,
-              variant: undefined,
-              reason: {
-                code: 'boolean',
-                condition_index: 1,
-                description: 'Did not match any condition',
-              },
-              metadata: {
-                id: 3,
-                version: 2,
-                payload: undefined,
-                description: 'description',
-              },
-            },
-          },
-          errorsWhileComputingFlags: false,
-          requestId: '0152a345-295f-4fba-adac-2e6ea9c91082',
-        }
-        mockedFetch.mockImplementation(apiImplementationV4(decideResponse))
-
-        const posthog = new PostHog('TEST_API_KEY', {
-          host: 'http://example.com',
-          ...posthogImmediateResolveOptions,
-        })
-        let capturedMessage: any
-        posthog.on('capture', (message) => {
-          capturedMessage = message
-        })
-
-        const result = await posthog.getFeatureFlag(key, 'some-distinct-id')
-
-        expect(result).toBe(expectedResponse)
-        expect(mockedFetch).toHaveBeenCalledWith('http://example.com/flags/?v=2', expect.any(Object))
-
-        await waitForPromises()
-        expect(capturedMessage).toMatchObject({
-          distinct_id: 'some-distinct-id',
-          event: '$feature_flag_called',
-          library: posthog.getLibraryId(),
-          library_version: posthog.getLibraryVersion(),
-          properties: {
-            [`$feature/${key}`]: expectedResponse,
-            $feature_flag: key,
-            $feature_flag_response: expectedResponse,
-            $feature_flag_id: expectedId,
-            $feature_flag_version: expectedVersion,
-            $feature_flag_reason: expectedReason,
-            $feature_flag_request_id: '0152a345-295f-4fba-adac-2e6ea9c91082',
-            $groups: undefined,
-            $lib: posthog.getLibraryId(),
-            $lib_version: posthog.getLibraryVersion(),
-            locally_evaluated: false,
-          },
-        })
-      }
-    )
-
-    describe('getFeatureFlagPayload v4', () => {
-      it('returns payload', async () => {
-        mockedFetch.mockImplementation(
-          apiImplementationV4({
-            flags: {
-              'flag-with-payload': {
-                key: 'flag-with-payload',
-                enabled: true,
-                variant: undefined,
-                reason: {
-                  code: 'boolean',
-                  condition_index: 1,
-                  description: 'Matched condition set 2',
-                },
-                metadata: {
-                  id: 1,
-                  version: 12,
-                  payload: '[0, 1, 2]',
-                  description: 'description',
-                },
-              },
-            },
-            errorsWhileComputingFlags: false,
-          })
-        )
-
-        const posthog = new PostHog('TEST_API_KEY', {
-          host: 'http://example.com',
-          ...posthogImmediateResolveOptions,
-        })
-        let capturedMessage: any
-        posthog.on('capture', (message) => {
-          capturedMessage = message
-        })
-
-        const result = await posthog.getFeatureFlagPayload('flag-with-payload', 'some-distinct-id')
-
-        expect(result).toEqual([0, 1, 2])
-        expect(mockedFetch).toHaveBeenCalledWith('http://example.com/flags/?v=2', expect.any(Object))
-
-        await waitForPromises()
-        expect(capturedMessage).toBeUndefined()
-      })
-    })
-  })
-
-  describe('error handling', () => {
-    let posthog: PostHog
-    describe.each([
-      {
-        case: 'JSON error response',
-        mock: apiImplementationV4({
-          status: 400,
-          json: () => Promise.resolve({ error: 'error response' }),
-        }),
-      },
-      {
-        case: 'undefined response',
-        mock: apiImplementationV4({
-          status: 400,
-          json: () => Promise.resolve(undefined),
-        }),
-      },
-      {
-        case: 'null response',
-        mock: apiImplementationV4({
-          status: 400,
-          json: () => Promise.resolve(null),
-        }),
-      },
-      {
-        case: 'empty response',
-        mock: apiImplementationV4({
-          status: 400,
-          json: () => Promise.resolve({}),
-        }),
-      },
-      {
-        case: 'network error',
-        mock: () => Promise.reject(new Error('Network error')),
-      },
-      {
-        case: 'invalid JSON',
-        mock: apiImplementationV4({
-          status: 500,
-          json: () => Promise.reject(new Error('Invalid JSON')),
-        }),
-      },
-    ])('when $case', ({ mock }) => {
-      beforeEach(() => {
-        posthog = new PostHog('TEST_API_KEY', {
-          host: 'http://example.com',
-          ...posthogImmediateResolveOptions,
-        })
-        mockedFetch.mockImplementation(mock)
-      })
-
-      it('getFeatureFlag returns undefined', async () => {
-        expect(await posthog.getFeatureFlag('error-flag', 'some-distinct-id')).toBe(undefined)
-      })
-
-      it('isFeatureEnabled returns undefined', async () => {
-        expect(await posthog.isFeatureEnabled('error-flag', 'some-distinct-id')).toBe(undefined)
-      })
-
-      it('getFeatureFlagPayload returns undefined', async () => {
-        expect(await posthog.getFeatureFlagPayload('error-flag', 'some-distinct-id')).toBe(undefined)
-      })
-
-      it('getAllFlags returns empty object', async () => {
-        expect(await posthog.getAllFlags('some-distinct-id')).toEqual({})
-      })
-
-      it('getAllFlagsAndPayloads returns object with empty flags and payloads', async () => {
-        expect(await posthog.getAllFlagsAndPayloads('some-distinct-id')).toEqual({
-          featureFlags: {},
-          featureFlagPayloads: {},
-        })
-      })
-
-      it('captures no events', async () => {
-        let capturedMessage: any
-        posthog.on('capture', (message) => {
-          capturedMessage = message
-        })
-
-        await posthog.getFeatureFlag('error-flag', 'some-distinct-id')
-        await waitForPromises()
-        expect(capturedMessage).toBeUndefined()
-      })
-    })
-  })
-})
-
-describe('decide v3', () => {
-  describe('getFeatureFlag v3', () => {
-    it('returns undefined if the flag is not found', async () => {
-      mockedFetch.mockImplementation(apiImplementation({ decideFlags: {} }))
-
-      const posthog = new PostHog('TEST_API_KEY', {
-        host: 'http://example.com',
-        ...posthogImmediateResolveOptions,
-      })
-      let capturedMessage: any
-      posthog.on('capture', (message) => {
-        capturedMessage = message
-      })
-
-      const result = await posthog.getFeatureFlag('non-existent-flag', 'some-distinct-id')
-
-      expect(result).toBe(undefined)
-      expect(mockedFetch).toHaveBeenCalledWith('http://example.com/flags/?v=2', expect.any(Object))
-
-      await waitForPromises()
-      expect(capturedMessage).toMatchObject({
-        distinct_id: 'some-distinct-id',
-        event: '$feature_flag_called',
-        library: posthog.getLibraryId(),
-        library_version: posthog.getLibraryVersion(),
-        properties: {
-          '$feature/non-existent-flag': undefined,
-          $feature_flag: 'non-existent-flag',
-          $feature_flag_response: undefined,
-          $groups: undefined,
-          $lib: posthog.getLibraryId(),
-          $lib_version: posthog.getLibraryVersion(),
-          locally_evaluated: false,
-        },
-      })
-    })
-  })
-
-  describe('getFeatureFlagPayload v3', () => {
-    it('returns payload', async () => {
-      mockedFetch.mockImplementation(
-        apiImplementation({
-          decideFlags: {
-            'flag-with-payload': true,
-          },
-          decideFlagPayloads: {
-            'flag-with-payload': [0, 1, 2],
-          },
-        })
-      )
-
-      const posthog = new PostHog('TEST_API_KEY', {
-        host: 'http://example.com',
-        ...posthogImmediateResolveOptions,
-      })
-      let capturedMessage: any = undefined
-      posthog.on('capture', (message) => {
-        capturedMessage = message
-      })
-
-      const result = await posthog.getFeatureFlagPayload('flag-with-payload', 'some-distinct-id')
-
-      expect(result).toEqual([0, 1, 2])
-      expect(mockedFetch).toHaveBeenCalledWith('http://example.com/flags/?v=2', expect.any(Object))
-
-      await waitForPromises()
-      expect(capturedMessage).toBeUndefined()
-    })
-  })
-})