myavana-bot-test-core 2.2.0 → 2.3.0

package/src/__tests__/personaClassifier.test.js

@@ -0,0 +1,253 @@
+const { pgClient, redisClient } = require('../database');
+
+jest.mock('../database', () => ({
+    pgClient: { query: jest.fn() },
+    redisClient: { get: jest.fn(), set: jest.fn() },
+}));
+
+const {
+    classifyFromSignals,
+    buildContextBlock,
+    saveUserPersona,
+    getUserPersona,
+    classifyAndSavePersona,
+    PERSONA_TYPES,
+    COMMUNICATION_STYLES,
+} = require('../personaClassifier');
+
+beforeEach(() => jest.clearAllMocks());
+
+describe('classifyFromSignals', () => {
+    test('overwhelmed: high desperation', () => {
+        const result = classifyFromSignals({
+            profileUpdates: { desperation_level_inferred: 'high' },
+            chatHistory: [],
+        });
+        expect(result.personaType).toBe(PERSONA_TYPES.OVERWHELMED);
+        expect(result.communicationStyle).toBe(COMMUNICATION_STYLES.NURTURING);
+        expect(result.toneDirectives).toContain('lead with empathy before solutions');
+    });
+
+    test('overwhelmed: low confidence', () => {
+        const result = classifyFromSignals({
+            profileUpdates: { confidence_level_inferred: 'low' },
+            chatHistory: [],
+        });
+        expect(result.personaType).toBe(PERSONA_TYPES.OVERWHELMED);
+    });
+
+    test('researcher: long messages', () => {
+        const longMessage = 'a'.repeat(210);
+        const result = classifyFromSignals({
+            profileUpdates: {},
+            chatHistory: [{ role: 'user', content: longMessage }],
+        });
+        expect(result.personaType).toBe(PERSONA_TYPES.RESEARCHER);
+        expect(result.communicationStyle).toBe(COMMUNICATION_STYLES.PROFESSIONAL);
+    });
+
+    test('researcher: high confidence', () => {
+        const result = classifyFromSignals({
+            profileUpdates: { confidence_level_inferred: 'high' },
+            chatHistory: [],
+        });
+        expect(result.personaType).toBe(PERSONA_TYPES.RESEARCHER);
+    });
+
+    test('explorer: experimenting interest', () => {
+        const result = classifyFromSignals({
+            profileUpdates: { experimenting_interest: true },
+            chatHistory: [],
+        });
+        expect(result.personaType).toBe(PERSONA_TYPES.EXPLORER);
+        expect(result.communicationStyle).toBe(COMMUNICATION_STYLES.CASUAL);
+        expect(result.toneDirectives).toContain('encourage curiosity and experimentation');
+    });
+
+    test('action-oriented: short messages after 3+ turns', () => {
+        const history = [
+            { role: 'user', content: 'hi' },
+            { role: 'user', content: 'ok' },
+            { role: 'user', content: 'yes' },
+        ];
+        const result = classifyFromSignals({ profileUpdates: {}, chatHistory: history });
+        expect(result.personaType).toBe(PERSONA_TYPES.ACTION_ORIENTED);
+        expect(result.communicationStyle).toBe(COMMUNICATION_STYLES.CONCISE);
+    });
+
+    test('engaged: default when no signals match', () => {
+        const result = classifyFromSignals({ profileUpdates: {}, chatHistory: [] });
+        expect(result.personaType).toBe(PERSONA_TYPES.ENGAGED);
+    });
+
+    test('boredom adds tone directive regardless of persona', () => {
+        const result = classifyFromSignals({
+            profileUpdates: { boredom_expression: true },
+            chatHistory: [],
+        });
+        expect(result.toneDirectives).toContain(
+            'vary your approach — try an unexpected angle or a direct question'
+        );
+    });
+
+    test('overwhelmed takes priority over researcher when both desperation and long messages', () => {
+        const result = classifyFromSignals({
+            profileUpdates: { desperation_level_inferred: 'high' },
+            chatHistory: [{ role: 'user', content: 'a'.repeat(210) }],
+        });
+        expect(result.personaType).toBe(PERSONA_TYPES.OVERWHELMED);
+    });
+});
+
+describe('buildContextBlock', () => {
+    test('returns formatted context string', () => {
+        const block = buildContextBlock({
+            personaType: 'overwhelmed',
+            communicationStyle: 'nurturing',
+            toneDirectives: ['lead with empathy'],
+        });
+        expect(block).toBe('[User persona: overwhelmed, style: nurturing — lead with empathy]\n');
+    });
+
+    test('returns empty string when personaType is missing', () => {
+        expect(buildContextBlock({})).toBe('');
+        expect(buildContextBlock()).toBe('');
+    });
+
+    test('omits directive separator when no directives and no trends', () => {
+        const block = buildContextBlock({
+            personaType: 'engaged',
+            communicationStyle: 'casual',
+            toneDirectives: [],
+        });
+        expect(block).toBe('[User persona: engaged, style: casual]\n');
+    });
+
+    test('joins multiple directives with semicolons', () => {
+        const block = buildContextBlock({
+            personaType: 'overwhelmed',
+            communicationStyle: 'nurturing',
+            toneDirectives: ['empathy first', 'small steps'],
+        });
+        expect(block).toContain('empathy first; small steps');
+    });
+
+    test('appends trend framing instruction when hasTrends=true', () => {
+        const block = buildContextBlock({
+            personaType: 'researcher',
+            communicationStyle: 'professional',
+            toneDirectives: [],
+        }, true);
+        expect(block).toContain('evidence or mechanism');
+    });
+
+    test('no trend framing when hasTrends=false', () => {
+        const block = buildContextBlock({
+            personaType: 'researcher',
+            communicationStyle: 'professional',
+            toneDirectives: [],
+        }, false);
+        expect(block).toBe('[User persona: researcher, style: professional]\n');
+    });
+
+    test('explorer gets casual trend framing when hasTrends=true', () => {
+        const block = buildContextBlock({
+            personaType: 'explorer',
+            communicationStyle: 'casual',
+            toneDirectives: [],
+        }, true);
+        expect(block).toContain('exciting things worth trying');
+    });
+});
+
+describe('saveUserPersona', () => {
+    test('upserts to PostgreSQL and sets Redis', async () => {
+        pgClient.query.mockResolvedValue({ rows: [] });
+        redisClient.set.mockResolvedValue('OK');
+
+        await saveUserPersona('u1', {
+            personaType: 'researcher',
+            communicationStyle: 'professional',
+            toneDirectives: ['skip basics'],
+        });
+
+        expect(pgClient.query).toHaveBeenCalledWith(
+            expect.stringContaining('INSERT INTO user_preferences'),
+            ['u1', 'researcher', 'professional', JSON.stringify({ toneDirectives: ['skip basics'] })]
+        );
+        expect(redisClient.set).toHaveBeenCalledWith(
+            'persona:u1',
+            JSON.stringify({ personaType: 'researcher', communicationStyle: 'professional', toneDirectives: ['skip basics'] }),
+            { EX: 86400 }
+        );
+    });
+
+    test('does not throw when PostgreSQL fails', async () => {
+        pgClient.query.mockRejectedValue(new Error('DB down'));
+        redisClient.set.mockResolvedValue('OK');
+        await expect(saveUserPersona('u1', { personaType: 'engaged', communicationStyle: 'casual', toneDirectives: [] })).resolves.not.toThrow();
+    });
+
+    test('does not throw when Redis fails', async () => {
+        pgClient.query.mockResolvedValue({ rows: [] });
+        redisClient.set.mockRejectedValue(new Error('Redis down'));
+        await expect(saveUserPersona('u1', { personaType: 'engaged', communicationStyle: 'casual', toneDirectives: [] })).resolves.not.toThrow();
+    });
+});
+
+describe('getUserPersona', () => {
+    test('returns from Redis cache when present', async () => {
+        const cached = { personaType: 'explorer', communicationStyle: 'casual', toneDirectives: [] };
+        redisClient.get.mockResolvedValue(JSON.stringify(cached));
+
+        const result = await getUserPersona('u1');
+        expect(result).toEqual(cached);
+        expect(pgClient.query).not.toHaveBeenCalled();
+    });
+
+    test('falls back to PostgreSQL when Redis miss', async () => {
+        redisClient.get.mockResolvedValue(null);
+        pgClient.query.mockResolvedValue({
+            rows: [{
+                persona_type: 'researcher',
+                communication_style: 'professional',
+                engagement_preferences: { toneDirectives: ['skip basics'] },
+            }],
+        });
+
+        const result = await getUserPersona('u1');
+        expect(result).toEqual({
+            personaType: 'researcher',
+            communicationStyle: 'professional',
+            toneDirectives: ['skip basics'],
+        });
+    });
+
+    test('returns null when not found anywhere', async () => {
+        redisClient.get.mockResolvedValue(null);
+        pgClient.query.mockResolvedValue({ rows: [] });
+        expect(await getUserPersona('u1')).toBeNull();
+    });
+
+    test('returns null and does not throw when Redis errors', async () => {
+        redisClient.get.mockRejectedValue(new Error('Redis error'));
+        pgClient.query.mockResolvedValue({ rows: [] });
+        expect(await getUserPersona('u1')).toBeNull();
+    });
+});
+
+describe('classifyAndSavePersona', () => {
+    test('classifies and saves, returns persona', async () => {
+        pgClient.query.mockResolvedValue({ rows: [] });
+        redisClient.set.mockResolvedValue('OK');
+
+        const result = await classifyAndSavePersona('u1', {
+            profileUpdates: { desperation_level_inferred: 'high' },
+            chatHistory: [],
+        });
+
+        expect(result.personaType).toBe(PERSONA_TYPES.OVERWHELMED);
+        expect(pgClient.query).toHaveBeenCalled();
+        expect(redisClient.set).toHaveBeenCalled();
+    });
+});

package/src/__tests__/postResponseProcessing.test.js

@@ -0,0 +1,199 @@
+const mockQuery = jest.fn();
+const mockRedisGet = jest.fn();
+const mockRedisSet = jest.fn();
+
+jest.mock('../database', () => ({
+    pgClient: { query: mockQuery },
+    redisClient: { get: mockRedisGet, set: mockRedisSet },
+}));
+
+const mockChatSend = jest.fn();
+const mockChat = jest.fn(() => ({ send: mockChatSend }));
+const mockUpdateState = jest.fn().mockResolvedValue({});
+const mockLoadSession = jest.fn().mockResolvedValue({ updateState: mockUpdateState });
+jest.mock('../ai', () => ({ chat: mockChat, loadSession: mockLoadSession }));
+jest.mock('@genkit-ai/google-genai', () => ({
+    googleAI: { model: jest.fn(() => 'mocked-model') },
+}));
+
+const mockSaveHairIssue = jest.fn();
+jest.mock('../hairIssues', () => ({ saveHairIssue: mockSaveHairIssue }));
+
+const mockGetProductByName = jest.fn();
+const mockAddProductRecommendation = jest.fn();
+jest.mock('../utils', () => ({
+    getProductByName: mockGetProductByName,
+    addProductRecommendation: mockAddProductRecommendation,
+}));
+
+const mockSaveConversation = jest.fn();
+const mockSaveConversationSummary = jest.fn();
+const mockGenerateAndSaveSummary = jest.fn();
+jest.mock('../conversation', () => ({
+    saveConversation: mockSaveConversation,
+    saveConversationSummary: mockSaveConversationSummary,
+    generateAndSaveSummary: mockGenerateAndSaveSummary,
+}));
+
+jest.mock('../session', () => jest.fn().mockImplementation(() => ({})));
+
+const {
+    updateUserProfile,
+    postResponseProductCheck,
+    postResponseProcessing,
+    postProcessConversation,
+} = require('../postResponseProcessing');
+
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+
+describe('updateUserProfile', () => {
+    test('does nothing when updates is empty', async () => {
+        const result = await updateUserProfile('u1', {});
+        expect(result).toBeNull();
+        expect(mockQuery).not.toHaveBeenCalled();
+    });
+
+    test('filters null values and updates DB + Redis', async () => {
+        mockQuery.mockResolvedValueOnce({ rows: [{ user_id: 'u1', hair_type: '4c' }] });
+        mockRedisSet.mockResolvedValue('OK');
+
+        const updates = { hair_type: '4c', porosity: null, name: 'Alex' };
+        const result = await updateUserProfile('u1', updates);
+
+        const dbCall = mockQuery.mock.calls.find(c => c[0].text && c[0].text.includes('UPDATE users'));
+        expect(dbCall).toBeDefined();
+        // null values should be filtered — only hair_type and name
+        expect(dbCall[0].values).not.toContain(null);
+        expect(mockRedisSet).toHaveBeenCalledWith('user:u1', expect.any(String));
+    });
+
+    test('returns null when user not found', async () => {
+        mockQuery.mockResolvedValueOnce({ rows: [] });
+
+        const result = await updateUserProfile('u1', { hair_type: '4c' });
+        expect(result).toBeNull();
+    });
+});
+
+describe('postResponseProductCheck', () => {
+    test('returns parsed product array on success', async () => {
+        const products = [{ productName: 'HairSI Kit', reason: 'For damage repair' }];
+        mockChatSend.mockResolvedValue({ output: JSON.stringify(products) });
+
+        const result = await postResponseProductCheck([], 'bot response');
+
+        expect(result).toEqual(products);
+    });
+
+    test('strips markdown code blocks before parsing', async () => {
+        const products = [{ productName: 'HairAI', reason: 'Quick analysis' }];
+        mockChatSend.mockResolvedValue({ output: '```json\n' + JSON.stringify(products) + '\n```' });
+
+        const result = await postResponseProductCheck([], 'bot response');
+
+        expect(result).toEqual(products);
+    });
+
+    test('returns empty array when output is empty', async () => {
+        mockChatSend.mockResolvedValue({ output: '' });
+
+        const result = await postResponseProductCheck([], 'bot response');
+
+        expect(result).toEqual([]);
+    });
+
+    test('returns empty array when output is []', async () => {
+        mockChatSend.mockResolvedValue({ output: '[]' });
+
+        const result = await postResponseProductCheck([], 'bot response');
+
+        expect(result).toEqual([]);
+    });
+
+    test('returns empty array when output is not a JSON array', async () => {
+        mockChatSend.mockResolvedValue({ output: '{"product": "x"}' });
+
+        const result = await postResponseProductCheck([], 'bot response');
+
+        expect(result).toEqual([]);
+    });
+
+    test('returns empty array on AI failure', async () => {
+        mockChat.mockImplementationOnce(() => { throw new Error('AI error'); });
+
+        const result = await postResponseProductCheck([], 'bot response');
+
+        expect(result).toEqual([]);
+    });
+});
+
+describe('postResponseProcessing', () => {
+    const history = [{ role: 'user', content: 'hi' }];
+
+    test('updates user profile when profile updates present', async () => {
+        mockQuery.mockResolvedValue({ rows: [{ user_id: 'u1' }] });
+        mockRedisSet.mockResolvedValue('OK');
+        mockChatSend.mockResolvedValue({ output: '[]' }); // product check
+        mockSaveConversation.mockResolvedValue({});
+        mockSaveConversationSummary.mockResolvedValue({});
+
+        const postProcessData = {
+            user_profile_updates: { hair_type: '4c' },
+            hair_issue_extractions: null,
+        };
+
+        await postResponseProcessing(postProcessData, 'u1', 'output', 'summary', 'c1', history, '{}');
+
+        const dbCall = mockQuery.mock.calls.find(c => c[0]?.text?.includes('UPDATE users'));
+        expect(dbCall).toBeDefined();
+    });
+
+    test('saves hair issues when present', async () => {
+        mockQuery.mockResolvedValue({ rows: [] });
+        mockChatSend.mockResolvedValue({ output: '[]' });
+        mockSaveConversation.mockResolvedValue({});
+        mockSaveConversationSummary.mockResolvedValue({});
+
+        const postProcessData = {
+            user_profile_updates: null,
+            hair_issue_extractions: { hair_issues_reported: ['dryness', 'breakage'] },
+        };
+
+        await postResponseProcessing(postProcessData, 'u1', 'output', 'summary', 'c1', history, '{}');
+
+        expect(mockSaveHairIssue).toHaveBeenCalledTimes(2);
+        expect(mockSaveHairIssue).toHaveBeenCalledWith('u1', 'dryness', expect.any(String));
+        expect(mockSaveHairIssue).toHaveBeenCalledWith('u1', 'breakage', expect.any(String));
+    });
+
+    test('saves product recommendations when products found', async () => {
+        mockQuery.mockResolvedValue({ rows: [] });
+        const products = [{ productName: 'HairSI Kit', reason: 'Damage repair' }];
+        mockChatSend.mockResolvedValue({ output: JSON.stringify(products) });
+        mockGetProductByName.mockResolvedValue({ product_id: 'p1' });
+        mockAddProductRecommendation.mockResolvedValue({});
+        mockSaveConversation.mockResolvedValue({});
+        mockSaveConversationSummary.mockResolvedValue({});
+
+        const postProcessData = { user_profile_updates: null, hair_issue_extractions: null };
+
+        await postResponseProcessing(postProcessData, 'u1', 'output', 'summary', 'c1', history, '{}');
+
+        expect(mockAddProductRecommendation).toHaveBeenCalledWith('u1', 'c1', 'p1', 'Damage repair');
+    });
+
+    test('saves conversation at end', async () => {
+        mockQuery.mockResolvedValue({ rows: [] });
+        mockChatSend.mockResolvedValue({ output: '[]' });
+        mockSaveConversation.mockResolvedValue({ conversation_id: 'c1' });
+        mockSaveConversationSummary.mockResolvedValue({});
+
+        const postProcessData = { user_profile_updates: null, hair_issue_extractions: null };
+
+        await postResponseProcessing(postProcessData, 'u1', 'output', 'summary', 'c1', history, '{}');
+
+        expect(mockSaveConversation).toHaveBeenCalledWith('c1', 'u1', history, 'summary');
+    });
+});

package/src/__tests__/trendManager.test.js

@@ -0,0 +1,166 @@
+const mockQuery = jest.fn();
+const mockRedisGet = jest.fn();
+const mockRedisSet = jest.fn();
+const mockRedisDel = jest.fn();
+
+jest.mock('../database', () => ({
+    pgClient: { query: mockQuery },
+    redisClient: { get: mockRedisGet, set: mockRedisSet, del: mockRedisDel },
+}));
+
+// Prevent real AI calls
+jest.mock('../ai', () => ({ generate: jest.fn() }));
+jest.mock('@genkit-ai/google-genai', () => ({
+    googleAI: { model: jest.fn(name => `mock:${name}`) },
+}));
+
+const { getTrendContext, getRelevantTrends, isTrendsStale, selectTrends } = require('../trendManager');
+
+const SAMPLE_TRENDS = [
+    { trend_name: 'Scalp Detox Routine',    description: 'Remove buildup for healthier growth', category: 'technique',   relevance_stages: [1, 3, 7], trend_score: 0.9 },
+    { trend_name: 'Rice Water Protein',     description: 'Fermented rice water strengthens strands', category: 'ingredient', relevance_stages: [6, 7],    trend_score: 0.85 },
+    { trend_name: 'Silk Bonnet Sleeping',   description: 'Reduce friction and retain moisture overnight', category: 'wellness',   relevance_stages: [2, 8],    trend_score: 0.75 },
+    { trend_name: 'Low Manipulation Braid', description: 'Protective styles for length retention', category: 'style',      relevance_stages: [4, 5, 6], trend_score: 0.7 },
+];
+
+beforeEach(() => jest.clearAllMocks());
+
+// ---------------------------------------------------------------------------
+// selectTrends
+// ---------------------------------------------------------------------------
+
+describe('selectTrends', () => {
+    test('returns empty array for empty input', () => {
+        expect(selectTrends([], 5, 3)).toEqual([]);
+    });
+
+    test('filters by stage and puts matches first', () => {
+        const result = selectTrends(SAMPLE_TRENDS, 6, 3);
+        expect(result[0].trend_name).toBe('Rice Water Protein');
+        expect(result).toHaveLength(3);
+    });
+
+    test('fills remaining slots with non-matching trends', () => {
+        const result = selectTrends(SAMPLE_TRENDS, 6, 4);
+        const names = result.map(t => t.trend_name);
+        expect(names).toContain('Rice Water Protein');
+        expect(names).toContain('Scalp Detox Routine'); // not stage 6 but fills slot
+    });
+
+    test('respects limit', () => {
+        expect(selectTrends(SAMPLE_TRENDS, null, 2)).toHaveLength(2);
+    });
+
+    test('returns top by score when stage is null', () => {
+        const result = selectTrends(SAMPLE_TRENDS, null, 2);
+        expect(result[0].trend_score).toBeGreaterThanOrEqual(result[1].trend_score);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// isTrendsStale
+// ---------------------------------------------------------------------------
+
+describe('isTrendsStale', () => {
+    test('returns true when no trends in DB', async () => {
+        mockQuery.mockResolvedValueOnce({ rows: [{ latest: null }] });
+        expect(await isTrendsStale()).toBe(true);
+    });
+
+    test('returns true when latest trend is older than 48h', async () => {
+        const old = new Date(Date.now() - 49 * 60 * 60 * 1000);
+        mockQuery.mockResolvedValueOnce({ rows: [{ latest: old }] });
+        expect(await isTrendsStale()).toBe(true);
+    });
+
+    test('returns false when trends are fresh', async () => {
+        const fresh = new Date(Date.now() - 1 * 60 * 60 * 1000);
+        mockQuery.mockResolvedValueOnce({ rows: [{ latest: fresh }] });
+        expect(await isTrendsStale()).toBe(false);
+    });
+
+    test('returns false without throwing when DB fails', async () => {
+        mockQuery.mockRejectedValueOnce(new Error('DB down'));
+        expect(await isTrendsStale()).toBe(false);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getRelevantTrends
+// ---------------------------------------------------------------------------
+
+describe('getRelevantTrends', () => {
+    test('returns from Redis cache when available', async () => {
+        mockRedisGet.mockResolvedValueOnce(JSON.stringify(SAMPLE_TRENDS));
+
+        const result = await getRelevantTrends(6, 2);
+        expect(mockQuery).not.toHaveBeenCalled();
+        expect(result).toHaveLength(2);
+        expect(result[0].trend_name).toBe('Rice Water Protein'); // stage 6 match first
+    });
+
+    test('falls back to DB when Redis misses', async () => {
+        mockRedisGet.mockResolvedValueOnce(null);
+        mockQuery.mockResolvedValueOnce({ rows: SAMPLE_TRENDS });
+        mockRedisSet.mockResolvedValueOnce('OK');
+
+        const result = await getRelevantTrends(null, 3);
+        expect(mockQuery).toHaveBeenCalled();
+        expect(result).toHaveLength(3);
+    });
+
+    test('populates Redis after DB fetch', async () => {
+        mockRedisGet.mockResolvedValueOnce(null);
+        mockQuery.mockResolvedValueOnce({ rows: SAMPLE_TRENDS });
+        mockRedisSet.mockResolvedValueOnce('OK');
+
+        await getRelevantTrends(null, 2);
+        expect(mockRedisSet).toHaveBeenCalledWith(
+            'hair_trends:current',
+            expect.any(String),
+            { EX: expect.any(Number) }
+        );
+    });
+
+    test('returns empty array without throwing when DB fails', async () => {
+        mockRedisGet.mockResolvedValueOnce(null);
+        mockQuery.mockRejectedValueOnce(new Error('DB down'));
+        expect(await getRelevantTrends(5, 2)).toEqual([]);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getTrendContext
+// ---------------------------------------------------------------------------
+
+describe('getTrendContext', () => {
+    test('returns formatted trend block', async () => {
+        mockRedisGet.mockResolvedValueOnce(JSON.stringify(SAMPLE_TRENDS));
+        // isTrendsStale call (background) → DB check
+        mockQuery.mockResolvedValue({ rows: [{ latest: new Date() }] });
+
+        const result = await getTrendContext(3, 'explorer');
+        expect(result).toMatch(/^\[Trending in hair care:/);
+        expect(result).toMatch(/\]\n$/);
+    });
+
+    test('returns empty string when no trends exist', async () => {
+        mockRedisGet.mockResolvedValueOnce(null);
+        mockQuery
+            .mockResolvedValueOnce({ rows: [] })             // getRelevantTrends DB query
+            .mockResolvedValueOnce({ rows: [{ latest: null }] }); // isTrendsStale
+
+        const result = await getTrendContext(null, null);
+        expect(result).toBe('');
+    });
+
+    test('trend names are lowercased in output', async () => {
+        mockRedisGet.mockResolvedValueOnce(JSON.stringify([
+            { trend_name: 'Scalp Detox Routine', relevance_stages: [], trend_score: 0.9 },
+        ]));
+        mockQuery.mockResolvedValue({ rows: [{ latest: new Date() }] });
+
+        const result = await getTrendContext(null, null);
+        expect(result).toContain('scalp detox routine');
+    });
+});