chore: add tests

joshsny · joshsny · commit c636cb76462a · 2025-03-12T11:26:01.000Z
diff --git a/src/__tests__/personProcessing.test.ts b/src/__tests__/personProcessing.test.ts
@@ -813,4 +813,120 @@ describe('person processing', () => {
             expect(beforeSendMock.mock.calls[1][0].properties.$process_person_profile).toEqual(false)
         })
     })
+
+    describe('property calls deduplication', () => {
+        it('should dedupe identical consecutive calls to setPersonProperties', async () => {
+            const { posthog, beforeSendMock } = await setup('always')
+
+            posthog.setPersonProperties({ email: 'john@example.com' })
+            posthog.setPersonProperties({ email: 'john@example.com' })
+
+            expect(beforeSendMock).toHaveBeenCalledTimes(1)
+            expect(beforeSendMock).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    event: '$set',
+                    properties: expect.objectContaining({
+                        $set: { email: 'john@example.com' },
+                        $set_once: {},
+                    }),
+                })
+            )
+        })
+
+        it('should not dedupe when properties are different', async () => {
+            const { posthog, beforeSendMock } = await setup('always')
+
+            posthog.setPersonProperties({ email: 'john@example.com' })
+            posthog.setPersonProperties({ email: 'john.doe@example.com' })
+
+            expect(beforeSendMock).toHaveBeenCalledTimes(2)
+        })
+
+        it('should not dedupe when set_once properties are different', async () => {
+            const { posthog, beforeSendMock } = await setup('always')
+
+            posthog.setPersonProperties({ email: 'john@example.com' }, { first_seen: 'today' })
+            posthog.setPersonProperties({ email: 'john@example.com' }, { first_seen: 'yesterday' })
+
+            expect(beforeSendMock).toHaveBeenCalledTimes(2)
+        })
+
+        it('does not dedupe when properties are in different order but identical', async () => {
+            const { posthog, beforeSendMock } = await setup('always')
+
+            posthog.setPersonProperties({ name: 'John', email: 'john@example.com' })
+            posthog.setPersonProperties({ email: 'john@example.com', name: 'John' })
+
+            expect(beforeSendMock).toHaveBeenCalledTimes(2)
+        })
+
+        it('should log a message when deduping properties', async () => {
+            const { posthog } = await setup('always')
+            mockLogger.info = jest.fn()
+
+            posthog.setPersonProperties({ email: 'john@example.com' })
+            posthog.setPersonProperties({ email: 'john@example.com' })
+
+            expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining('duplicate'))
+        })
+
+        it('should not dedupe after distinct_id changes', async () => {
+            const { posthog, beforeSendMock } = await setup('always')
+
+            posthog.setPersonProperties({ email: 'john@example.com' })
+
+            posthog.identify('new-id')
+
+            posthog.setPersonProperties({ email: 'john@example.com' })
+
+            // 1 for setPersonProperties, 1 for identify, 1 for second setPersonProperties
+            expect(beforeSendMock).toHaveBeenCalledTimes(3)
+        })
+
+        it('should dedupe when using people.set with identical properties', async () => {
+            const { posthog, beforeSendMock } = await setup('always')
+
+            posthog.people.set({ email: 'john@example.com' })
+            posthog.people.set({ email: 'john@example.com' })
+
+            expect(beforeSendMock).toHaveBeenCalledTimes(1)
+        })
+
+        it('should dedupe when mixing people.set and setPersonProperties with identical properties', async () => {
+            const { posthog, beforeSendMock } = await setup('always')
+
+            posthog.people.set({ email: 'john@example.com' })
+            posthog.setPersonProperties({ email: 'john@example.com' })
+
+            expect(beforeSendMock).toHaveBeenCalledTimes(1)
+        })
+
+        it('should dedupe when using people.set_once with identical properties', async () => {
+            const { posthog, beforeSendMock } = await setup('always')
+
+            posthog.people.set_once({ first_seen: 'today' })
+            posthog.people.set_once({ first_seen: 'today' })
+
+            expect(beforeSendMock).toHaveBeenCalledTimes(1)
+        })
+
+        it('should not dedupe when mixing set and set_once with same properties', async () => {
+            const { posthog, beforeSendMock } = await setup('always')
+
+            posthog.people.set({ email: 'john@example.com' })
+            posthog.people.set_once({ email: 'john@example.com' })
+
+            expect(beforeSendMock).toHaveBeenCalledTimes(2)
+        })
+
+        it('should reset deduplication cache after reset()', async () => {
+            const { posthog, beforeSendMock } = await setup('always')
+
+            posthog.setPersonProperties({ email: 'john@example.com' })
+            posthog.reset()
+            posthog.setPersonProperties({ email: 'john@example.com' })
+
+            expect(beforeSendMock).toHaveBeenCalledTimes(2)
+        })
+    })
 })
diff --git a/src/__tests__/posthog-core.identify.test.ts b/src/__tests__/posthog-core.identify.test.ts
@@ -344,4 +344,100 @@ describe('identify()', () => {
             expect(instance.featureFlags.setAnonymousDistinctId).not.toHaveBeenCalled()
         })
     })
+
+    describe('identify deduplication', () => {
+        beforeEach(() => {
+            instance.persistence!.props['distinct_id'] = 'oldIdentity'
+        })
+
+        it('dedupes identical consecutive property updates with same identity', () => {
+            instance.identify('new-user', { email: 'john@example.com' })
+
+            instance.identify('new-user', { email: 'john@example.com' })
+
+            // Should only send one $identify and no additional $set
+            expect(beforeSendMock).toHaveBeenCalledTimes(1)
+            expect(beforeSendMock).toHaveBeenCalledWith(expect.objectContaining({ event: '$identify' }))
+        })
+
+        it('does not dedupe when properties are different', () => {
+            instance.identify('new-user', { email: 'john@example.com' })
+            instance.identify('new-user', { email: 'john.doe@example.com' })
+
+            // Should send one $identify and one $set
+            expect(beforeSendMock).toHaveBeenCalledTimes(2)
+            expect(beforeSendMock.mock.calls[0][0].event).toBe('$identify')
+            expect(beforeSendMock.mock.calls[1][0].event).toBe('$set')
+        })
+
+        it('does not dedupe when set_once properties are different', () => {
+            instance.identify('new-user', { email: 'john@example.com' }, { first_seen: 'today' })
+            instance.identify('new-user', { email: 'john@example.com' }, { first_seen: 'yesterday' })
+
+            // Should send one $identify and one $set
+            expect(beforeSendMock).toHaveBeenCalledTimes(2)
+            expect(beforeSendMock.mock.calls[0][0].event).toBe('$identify')
+            expect(beforeSendMock.mock.calls[1][0].event).toBe('$set')
+        })
+
+        it('does not dedupe when properties are identical but in different order', () => {
+            instance.identify('new-user', { name: 'John', email: 'john@example.com' })
+            instance.identify('new-user', { email: 'john@example.com', name: 'John' })
+
+            expect(beforeSendMock).toHaveBeenCalledTimes(2)
+        })
+
+        it('does not dedupe when identity changes', () => {
+            instance.identify('user-1', { email: 'john@example.com' })
+            instance.identify('user-2', { email: 'john@example.com' })
+
+            // Should send two $identify events
+            expect(beforeSendMock).toHaveBeenCalledTimes(2)
+            expect(beforeSendMock.mock.calls[0][0].event).toBe('$identify')
+            expect(beforeSendMock.mock.calls[1][0].event).toBe('$identify')
+        })
+
+        it('logs a message when deduping properties', () => {
+            console.info = jest.fn()
+
+            instance.identify('new-user', { email: 'john@example.com' })
+            instance.identify('new-user', { email: 'john@example.com' })
+
+            expect(console.info).toHaveBeenCalledWith(expect.stringContaining('duplicate'))
+        })
+
+        it('dedupes when mixing identify and setPersonProperties with identical properties', () => {
+            instance.identify('new-user', { email: 'john@example.com' })
+            instance.setPersonProperties({ email: 'john@example.com' })
+
+            console.log(beforeSendMock.mock.calls)
+
+            // Should only send one $identify
+            expect(beforeSendMock).toHaveBeenCalledTimes(1)
+            expect(beforeSendMock.mock.calls[0][0].event).toBe('$identify')
+        })
+
+        it('does not dedupe after reset()', () => {
+            instance.identify('new-user', { email: 'john@example.com' })
+
+            instance.reset()
+            instance.persistence!.props['distinct_id'] = 'oldIdentity' // Reset to trigger a new identify
+
+            instance.identify('new-user', { email: 'john@example.com' })
+
+            // Should send two $identify events
+            expect(beforeSendMock).toHaveBeenCalledTimes(2)
+            expect(beforeSendMock.mock.calls[0][0].event).toBe('$identify')
+            expect(beforeSendMock.mock.calls[1][0].event).toBe('$identify')
+        })
+
+        it('dedupes when no properties are passed in consecutive calls', () => {
+            instance.identify('new-user')
+            instance.identify('new-user')
+
+            // Should only send one $identify
+            expect(beforeSendMock).toHaveBeenCalledTimes(1)
+            expect(beforeSendMock.mock.calls[0][0].event).toBe('$identify')
+        })
+    })
 })
diff --git a/src/__tests__/utils.test.ts b/src/__tests__/utils.test.ts
@@ -13,6 +13,7 @@ import { isLikelyBot, DEFAULT_BLOCKED_UA_STRS, isBlockedUA, NavigatorUAData } fr
 import { expect } from '@jest/globals'
 
 import { _base64Encode } from '../utils/encode-utils'
+import { getPersonPropertiesHash } from '../utils/identify-utils'
 
 function userAgentFor(botString: string) {
     const randOne = (Math.random() + 1).toString(36).substring(7)
@@ -314,4 +315,101 @@ describe('utils', () => {
             expect(_base64Encode(input)).toBe(expectedOutput)
         })
     })
+
+    describe('getPersonPropertiesHash', () => {
+        it('returns a string hash with only distinct_id', () => {
+            const hash = getPersonPropertiesHash('user123')
+            expect(typeof hash).toBe('string')
+            expect(hash).toContain('user123')
+        })
+
+        it('returns the same hash for the same inputs', () => {
+            const distinct_id = 'user123'
+            const userPropertiesToSet = { name: 'John Doe', email: 'john@example.com' }
+            const userPropertiesToSetOnce = { first_seen: '2023-01-01' }
+
+            const hash1 = getPersonPropertiesHash(distinct_id, userPropertiesToSet, userPropertiesToSetOnce)
+            const hash2 = getPersonPropertiesHash(distinct_id, userPropertiesToSet, userPropertiesToSetOnce)
+
+            expect(hash1).toBe(hash2)
+        })
+
+        it('returns different hashes for different distinct_ids', () => {
+            const props = { name: 'John Doe' }
+            const hash1 = getPersonPropertiesHash('user1', props)
+            const hash2 = getPersonPropertiesHash('user2', props)
+
+            expect(hash1).not.toBe(hash2)
+        })
+
+        it('returns different hashes for different userPropertiesToSet', () => {
+            const distinct_id = 'user123'
+            const hash1 = getPersonPropertiesHash(distinct_id, { name: 'John' })
+            const hash2 = getPersonPropertiesHash(distinct_id, { name: 'Jane' })
+
+            expect(hash1).not.toBe(hash2)
+        })
+
+        it('returns different hashes for different userPropertiesToSetOnce', () => {
+            const distinct_id = 'user123'
+            const hash1 = getPersonPropertiesHash(distinct_id, undefined, { first_seen: '2023-01-01' })
+            const hash2 = getPersonPropertiesHash(distinct_id, undefined, { first_seen: '2023-02-01' })
+
+            expect(hash1).not.toBe(hash2)
+        })
+
+        it('includes all parameters in the hash', () => {
+            const distinct_id = 'user123'
+            const userPropertiesToSet = { name: 'John Doe' }
+            const userPropertiesToSetOnce = { first_seen: '2023-01-01' }
+
+            const hash = getPersonPropertiesHash(distinct_id, userPropertiesToSet, userPropertiesToSetOnce)
+
+            expect(hash).toContain('user123')
+            expect(hash).toContain('John Doe')
+            expect(hash).toContain('2023-01-01')
+        })
+
+        it('handles undefined userPropertiesToSet', () => {
+            const distinct_id = 'user123'
+            const userPropertiesToSetOnce = { first_seen: '2023-01-01' }
+
+            const hash = getPersonPropertiesHash(distinct_id, undefined, userPropertiesToSetOnce)
+
+            expect(hash).toContain('user123')
+            expect(hash).toContain('2023-01-01')
+            expect(hash).not.toContain('undefined')
+        })
+
+        it('handles undefined userPropertiesToSetOnce', () => {
+            const distinct_id = 'user123'
+            const userPropertiesToSet = { name: 'John Doe' }
+
+            const hash = getPersonPropertiesHash(distinct_id, userPropertiesToSet)
+
+            expect(hash).toContain('user123')
+            expect(hash).toContain('John Doe')
+        })
+
+        it('handles complex nested properties', () => {
+            const distinct_id = 'user123'
+            const userPropertiesToSet = {
+                profile: {
+                    name: 'John Doe',
+                    contacts: ['email', 'phone'],
+                    details: {
+                        age: 30,
+                        location: 'New York',
+                    },
+                },
+            }
+
+            const hash = getPersonPropertiesHash(distinct_id, userPropertiesToSet)
+
+            expect(typeof hash).toBe('string')
+            expect(hash).toContain('user123')
+            expect(hash).toContain('John Doe')
+            expect(hash).toContain('New York')
+        })
+    })
 })
diff --git a/src/posthog-core.ts b/src/posthog-core.ts
@@ -1469,6 +1469,14 @@ export class PostHog {
                 },
                 { $set: userPropertiesToSet || {}, $set_once: userPropertiesToSetOnce || {} }
             )
+
+            this._cachedPersonProperties = getPersonPropertiesHash(
+                new_distinct_id,
+                userPropertiesToSet,
+                userPropertiesToSetOnce
+            )
+
+            logger.info('this._cachedPersonProperties', this._cachedPersonProperties)
             // let the reload feature flag request know to send this previous distinct id
             // for flag consistency
             this.featureFlags.setAnonymousDistinctId(previous_distinct_id)
