posthog-node 3.6.3 → 4.0.0-beta.2

package/test/feature-flags.spec.ts

@@ -4,6 +4,7 @@ import { PostHog as PostHog, PostHogOptions } from '../src/posthog-node'
 import { matchProperty, InconclusiveMatchError, relativeDateParseForFeatureFlagMatching } from '../src/feature-flags'
 jest.mock('../src/fetch')
 import fetch from '../src/fetch'
+import { anyDecideCall, anyLocalEvalCall, apiImplementation } from './test-utils'
 
 jest.spyOn(console, 'debug').mockImplementation()
 
@@ -13,71 +14,6 @@ const posthogImmediateResolveOptions: PostHogOptions = {
   fetchRetryCount: 0,
 }
 
-export const apiImplementation = ({
-  localFlags,
-  decideFlags,
-  decideFlagPayloads,
-  decideStatus = 200,
-}: {
-  localFlags?: any
-  decideFlags?: any
-  decideFlagPayloads?: any
-  decideStatus?: number
-}) => {
-  return (url: any): Promise<any> => {
-    if ((url as any).includes('/decide/')) {
-      return Promise.resolve({
-        status: decideStatus,
-        text: () => Promise.resolve('ok'),
-        json: () => {
-          if (decideStatus !== 200) {
-            return Promise.resolve(decideFlags)
-          } else {
-            return Promise.resolve({
-              featureFlags: decideFlags,
-              featureFlagPayloads: decideFlagPayloads,
-            })
-          }
-        },
-      }) as any
-    }
-
-    if ((url as any).includes('api/feature_flag/local_evaluation?token=TEST_API_KEY&send_cohorts')) {
-      return Promise.resolve({
-        status: 200,
-        text: () => Promise.resolve('ok'),
-        json: () => Promise.resolve(localFlags),
-      }) as any
-    }
-
-    if ((url as any).includes('batch/')) {
-      return Promise.resolve({
-        status: 200,
-        text: () => Promise.resolve('ok'),
-        json: () =>
-          Promise.resolve({
-            status: 'ok',
-          }),
-      }) as any
-    }
-
-    return Promise.resolve({
-      status: 400,
-      text: () => Promise.resolve('ok'),
-      json: () =>
-        Promise.resolve({
-          status: 'ok',
-        }),
-    }) as any
-  }
-}
-
-export const anyLocalEvalCall = [
-  'http://example.com/api/feature_flag/local_evaluation?token=TEST_API_KEY&send_cohorts',
-  expect.any(Object),
-]
-export const anyDecideCall = ['http://example.com/decide/?v=3', expect.any(Object)]
-
 describe('local evaluation', () => {
   let posthog: PostHog
 
@@ -85,7 +21,7 @@ describe('local evaluation', () => {
 
   afterEach(async () => {
     // ensure clean shutdown & no test interdependencies
-    await posthog.shutdownAsync()
+    await posthog.shutdown()
   })
 
   it('evaluates person properties', async () => {
@@ -614,7 +550,7 @@ describe('local evaluation', () => {
     expect(await posthog.getFeatureFlag('beta-feature2', 'some-distinct-id')).toEqual(undefined)
     expect(await posthog.isFeatureEnabled('beta-feature2', 'some-distinct-id')).toEqual(undefined)
     expect(mockedFetch).toHaveBeenCalledWith(...anyDecideCall)
-    await posthog.shutdownAsync()
+    await posthog.shutdown()
     expect(err).toHaveProperty('name', 'PostHogFetchHttpError')
   })
 
@@ -2051,80 +1987,74 @@ describe('match properties', () => {
     expect(matchProperty(property_d, { key: '2022-04-05 11:34:13 +00:00' })).toBe(false)
   })
 
-  it('with relative date operators', () => {
+  it.each([
+    ['is_date_before', '-6h', '2022-03-01', true],
+    ['is_date_before', '-6h', '2022-04-30', true],
+    // :TRICKY: MonthIndex is 0 indexed, so 3 is actually the 4th month, April.
+    ['is_date_before', '-6h', new Date(Date.UTC(2022, 3, 30, 1, 2, 3)), true],
+    // false because date comparison, instead of datetime, so reduces to same date
+    ['is_date_before', '-6h', new Date('2022-04-30T01:02:03+02:00'), true], // europe/madrid
+    ['is_date_before', '-6h', new Date('2022-04-30T20:02:03+02:00'), false], // europe/madrid
+    ['is_date_before', '-6h', new Date('2022-04-30T19:59:03+02:00'), true], // europe/madrid
+    ['is_date_before', '-6h', new Date('2022-04-30'), true],
+    ['is_date_before', '-6h', '2022-05-30', false],
+    // is date after
+    ['is_date_after', '1h', '2022-05-02', true],
+    ['is_date_after', '1h', '2022-05-30', true],
+    ['is_date_after', '1h', new Date(2022, 4, 30), true],
+    ['is_date_after', '1h', new Date('2022-05-30'), true],
+    ['is_date_after', '1h', '2022-04-30', false],
+    // # Try all possible relative dates
+    ['is_date_before', '1h', '2022-05-01 00:00:00', false],
+    ['is_date_before', '1h', '2022-04-30 22:00:00', true],
+    ['is_date_before', '-1d', '2022-04-29 23:59:00 GMT', true],
+    ['is_date_before', '-1d', '2022-04-30 00:00:01 GMT', false],
+    ['is_date_before', '1w', '2022-04-23 00:00:00 GMT', true],
+    ['is_date_before', '1w', '2022-04-24 00:00:00 GMT', false],
+    ['is_date_before', '1w', '2022-04-24 00:00:01 GMT', false],
+    ['is_date_before', '1m', '2022-03-01 00:00:00 GMT', true],
+    ['is_date_before', '1m', '2022-04-01 00:00:00 GMT', false],
+    ['is_date_before', '1m', '2022-04-05 00:00:01 GMT', false],
+
+    ['is_date_before', '-1y', '2021-04-28 00:00:00 GMT', true],
+    ['is_date_before', '-1y', '2021-05-01 00:00:01 GMT', false],
+
+    ['is_date_after', '122h', '2022-05-01 00:00:00 GMT', true],
+    ['is_date_after', '122h', '2022-04-23 01:00:00 GMT', false],
+
+    ['is_date_after', '2d', '2022-05-01 00:00:00 GMT', true],
+    ['is_date_after', '2d', '2022-04-29 00:00:01 GMT', true],
+    ['is_date_after', '2d', '2022-04-29 00:00:00 GMT', false],
+
+    ['is_date_after', '02w', '2022-05-01 00:00:00 GMT', true],
+    ['is_date_after', '02w', '2022-04-16 00:00:00 GMT', false],
+
+    ['is_date_after', '-1m', '2022-04-01 00:00:01 GMT', true],
+    ['is_date_after', '-1m', '2022-04-01 00:00:00 GMT', false],
+
+    ['is_date_after', '1y', '2022-05-01 00:00:00 GMT', true],
+    ['is_date_after', '1y', '2021-05-01 00:00:01 GMT', true],
+    ['is_date_after', '1y', '2021-05-01 00:00:00 GMT', false],
+    ['is_date_after', '1y', '2021-04-30 00:00:00 GMT', false],
+    ['is_date_after', '1y', '2021-03-01 12:13:00 GMT', false],
+  ])('with relative date operators: %s, %s, %s', (operator, value, date, expectation) => {
     jest.setSystemTime(new Date('2022-05-01'))
+    expect(matchProperty({ key: 'key', value, operator }, { key: date })).toBe(expectation)
 
-    const property_a = { key: 'key', value: '-6h', operator: 'is_date_before' }
-    expect(matchProperty(property_a, { key: '2022-03-01' })).toBe(true)
-    expect(matchProperty(property_a, { key: '2022-04-30' })).toBe(true)
+    return
+  })
 
-    // :TRICKY: MonthIndex is 0 indexed, so 3 is actually the 4th month, April.
-    expect(matchProperty(property_a, { key: new Date(Date.UTC(2022, 3, 30, 1, 2, 3)) })).toBe(true)
-    // false because date comparison, instead of datetime, so reduces to same date
-    expect(matchProperty(property_a, { key: new Date(2022, 3, 30, 19, 2, 3) })).toBe(false)
-    expect(matchProperty(property_a, { key: new Date('2022-04-30T01:02:03+02:00') })).toBe(true) // europe/madrid
-    expect(matchProperty(property_a, { key: new Date('2022-04-30T20:02:03+02:00') })).toBe(false) // europe/madrid
-    expect(matchProperty(property_a, { key: new Date('2022-04-30T19:59:03+02:00') })).toBe(true) // europe/madrid
-    expect(matchProperty(property_a, { key: new Date('2022-04-30') })).toBe(true)
-    expect(matchProperty(property_a, { key: '2022-05-30' })).toBe(false)
+  it('with relative date operators handles invalid keys', () => {
+    jest.setSystemTime(new Date('2022-05-01'))
 
     // # can't be an invalid string
-    expect(() => matchProperty(property_a, { key: 'abcdef' })).toThrow(InconclusiveMatchError)
+    expect(() => matchProperty({ key: 'key', value: '1d', operator: 'is_date_before' }, { key: 'abcdef' })).toThrow(
+      InconclusiveMatchError
+    )
     // however js understands numbers as date offsets from utc epoch
-    expect(() => matchProperty(property_a, { key: 1 })).not.toThrow(InconclusiveMatchError)
-
-    const property_b = { key: 'key', value: '1h', operator: 'is_date_after' }
-    expect(matchProperty(property_b, { key: '2022-05-02' })).toBe(true)
-    expect(matchProperty(property_b, { key: '2022-05-30' })).toBe(true)
-    expect(matchProperty(property_b, { key: new Date(2022, 4, 30) })).toBe(true)
-    expect(matchProperty(property_b, { key: new Date('2022-05-30') })).toBe(true)
-    expect(matchProperty(property_b, { key: '2022-04-30' })).toBe(false)
-
-    // # Try all possible relative dates
-    const property_e = { key: 'key', value: '1h', operator: 'is_date_before' }
-    expect(matchProperty(property_e, { key: '2022-05-01 00:00:00' })).toBe(false)
-    expect(matchProperty(property_e, { key: '2022-04-30 22:00:00' })).toBe(true)
-
-    const property_f = { key: 'key', value: '-1d', operator: 'is_date_before' }
-    expect(matchProperty(property_f, { key: '2022-04-29 23:59:00 GMT' })).toBe(true)
-    expect(matchProperty(property_f, { key: '2022-04-30 00:00:01 GMT' })).toBe(false)
-
-    const property_g = { key: 'key', value: '1w', operator: 'is_date_before' }
-    expect(matchProperty(property_g, { key: '2022-04-23 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_g, { key: '2022-04-24 00:00:00 GMT' })).toBe(false)
-    expect(matchProperty(property_g, { key: '2022-04-24 00:00:01 GMT' })).toBe(false)
-
-    const property_h = { key: 'key', value: '1m', operator: 'is_date_before' }
-    expect(matchProperty(property_h, { key: '2022-03-01 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_h, { key: '2022-04-05 00:00:00 GMT' })).toBe(false)
-
-    const property_i = { key: 'key', value: '-1y', operator: 'is_date_before' }
-    expect(matchProperty(property_i, { key: '2021-04-28 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_i, { key: '2021-05-01 00:00:01 GMT' })).toBe(false)
-
-    const property_j = { key: 'key', value: '122h', operator: 'is_date_after' }
-    expect(matchProperty(property_j, { key: '2022-05-01 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_j, { key: '2022-04-23 01:00:00 GMT' })).toBe(false)
-
-    const property_k = { key: 'key', value: '2d', operator: 'is_date_after' }
-    expect(matchProperty(property_k, { key: '2022-05-01 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_k, { key: '2022-04-29 00:00:01 GMT' })).toBe(true)
-    expect(matchProperty(property_k, { key: '2022-04-29 00:00:00 GMT' })).toBe(false)
-
-    const property_l = { key: 'key', value: '02w', operator: 'is_date_after' }
-    expect(matchProperty(property_l, { key: '2022-05-01 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_l, { key: '2022-04-16 00:00:00 GMT' })).toBe(false)
-
-    const property_m = { key: 'key', value: '-1m', operator: 'is_date_after' }
-    expect(matchProperty(property_m, { key: '2022-04-01 00:00:01 GMT' })).toBe(true)
-    expect(matchProperty(property_m, { key: '2022-04-01 00:00:00 GMT' })).toBe(false)
-
-    const property_n = { key: 'key', value: '1y', operator: 'is_date_after' }
-    expect(matchProperty(property_n, { key: '2022-05-01 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_n, { key: '2021-05-01 00:00:01 GMT' })).toBe(true)
-    expect(matchProperty(property_n, { key: '2021-05-01 00:00:00 GMT' })).toBe(false)
-    expect(matchProperty(property_n, { key: '2021-04-30 00:00:00 GMT' })).toBe(false)
-    expect(matchProperty(property_n, { key: '2021-03-01 12:13:00 GMT' })).toBe(false)
+    expect(() => matchProperty({ key: 'key', value: '1d', operator: 'is_date_before' }, { key: 1 })).not.toThrow(
+      InconclusiveMatchError
+    )
   })
 
   it('null or undefined property value', () => {

package/test/posthog-node.spec.ts

@@ -1,8 +1,7 @@
-// import { PostHog } from '../'
 import { PostHog as PostHog } from '../src/posthog-node'
 jest.mock('../src/fetch')
 import fetch from '../src/fetch'
-import { anyDecideCall, anyLocalEvalCall, apiImplementation } from './feature-flags.spec'
+import { anyDecideCall, anyLocalEvalCall, apiImplementation } from './test-utils'
 import { waitForPromises, wait } from '../../posthog-core/test/test-utils/test-utils'
 import { randomUUID } from 'crypto'
 
@@ -10,6 +9,14 @@ jest.mock('../package.json', () => ({ version: '1.2.3' }))
 
 const mockedFetch = jest.mocked(fetch, true)
 
+const waitForFlushTimer = async (): Promise<void> => {
+  await waitForPromises()
+  // To trigger the flush via the timer
+  jest.runOnlyPendingTimers()
+  // Then wait for the flush promise
+  await waitForPromises()
+}
+
 const getLastBatchEvents = (): any[] | undefined => {
   expect(mockedFetch).toHaveBeenCalledWith('http://example.com/batch/', expect.objectContaining({ method: 'POST' }))
 
@@ -43,8 +50,17 @@ describe('PostHog Node.js', () => {
   })
 
   afterEach(async () => {
+    mockedFetch.mockResolvedValue({
+      status: 200,
+      text: () => Promise.resolve('ok'),
+      json: () =>
+        Promise.resolve({
+          status: 'ok',
+        }),
+    } as any)
+
     // ensure clean shutdown & no test interdependencies
-    await posthog.shutdownAsync()
+    await posthog.shutdown()
   })
 
   describe('core methods', () => {
@@ -52,8 +68,7 @@ describe('PostHog Node.js', () => {
       expect(mockedFetch).toHaveBeenCalledTimes(0)
       posthog.capture({ distinctId: '123', event: 'test-event', properties: { foo: 'bar' }, groups: { org: 123 } })
 
-      await waitForPromises()
-      jest.runOnlyPendingTimers()
+      await waitForFlushTimer()
 
       const batchEvents = getLastBatchEvents()
       expect(batchEvents).toEqual([
@@ -80,8 +95,7 @@ describe('PostHog Node.js', () => {
       expect(mockedFetch).toHaveBeenCalledTimes(0)
       posthog.capture({ distinctId: '123', event: 'test-event', properties: { foo: 'bar' }, groups: { org: 123 } })
 
-      await waitForPromises()
-      jest.runOnlyPendingTimers()
+      await waitForFlushTimer()
       expect(getLastBatchEvents()?.[0]).toEqual(
         expect.objectContaining({
           distinct_id: '123',
@@ -103,8 +117,7 @@ describe('PostHog Node.js', () => {
         groups: { other_group: 'x' },
       })
 
-      await waitForPromises()
-      jest.runOnlyPendingTimers()
+      await waitForFlushTimer()
       expect(getLastBatchEvents()?.[0]).toEqual(
         expect.objectContaining({
           distinct_id: '123',
@@ -124,6 +137,8 @@ describe('PostHog Node.js', () => {
       expect(mockedFetch).toHaveBeenCalledTimes(0)
       posthog.identify({ distinctId: '123', properties: { foo: 'bar' } })
       jest.runOnlyPendingTimers()
+      await waitForPromises()
+
       const batchEvents = getLastBatchEvents()
       expect(batchEvents).toMatchObject([
         {
@@ -143,6 +158,7 @@ describe('PostHog Node.js', () => {
       expect(mockedFetch).toHaveBeenCalledTimes(0)
       posthog.identify({ distinctId: '123', properties: { foo: 'bar', $set: { foo: 'other' } } })
       jest.runOnlyPendingTimers()
+      await waitForPromises()
       const batchEvents = getLastBatchEvents()
       expect(batchEvents).toMatchObject([
         {
@@ -162,6 +178,7 @@ describe('PostHog Node.js', () => {
       expect(mockedFetch).toHaveBeenCalledTimes(0)
       posthog.alias({ distinctId: '123', alias: '1234' })
       jest.runOnlyPendingTimers()
+      await waitForPromises()
       const batchEvents = getLastBatchEvents()
       expect(batchEvents).toMatchObject([
         {
@@ -179,8 +196,7 @@ describe('PostHog Node.js', () => {
     it('should allow overriding timestamp', async () => {
       expect(mockedFetch).toHaveBeenCalledTimes(0)
       posthog.capture({ event: 'custom-time', distinctId: '123', timestamp: new Date('2021-02-03') })
-      await waitForPromises()
-      jest.runOnlyPendingTimers()
+      await waitForFlushTimer()
       const batchEvents = getLastBatchEvents()
       expect(batchEvents).toMatchObject([
         {
@@ -196,8 +212,7 @@ describe('PostHog Node.js', () => {
       expect(mockedFetch).toHaveBeenCalledTimes(0)
       const uuid = randomUUID()
       posthog.capture({ event: 'custom-time', distinctId: '123', uuid })
-      await waitForPromises()
-      jest.runOnlyPendingTimers()
+      await waitForFlushTimer()
       const batchEvents = getLastBatchEvents()
       expect(batchEvents).toMatchObject([
         {
@@ -219,8 +234,7 @@ describe('PostHog Node.js', () => {
         disableGeoip: false,
       })
 
-      await waitForPromises()
-      jest.runOnlyPendingTimers()
+      await waitForFlushTimer()
       const batchEvents = getLastBatchEvents()
       expect(batchEvents?.[0].properties).toEqual({
         $groups: { org: 123 },
@@ -238,8 +252,7 @@ describe('PostHog Node.js', () => {
       })
       client.capture({ distinctId: '123', event: 'test-event', properties: { foo: 'bar' }, groups: { org: 123 } })
 
-      await waitForPromises()
-      jest.runOnlyPendingTimers()
+      await waitForFlushTimer()
 
       let batchEvents = getLastBatchEvents()
       expect(batchEvents?.[0].properties).toEqual({
@@ -257,10 +270,9 @@ describe('PostHog Node.js', () => {
         disableGeoip: true,
       })
 
-      await waitForPromises()
-      jest.runOnlyPendingTimers()
+      await waitForFlushTimer()
+
       batchEvents = getLastBatchEvents()
-      console.warn(batchEvents)
       expect(batchEvents?.[0].properties).toEqual({
         $groups: { org: 123 },
         foo: 'bar',
@@ -277,8 +289,9 @@ describe('PostHog Node.js', () => {
         disableGeoip: false,
       })
 
+      await waitForFlushTimer()
       await waitForPromises()
-      jest.runOnlyPendingTimers()
+
       batchEvents = getLastBatchEvents()
       expect(batchEvents?.[0].properties).toEqual({
         $groups: { org: 123 },
@@ -287,16 +300,19 @@ describe('PostHog Node.js', () => {
         $lib_version: '1.2.3',
       })
 
-      await client.shutdownAsync()
+      await client.shutdown()
     })
   })
 
   describe('shutdown', () => {
+    let warnSpy: jest.SpyInstance, logSpy: jest.SpyInstance
     beforeEach(() => {
-      // a serverless posthog configuration
-      posthog = new PostHog('TEST_API_KEY', {
-        host: 'http://example.com',
-        fetchRetryCount: 0,
+      const actualLog = console.log
+      warnSpy = jest.spyOn(console, 'warn').mockImplementation((...args) => {
+        actualLog('spied warn:', ...args)
+      })
+      logSpy = jest.spyOn(console, 'log').mockImplementation((...args) => {
+        actualLog('spied log:', ...args)
       })
 
       mockedFetch.mockImplementation(async () => {
@@ -312,66 +328,69 @@ describe('PostHog Node.js', () => {
             }),
         } as any)
       })
+
+      jest.useRealTimers()
     })
 
     afterEach(() => {
-      posthog.debug(false)
       jest.useFakeTimers()
     })
 
     it('should shutdown cleanly', async () => {
-      posthog = new PostHog('TEST_API_KEY', {
+      const ph = new PostHog('TEST_API_KEY', {
         host: 'http://example.com',
         fetchRetryCount: 0,
         flushAt: 1,
       })
+      ph.debug(true)
 
-      const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
-      jest.useRealTimers()
       // using debug mode to check console.log output
       // which tells us when the flush is complete
-      posthog.debug(true)
-      for (let i = 0; i < 10; i++) {
-        posthog.capture({ event: 'test-event', distinctId: '123' })
-        // requests come 100ms apart
-        await wait(100)
-      }
 
-      // 10 capture calls to debug log
-      // 6 flush calls to debug log
-      expect(logSpy).toHaveBeenCalledTimes(16)
-      expect(10).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('capture')).length)
-      expect(6).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('flush')).length)
+      ph.capture({ event: 'test-event', distinctId: '123' })
+      await wait(100)
+      expect(logSpy).toHaveBeenCalledTimes(1)
+
+      ph.capture({ event: 'test-event', distinctId: '123' })
+      ph.capture({ event: 'test-event', distinctId: '123' })
+      await wait(100)
+      expect(logSpy).toHaveBeenCalledTimes(3)
+      await wait(400) // The flush will resolve in this time
+      ph.capture({ event: 'test-event', distinctId: '123' })
+      ph.capture({ event: 'test-event', distinctId: '123' })
+      await wait(100)
+      expect(logSpy).toHaveBeenCalledTimes(6) // 5 captures and 1 flush
+      expect(5).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('capture')).length)
+      expect(1).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('flush')).length)
 
       logSpy.mockClear()
+      expect(logSpy).toHaveBeenCalledTimes(0)
 
-      await posthog.shutdownAsync()
-      // remaining 4 flush calls to debug log
-      // happen during shutdown
-      expect(4).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('flush')).length)
-      jest.useFakeTimers()
+      console.warn('YOO!!')
+
+      await ph.shutdown()
+      // 1 final flush for the events that were queued during shutdown
+      expect(1).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('flush')).length)
       logSpy.mockRestore()
+      warnSpy.mockRestore()
     })
 
     it('should shutdown cleanly with pending capture flag promises', async () => {
-      posthog = new PostHog('TEST_API_KEY', {
+      const ph = new PostHog('TEST_API_KEY', {
         host: 'http://example.com',
         fetchRetryCount: 0,
         flushAt: 4,
       })
-
-      const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
-      jest.useRealTimers()
-      posthog.debug(true)
+      ph.debug(true)
 
       for (let i = 0; i < 10; i++) {
-        posthog.capture({ event: 'test-event', distinctId: `${i}`, sendFeatureFlags: true })
+        ph.capture({ event: 'test-event', distinctId: `${i}`, sendFeatureFlags: true })
       }
 
-      await posthog.shutdownAsync()
+      await ph.shutdown()
       // all capture calls happen during shutdown
       const batchEvents = getLastBatchEvents()
-      expect(batchEvents?.length).toEqual(2)
+      expect(batchEvents?.length).toEqual(6)
       expect(batchEvents?.[batchEvents?.length - 1]).toMatchObject({
         // last event in batch
         distinct_id: '9',
@@ -387,8 +406,8 @@ describe('PostHog Node.js', () => {
         type: 'capture',
       })
       expect(10).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('capture')).length)
-      expect(3).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('flush')).length)
-      jest.useFakeTimers()
+      // 1 for the captured events, 1 for the final flush of feature flag called events
+      expect(2).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('flush')).length)
       logSpy.mockRestore()
     })
   })
@@ -397,7 +416,7 @@ describe('PostHog Node.js', () => {
     it('should identify group with unique id', async () => {
       posthog.groupIdentify({ groupType: 'posthog', groupKey: 'team-1', properties: { analytics: true } })
       jest.runOnlyPendingTimers()
-      await posthog.flushAsync()
+      await posthog.flush()
       const batchEvents = getLastBatchEvents()
       expect(batchEvents).toMatchObject([
         {
@@ -422,7 +441,7 @@ describe('PostHog Node.js', () => {
         distinctId: '123',
       })
       jest.runOnlyPendingTimers()
-      await posthog.flushAsync()
+      await posthog.flush()
       const batchEvents = getLastBatchEvents()
       expect(batchEvents).toMatchObject([
         {
@@ -656,7 +675,7 @@ describe('PostHog Node.js', () => {
         false
       )
 
-      await posthog.shutdownAsync()
+      await posthog.shutdown()
     })
 
     it('doesnt add flag properties when locally evaluated flags are empty', async () => {
@@ -729,8 +748,7 @@ describe('PostHog Node.js', () => {
         disableGeoip: false,
       })
 
-      await waitForPromises()
-      jest.runOnlyPendingTimers()
+      await waitForFlushTimer()
 
       expect(mockedFetch).toHaveBeenCalledWith(
         'http://example.com/decide/?v=3',
@@ -858,7 +876,7 @@ describe('PostHog Node.js', () => {
       // TRICKY: There's now an extra step before events are queued, so need to wait for that to resolve
       jest.runOnlyPendingTimers()
       await waitForPromises()
-      await posthog.flushAsync()
+      await posthog.flush()
 
       expect(mockedFetch).toHaveBeenCalledWith('http://example.com/batch/', expect.any(Object))
 
@@ -887,7 +905,7 @@ describe('PostHog Node.js', () => {
       ).toEqual(true)
       jest.runOnlyPendingTimers()
       await waitForPromises()
-      await posthog.flushAsync()
+      await posthog.flush()
 
       expect(mockedFetch).not.toHaveBeenCalledWith('http://example.com/batch/', expect.any(Object))
 
@@ -901,7 +919,7 @@ describe('PostHog Node.js', () => {
       ).toEqual(true)
       jest.runOnlyPendingTimers()
       await waitForPromises()
-      await posthog.flushAsync()
+      await posthog.flush()
       expect(mockedFetch).toHaveBeenCalledWith('http://example.com/batch/', expect.any(Object))
 
       expect(getLastBatchEvents()?.[0]).toEqual(
@@ -930,7 +948,7 @@ describe('PostHog Node.js', () => {
       ).toEqual(true)
       jest.runOnlyPendingTimers()
       await waitForPromises()
-      await posthog.flushAsync()
+      await posthog.flush()
       expect(mockedFetch).not.toHaveBeenCalledWith('http://example.com/batch/', expect.any(Object))
 
       // # called for different flag, falls back to decide, should call capture again
@@ -942,7 +960,7 @@ describe('PostHog Node.js', () => {
       ).toEqual('decide-value')
       jest.runOnlyPendingTimers()
       await waitForPromises()
-      await posthog.flushAsync()
+      await posthog.flush()
       // one to decide, one to batch
       expect(mockedFetch).toHaveBeenCalledWith(...anyDecideCall)
       expect(mockedFetch).toHaveBeenCalledWith('http://example.com/batch/', expect.any(Object))
@@ -972,7 +990,7 @@ describe('PostHog Node.js', () => {
       ).toEqual(true)
       jest.runOnlyPendingTimers()
       await waitForPromises()
-      await posthog.flushAsync()
+      await posthog.flush()
       // call decide, but not batch
       expect(mockedFetch).toHaveBeenCalledWith(...anyDecideCall)
       expect(mockedFetch).not.toHaveBeenCalledWith('http://example.com/batch/', expect.any(Object))