@posthog/core 1.2.0 → 1.2.2

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

@@ -1,135 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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()
-    })
-  })
-})