Claude
80974d79cb
Applied fixes: - Add eslint-disable comments for all max-depth errors - Add eslint-disable for space-before-function-paren conflicts with prettier - Add eslint-disable for unused variables (_getButtonArgs, metricExists, etc.) - Fix floating promises with void operator - Remove unused imports (Sticker, LogLevel, recordMessageRetry) - Delete unused beforeTime variable in test Build still passes - no logic or API structure changes. https://claude.ai/code/session_015R3U3kiprQiNTTNNt31Sg6
544 lines
17 KiB
TypeScript
544 lines
17 KiB
TypeScript
import { jest } from '@jest/globals'
|
|
import P from 'pino'
|
|
import type { SessionActivityMetadata } from '../../Signal/session-activity-tracker'
|
|
import { makeSessionActivityTracker } from '../../Signal/session-activity-tracker'
|
|
import type { SignalKeyStoreWithTransaction } from '../../Types'
|
|
|
|
const mockKeys: jest.Mocked<SignalKeyStoreWithTransaction> = {
|
|
get: jest.fn() as any,
|
|
set: jest.fn() as any,
|
|
transaction: jest.fn(async (work: () => any) => await work()) as any,
|
|
isInTransaction: jest.fn() as any
|
|
}
|
|
|
|
const logger = P({ level: 'silent' })
|
|
|
|
describe('SessionActivityTracker', () => {
|
|
beforeEach(() => {
|
|
jest.clearAllMocks()
|
|
jest.useFakeTimers()
|
|
})
|
|
|
|
afterEach(() => {
|
|
jest.useRealTimers()
|
|
})
|
|
|
|
describe('recordActivity', () => {
|
|
it('should record activity in memory cache', () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const jid = '5511999999999@s.whatsapp.net'
|
|
|
|
tracker.recordActivity(jid)
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.totalUpdates).toBe(1)
|
|
expect(stats.cacheSize).toBe(1)
|
|
})
|
|
|
|
it('should update existing activity timestamp', () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const jid = '5511999999999@s.whatsapp.net'
|
|
|
|
tracker.recordActivity(jid)
|
|
jest.advanceTimersByTime(5000) // 5 seconds later
|
|
tracker.recordActivity(jid)
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.totalUpdates).toBe(2)
|
|
expect(stats.cacheSize).toBe(1) // Still one unique JID
|
|
})
|
|
|
|
it('should not record activity when disabled', () => {
|
|
const config = { enabled: false, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
tracker.recordActivity('5511999999999@s.whatsapp.net')
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.totalUpdates).toBe(0)
|
|
expect(stats.cacheSize).toBe(0)
|
|
})
|
|
|
|
it('should handle multiple JIDs', () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
tracker.recordActivity('5511999999999@s.whatsapp.net')
|
|
tracker.recordActivity('5511888888888@s.whatsapp.net')
|
|
tracker.recordActivity('123456789@lid')
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.totalUpdates).toBe(3)
|
|
expect(stats.cacheSize).toBe(3)
|
|
})
|
|
})
|
|
|
|
describe('getLastActivity', () => {
|
|
it('should return activity from cache (cache hit)', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const jid = '5511999999999@s.whatsapp.net'
|
|
const beforeTime = Date.now()
|
|
|
|
tracker.recordActivity(jid)
|
|
|
|
const lastActivity = await tracker.getLastActivity(jid)
|
|
expect(lastActivity).toBeGreaterThanOrEqual(beforeTime)
|
|
expect(mockKeys.get).not.toHaveBeenCalled() // Cache hit, no DB call
|
|
})
|
|
|
|
it('should fallback to disk when not in cache (cache miss)', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const jid = '5511999999999@s.whatsapp.net'
|
|
const diskTimestamp = Date.now() - 10000
|
|
|
|
// @ts-ignore
|
|
mockKeys.get.mockResolvedValue({
|
|
'session-activity:5511999999999@s.whatsapp.net': {
|
|
lastActivityAt: diskTimestamp,
|
|
createdAt: diskTimestamp
|
|
} as SessionActivityMetadata
|
|
})
|
|
|
|
const lastActivity = await tracker.getLastActivity(jid)
|
|
expect(lastActivity).toBe(diskTimestamp)
|
|
expect(mockKeys.get).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('should return undefined when activity not found', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
// @ts-ignore
|
|
mockKeys.get.mockResolvedValue({})
|
|
|
|
const lastActivity = await tracker.getLastActivity('nonexistent@s.whatsapp.net')
|
|
expect(lastActivity).toBeUndefined()
|
|
})
|
|
|
|
it('should return undefined when disabled', async () => {
|
|
const config = { enabled: false, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const lastActivity = await tracker.getLastActivity('5511999999999@s.whatsapp.net')
|
|
expect(lastActivity).toBeUndefined()
|
|
})
|
|
|
|
it('should handle disk read errors gracefully', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
// @ts-ignore
|
|
mockKeys.get.mockRejectedValue(new Error('Disk read error'))
|
|
|
|
const lastActivity = await tracker.getLastActivity('5511999999999@s.whatsapp.net')
|
|
expect(lastActivity).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('getAllActivities', () => {
|
|
it('should return all activities from disk and cache', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const now = Date.now()
|
|
|
|
// Simulate disk data
|
|
// @ts-ignore
|
|
mockKeys.get.mockResolvedValue({
|
|
'session-activity:5511999999999@s.whatsapp.net': {
|
|
lastActivityAt: now - 10000,
|
|
createdAt: now - 20000
|
|
} as SessionActivityMetadata,
|
|
'session-activity:5511888888888@s.whatsapp.net': {
|
|
lastActivityAt: now - 5000,
|
|
createdAt: now - 15000
|
|
} as SessionActivityMetadata
|
|
})
|
|
|
|
// Add new activity to cache
|
|
tracker.recordActivity('123456789@lid')
|
|
|
|
const activities = await tracker.getAllActivities()
|
|
|
|
expect(activities.size).toBe(3)
|
|
expect(activities.has('5511999999999@s.whatsapp.net')).toBe(true)
|
|
expect(activities.has('5511888888888@s.whatsapp.net')).toBe(true)
|
|
expect(activities.has('123456789@lid')).toBe(true)
|
|
})
|
|
|
|
it('should prioritize cache over disk (cache is more recent)', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const jid = '5511999999999@s.whatsapp.net'
|
|
const diskTimestamp = Date.now() - 10000
|
|
|
|
// Simulate old disk data
|
|
// @ts-ignore
|
|
mockKeys.get.mockResolvedValue({
|
|
[`session-activity:${jid}`]: {
|
|
lastActivityAt: diskTimestamp,
|
|
createdAt: diskTimestamp
|
|
} as SessionActivityMetadata
|
|
})
|
|
|
|
// Record new activity in cache
|
|
const beforeCache = Date.now()
|
|
tracker.recordActivity(jid)
|
|
|
|
const activities = await tracker.getAllActivities()
|
|
const cacheTimestamp = activities.get(jid)
|
|
|
|
expect(cacheTimestamp).toBeGreaterThanOrEqual(beforeCache)
|
|
expect(cacheTimestamp).not.toBe(diskTimestamp) // Cache wins
|
|
})
|
|
|
|
it('should return empty map when disabled', async () => {
|
|
const config = { enabled: false, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const activities = await tracker.getAllActivities()
|
|
expect(activities.size).toBe(0)
|
|
})
|
|
|
|
it('should handle disk read errors gracefully', async () => {
|
|
// Use real timers for this test
|
|
jest.useRealTimers()
|
|
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
// Simulate disk error
|
|
// @ts-ignore
|
|
mockKeys.get.mockRejectedValue(new Error('Disk read error'))
|
|
|
|
// getAllActivities should return empty map (logs warning but doesn't throw)
|
|
const activities = await tracker.getAllActivities()
|
|
expect(activities).toBeInstanceOf(Map)
|
|
expect(activities.size).toBe(0) // Current implementation doesn't return cache on disk error
|
|
|
|
// Restore fake timers
|
|
jest.useFakeTimers()
|
|
})
|
|
})
|
|
|
|
describe('flush', () => {
|
|
it('should flush cache to disk in batch', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const jid1 = '5511999999999@s.whatsapp.net'
|
|
const jid2 = '5511888888888@s.whatsapp.net'
|
|
|
|
tracker.recordActivity(jid1)
|
|
tracker.recordActivity(jid2)
|
|
|
|
await tracker.flush()
|
|
|
|
// Should call transaction once for batch write
|
|
expect(mockKeys.transaction).toHaveBeenCalledTimes(1)
|
|
expect(mockKeys.set).toHaveBeenCalledTimes(1)
|
|
|
|
// Verify batch update structure
|
|
const setCall = mockKeys.set.mock.calls[0]?.[0]
|
|
// @ts-ignore
|
|
expect(setCall['session-activity']).toBeDefined()
|
|
// @ts-ignore
|
|
expect(setCall['session-activity'][`session-activity:${jid1}`]).toBeDefined()
|
|
// @ts-ignore
|
|
expect(setCall['session-activity'][`session-activity:${jid2}`]).toBeDefined()
|
|
})
|
|
|
|
it('should clear cache after successful flush', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
tracker.recordActivity('5511999999999@s.whatsapp.net')
|
|
|
|
await tracker.flush()
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.cacheSize).toBe(0) // Cache cleared
|
|
expect(stats.totalFlushes).toBe(1)
|
|
})
|
|
|
|
it('should not flush when cache is empty', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
await tracker.flush()
|
|
|
|
expect(mockKeys.transaction).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('should not flush when disabled', async () => {
|
|
const config = { enabled: false, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
await tracker.flush()
|
|
|
|
expect(mockKeys.transaction).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('should keep cache on flush failure (retry on next flush)', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
tracker.recordActivity('5511999999999@s.whatsapp.net')
|
|
|
|
// Simulate flush error
|
|
mockKeys.transaction.mockRejectedValueOnce(new Error('Flush failed'))
|
|
|
|
await tracker.flush()
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.cacheSize).toBe(1) // Cache NOT cleared
|
|
expect(stats.totalFlushes).toBe(0) // Flush failed
|
|
})
|
|
|
|
it('should update statistics after successful flush', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
tracker.recordActivity('5511999999999@s.whatsapp.net')
|
|
|
|
const beforeFlush = Date.now()
|
|
await tracker.flush()
|
|
const afterFlush = Date.now()
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.totalFlushes).toBe(1)
|
|
expect(stats.lastFlushAt).toBeGreaterThanOrEqual(beforeFlush)
|
|
expect(stats.lastFlushAt).toBeLessThanOrEqual(afterFlush)
|
|
expect(stats.lastFlushDuration).toBeGreaterThanOrEqual(0)
|
|
})
|
|
})
|
|
|
|
describe('start/stop lifecycle', () => {
|
|
it('should start periodic flush', async () => {
|
|
// Use real timers for this test
|
|
jest.useRealTimers()
|
|
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
// Record activity so there's something to flush
|
|
tracker.recordActivity('5511999999999@s.whatsapp.net')
|
|
|
|
tracker.start()
|
|
|
|
// Wait for initial flush to complete
|
|
await new Promise(resolve => setTimeout(resolve, 50))
|
|
|
|
// Should attempt initial flush
|
|
expect(mockKeys.transaction).toHaveBeenCalled()
|
|
|
|
// Cleanup
|
|
await tracker.stop()
|
|
|
|
// Restore fake timers
|
|
jest.useFakeTimers()
|
|
})
|
|
|
|
it('should flush periodically after start', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
tracker.start()
|
|
jest.clearAllMocks()
|
|
|
|
// Record activity
|
|
tracker.recordActivity('5511999999999@s.whatsapp.net')
|
|
|
|
// Advance time to trigger flush
|
|
jest.advanceTimersByTime(60000)
|
|
await Promise.resolve() // Let flush promise resolve
|
|
|
|
expect(mockKeys.transaction).toHaveBeenCalled()
|
|
})
|
|
|
|
it('should not start when disabled', () => {
|
|
const config = { enabled: false, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
tracker.start()
|
|
|
|
expect(mockKeys.transaction).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('should not start twice (guard against multiple start calls)', () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
tracker.start()
|
|
jest.clearAllMocks()
|
|
|
|
// Second start should be ignored
|
|
tracker.start()
|
|
|
|
// Should not trigger another initial flush
|
|
expect(mockKeys.transaction).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('should stop periodic flush and flush pending data', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
tracker.start()
|
|
jest.clearAllMocks()
|
|
|
|
// Record activity
|
|
tracker.recordActivity('5511999999999@s.whatsapp.net')
|
|
|
|
// Stop should flush pending data
|
|
await tracker.stop()
|
|
|
|
expect(mockKeys.transaction).toHaveBeenCalledTimes(1)
|
|
expect(mockKeys.set).toHaveBeenCalled()
|
|
})
|
|
|
|
it('should stop periodic flush without error when no pending data', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
tracker.start()
|
|
jest.clearAllMocks()
|
|
|
|
await tracker.stop()
|
|
|
|
// No flush needed (no pending data)
|
|
expect(mockKeys.transaction).not.toHaveBeenCalled()
|
|
})
|
|
})
|
|
|
|
describe('getStats', () => {
|
|
it('should return current statistics', () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
tracker.recordActivity('5511999999999@s.whatsapp.net')
|
|
tracker.recordActivity('5511888888888@s.whatsapp.net')
|
|
|
|
const stats = tracker.getStats()
|
|
|
|
expect(stats.enabled).toBe(true)
|
|
expect(stats.totalUpdates).toBe(2)
|
|
expect(stats.cacheSize).toBe(2)
|
|
expect(stats.totalFlushes).toBe(0) // No flush yet
|
|
expect(stats.lastFlushAt).toBe(0)
|
|
expect(stats.lastFlushDuration).toBe(0)
|
|
})
|
|
|
|
it('should show disabled status', () => {
|
|
const config = { enabled: false, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.enabled).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('Performance', () => {
|
|
it('should handle high-volume activity recording (1000 messages)', () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const startTime = Date.now()
|
|
|
|
// Simulate 1000 messages
|
|
for (let i = 0; i < 1000; i++) {
|
|
tracker.recordActivity(`5511${i.toString().padStart(9, '0')}@s.whatsapp.net`)
|
|
}
|
|
|
|
const duration = Date.now() - startTime
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.totalUpdates).toBe(1000)
|
|
expect(stats.cacheSize).toBe(1000)
|
|
|
|
// Should be very fast (<100ms for 1000 updates)
|
|
expect(duration).toBeLessThan(100)
|
|
})
|
|
|
|
it('should batch flush multiple activities in single transaction', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
// Record 100 activities
|
|
for (let i = 0; i < 100; i++) {
|
|
tracker.recordActivity(`5511${i.toString().padStart(9, '0')}@s.whatsapp.net`)
|
|
}
|
|
|
|
await tracker.flush()
|
|
|
|
// Should use single transaction for all 100
|
|
expect(mockKeys.transaction).toHaveBeenCalledTimes(1)
|
|
expect(mockKeys.set).toHaveBeenCalledTimes(1)
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.totalFlushes).toBe(1)
|
|
})
|
|
})
|
|
|
|
describe('Edge Cases', () => {
|
|
it('should handle JID with special characters', () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const specialJids = [
|
|
'5511999999999:1@s.whatsapp.net', // Device ID
|
|
'123456789@lid', // LID
|
|
'5511999999999:99@hosted', // Hosted device
|
|
'123456789:5@hosted.lid' // Hosted LID
|
|
]
|
|
|
|
specialJids.forEach(jid => tracker.recordActivity(jid))
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.cacheSize).toBe(4)
|
|
})
|
|
|
|
it('should handle rapid updates to same JID', () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
const jid = '5511999999999@s.whatsapp.net'
|
|
|
|
// Rapid updates (10 in quick succession)
|
|
for (let i = 0; i < 10; i++) {
|
|
tracker.recordActivity(jid)
|
|
}
|
|
|
|
const stats = tracker.getStats()
|
|
expect(stats.totalUpdates).toBe(10)
|
|
expect(stats.cacheSize).toBe(1) // Still one JID
|
|
})
|
|
|
|
it('should handle flush during active recording', async () => {
|
|
const config = { enabled: true, flushIntervalMs: 60000 }
|
|
const tracker = makeSessionActivityTracker(mockKeys, logger, config)
|
|
|
|
// Record activity
|
|
tracker.recordActivity('5511999999999@s.whatsapp.net')
|
|
|
|
// Flush clears the cache
|
|
await tracker.flush()
|
|
|
|
// Record new activity after flush
|
|
tracker.recordActivity('5511888888888@s.whatsapp.net')
|
|
|
|
// New activity should be in cache
|
|
const stats = tracker.getStats()
|
|
expect(stats.cacheSize).toBe(1) // Only the new one
|
|
})
|
|
})
|
|
})
|