@posthog/core 1.1.0 → 1.2.1

package/src/__tests__/posthog.core.spec.ts

@@ -0,0 +1,135 @@
+import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  let mocks: PostHogCoreTestClientMocks
+
+  jest.useFakeTimers()
+  jest.setSystemTime(new Date('2022-01-01'))
+
+  const errorAPIResponse = Promise.resolve({
+    status: 400,
+    text: () => Promise.resolve('error'),
+    json: () =>
+      Promise.resolve({
+        status: 'error',
+      }),
+  })
+
+  describe('getFlags', () => {
+    beforeEach(() => {
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 1 })
+    })
+
+    it('should handle successful v1 response and return normalized response', async () => {
+      const mockV1Response = {
+        featureFlags: { 'test-flag': true },
+        featureFlagPayloads: { 'test-flag': { a: 'payload' } },
+      }
+
+      const expectedResponse = {
+        ...mockV1Response,
+        flags: {
+          'test-flag': {
+            key: 'test-flag',
+            enabled: true,
+            variant: undefined,
+            reason: undefined,
+            metadata: {
+              id: undefined,
+              version: undefined,
+              description: undefined,
+              payload: '{"a":"payload"}',
+            },
+          },
+        },
+      }
+
+      mocks.fetch.mockImplementation((url) => {
+        if (url.includes('/flags/?v=2&config=true')) {
+          return Promise.resolve({
+            status: 200,
+            text: () => Promise.resolve('ok'),
+            json: () => Promise.resolve(mockV1Response),
+          })
+        }
+        return errorAPIResponse
+      })
+
+      const response = await posthog.getFlags('test-distinct-id')
+      expect(response).toEqual(expectedResponse)
+    })
+
+    it('should handle successful v4 response and return normalized response', async () => {
+      const mockV4Response = {
+        flags: {
+          'test-flag': {
+            key: 'test-flag',
+            enabled: true,
+            variant: 'test-payload',
+            reason: {
+              code: 'matched_condition',
+              description: 'matched condition set 1',
+              condition_index: 0,
+            },
+            metadata: {
+              id: 1,
+              version: 1,
+              description: 'test-flag',
+              payload: '{"a":"payload"}',
+            },
+          },
+        },
+      }
+
+      const expectedResponse = {
+        ...mockV4Response,
+        featureFlags: { 'test-flag': 'test-payload' },
+        featureFlagPayloads: { 'test-flag': { a: 'payload' } },
+      }
+      mocks.fetch.mockImplementation((url) => {
+        if (url.includes('/flags/?v=2&config=true')) {
+          return Promise.resolve({
+            status: 200,
+            text: () => Promise.resolve('ok'),
+            json: () => Promise.resolve(mockV4Response),
+          })
+        }
+        return errorAPIResponse
+      })
+
+      const response = await posthog.getFlags('test-distinct-id')
+      expect(response).toEqual(expectedResponse)
+    })
+
+    it('should handle error response', async () => {
+      mocks.fetch.mockImplementation((url) => {
+        if (url.includes('/flags/?v=2&config=true')) {
+          return Promise.resolve({
+            status: 400,
+            text: () => Promise.resolve('error'),
+            json: () => Promise.resolve({ error: 'went wrong' }),
+          })
+        }
+        return errorAPIResponse
+      })
+
+      const response = await posthog.getFlags('test-distinct-id')
+      expect(response).toBeUndefined()
+    })
+
+    it('should handle network errors', async () => {
+      const emitSpy = jest.spyOn(posthog['_events'], 'emit')
+      mocks.fetch.mockImplementation((url) => {
+        if (url.includes('/flags/?v=2&config=true')) {
+          return Promise.reject(new Error('Network error'))
+        }
+        return errorAPIResponse
+      })
+
+      const response = await posthog.getFlags('test-distinct-id')
+      expect(response).toBeUndefined()
+      expect(emitSpy).toHaveBeenCalledWith('error', expect.any(Error))
+    })
+  })
+})

package/src/__tests__/posthog.debug.spec.ts

@@ -0,0 +1,36 @@
+import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  let mocks: PostHogCoreTestClientMocks
+
+  beforeEach(() => {
+    ;[posthog, mocks] = createTestClient('TEST_API_KEY', {})
+  })
+
+  describe('debug', () => {
+    it('should log emitted events when enabled', () => {
+      const spy = jest.spyOn(console, 'log')
+
+      posthog.capture('test-event1')
+      expect(spy).toHaveBeenCalledTimes(0)
+
+      posthog.debug()
+      posthog.capture('test-event1')
+      expect(spy).toHaveBeenCalledTimes(1)
+      expect(spy).toHaveBeenCalledWith(
+        'PostHog Debug',
+        'capture',
+        expect.objectContaining({
+          event: 'test-event1',
+        })
+      )
+
+      spy.mockReset()
+      posthog.debug(false)
+      posthog.capture('test-event1')
+      expect(spy).toHaveBeenCalledTimes(0)
+    })
+  })
+})

package/src/__tests__/posthog.enqueue.spec.ts

@@ -0,0 +1,93 @@
+import { PostHogPersistedProperty } from '@/types'
+import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  let mocks: PostHogCoreTestClientMocks
+
+  beforeEach(() => {
+    jest.setSystemTime(new Date('2022-01-01'))
+  })
+
+  function createSut(maxQueueSize: number = 1000, flushAt: number = 20): void {
+    ;[posthog, mocks] = createTestClient('TEST_API_KEY', {
+      maxQueueSize: maxQueueSize,
+      flushAt: flushAt,
+    })
+  }
+
+  describe('enqueue', () => {
+    it('should add a message to the queue', () => {
+      createSut()
+
+      posthog.capture('type', {
+        foo: 'bar',
+      })
+
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Queue)).toHaveLength(1)
+
+      const item = posthog.getPersistedProperty<any[]>(PostHogPersistedProperty.Queue)?.pop()
+
+      expect(item).toMatchObject({
+        message: {
+          library: 'posthog-core-tests',
+          library_version: '2.0.0-alpha',
+          type: 'capture',
+          properties: {
+            foo: 'bar',
+          },
+        },
+      })
+
+      expect(mocks.fetch).not.toHaveBeenCalled()
+    })
+
+    it('should delete oldest message if queue is full', () => {
+      createSut(2, 2)
+
+      posthog.capture('type1', {
+        foo: 'bar',
+      })
+
+      posthog.capture('type2', {
+        foo: 'bar',
+      })
+
+      posthog.capture('type3', {
+        foo: 'bar',
+      })
+
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Queue)).toHaveLength(2)
+
+      let item = posthog.getPersistedProperty<any[]>(PostHogPersistedProperty.Queue)?.pop()
+
+      expect(item).toMatchObject({
+        message: {
+          library: 'posthog-core-tests',
+          library_version: '2.0.0-alpha',
+          type: 'capture',
+          properties: {
+            foo: 'bar',
+          },
+          event: 'type3',
+        },
+      })
+
+      item = posthog.getPersistedProperty<any[]>(PostHogPersistedProperty.Queue)?.pop()
+
+      expect(item).toMatchObject({
+        message: {
+          library: 'posthog-core-tests',
+          library_version: '2.0.0-alpha',
+          type: 'capture',
+          properties: {
+            foo: 'bar',
+          },
+          event: 'type2',
+        },
+      })
+
+      expect(mocks.fetch).not.toHaveBeenCalled()
+    })
+  })
+})