graphs/backend/test/analyticsService.test.js

const assert = require('node:assert/strict');
const test = require('node:test');

const {
    buildRfmClients,
    buildRfmSegments,
    buildDateFilter,
    getPreviousDate,
    getRecencyScore,
    getRfmAnalytics,
    getRfmSegment,
    normalizeDateParam,
    scoreTertile
} = require('../services/analyticsService');
const { pool } = require('../db');

test('normalizeDateParam accepts strict ISO dates', () => {
    assert.equal(normalizeDateParam('2026-05-28'), '2026-05-28');
});

test('normalizeDateParam rejects non-ISO or impossible dates', () => {
    assert.equal(normalizeDateParam('28/05/2026'), null);
    assert.equal(normalizeDateParam('2026-02-31'), null);
    assert.equal(normalizeDateParam(''), null);
});

test('buildDateFilter builds bounded date predicates', () => {
    const filter = buildDateFilter({ start: '2026-05-01', end: '2026-05-28' });

    assert.deepEqual(filter.params, ['2026-05-01', '2026-05-28']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date >= $1::date AND data_pedido_date <= $2::date'
    );
});

test('buildDateFilter builds Hoje as an inclusive single-day date predicate', () => {
    const filter = buildDateFilter({ start: '2026-06-15', end: '2026-06-15' });

    assert.deepEqual(filter.params, ['2026-06-15', '2026-06-15']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date >= $1::date AND data_pedido_date <= $2::date'
    );
});

test('buildDateFilter builds Ontem as an inclusive single-day date predicate', () => {
    const filter = buildDateFilter({ start: '2026-06-14', end: '2026-06-14' });

    assert.deepEqual(filter.params, ['2026-06-14', '2026-06-14']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date >= $1::date AND data_pedido_date <= $2::date'
    );
});

test('buildDateFilter builds Ultimos 7 dias as an inclusive calendar range', () => {
    const filter = buildDateFilter({ start: '2026-06-09', end: '2026-06-15' });

    assert.deepEqual(filter.params, ['2026-06-09', '2026-06-15']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date >= $1::date AND data_pedido_date <= $2::date'
    );
});

test('buildDateFilter builds custom single-day ranges inclusively', () => {
    const filter = buildDateFilter({ start: '2026-06-10', end: '2026-06-10' });

    assert.deepEqual(filter.params, ['2026-06-10', '2026-06-10']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date >= $1::date AND data_pedido_date <= $2::date'
    );
});

test('buildDateFilter ignores invalid bounds', () => {
    const filter = buildDateFilter({ start: 'invalid', end: '2026-05-28' });

    assert.deepEqual(filter.params, ['2026-05-28']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date <= $1::date'
    );
});

test('getPreviousDate returns the calendar day before an ISO date', () => {
    assert.equal(getPreviousDate('2026-06-15'), '2026-06-14');
    assert.equal(getPreviousDate('2026-03-01'), '2026-02-28');
    assert.equal(getPreviousDate('invalid'), null);
});

test('scoreTertile scores higher values higher by default', () => {
    const values = [10, 20, 30, 40, 50];

    assert.equal(scoreTertile(10, values), 1);
    assert.equal(scoreTertile(30, values), 2);
    assert.equal(scoreTertile(50, values), 3);
});

test('scoreTertile can score lower values higher for recency', () => {
    const recencyDays = [2, 10, 20, 40, 80];

    assert.equal(scoreTertile(2, recencyDays, false), 3);
    assert.equal(scoreTertile(20, recencyDays, false), 2);
    assert.equal(scoreTertile(80, recencyDays, false), 1);
});

test('scoreTertile treats equal recency as high recency', () => {
    assert.equal(scoreTertile(0, [0, 0, 0], false), 3);
});

test('getRecencyScore uses fixed lifecycle boundaries', () => {
    assert.equal(getRecencyScore(0), 3);
    assert.equal(getRecencyScore(60), 3);
    assert.equal(getRecencyScore(61), 2);
    assert.equal(getRecencyScore(180), 2);
    assert.equal(getRecencyScore(181), 1);
    assert.equal(getRecencyScore(365), 1);
    assert.equal(getRecencyScore(366), 1);
});

test('getRfmSegment maps the 3x3 RFM matrix', () => {
    assert.deepEqual(getRfmSegment(3, 3), { key: 'champions', label: 'Champions' });
    assert.deepEqual(getRfmSegment(2, 2), { key: 'need_attention', label: 'Precisam de Atenção' });
    assert.deepEqual(getRfmSegment(1, 1), { key: 'lost', label: 'Perdidos' });
});

test('buildRfmSegments summarizes segment count and revenue', () => {
    const segments = buildRfmSegments([
        { segmentKey: 'champions', monetary: 100 },
        { segmentKey: 'champions', monetary: 50 },
        { segmentKey: 'lost', monetary: 25 }
    ]);

    const champions = segments.find(segment => segment.key === 'champions');
    const lost = segments.find(segment => segment.key === 'lost');

    assert.equal(champions.count, 2);
    assert.equal(champions.totalRevenue, 150);
    assert.equal(champions.averageRevenue, 75);
    assert.equal(lost.count, 1);
    assert.equal(lost.totalRevenue, 25);
});

test('buildRfmClients keeps a yesterday buyer in the same high-recency segment when it is the only qualifying client', () => {
    const sevenDayClients = buildRfmClients([
        { name: 'Cliente Ontem', phone: '1', monetary: 500, frequency: 2, quantityPurchased: 2, lastPurchaseDate: '2026-06-14', recencyDays: 1 }
    ]);
    const yesterdayClients = buildRfmClients([
        { name: 'Cliente Ontem', phone: '1', monetary: 500, frequency: 2, quantityPurchased: 2, lastPurchaseDate: '2026-06-14', recencyDays: 0 }
    ]);

    assert.equal(sevenDayClients[0].segmentKey, 'champions');
    assert.equal(yesterdayClients[0].segmentKey, 'champions');
    assert.equal(sevenDayClients[0].phone, yesterdayClients[0].phone);
});

test('buildRfmClients scores segments from RFM history when period totals are smaller', () => {
    const clients = buildRfmClients([
        {
            name: 'Champion que comprou ontem',
            phone: '1',
            monetary: 100,
            frequency: 1,
            quantityPurchased: 1,
            lastPurchaseDate: '2026-06-14',
            recencyDays: 0,
            rfmFrequency: 20,
            rfmMonetary: 10000
        },
        {
            name: 'Compra alta no periodo',
            phone: '2',
            monetary: 1000,
            frequency: 5,
            quantityPurchased: 5,
            lastPurchaseDate: '2026-06-10',
            recencyDays: 4,
            rfmFrequency: 1,
            rfmMonetary: 100
        },
        {
            name: 'Compra media no periodo',
            phone: '3',
            monetary: 900,
            frequency: 4,
            quantityPurchased: 4,
            lastPurchaseDate: '2026-06-05',
            recencyDays: 9,
            rfmFrequency: 1,
            rfmMonetary: 50
        }
    ]);

    const yesterdayBuyer = clients.find(client => client.phone === '1');

    assert.equal(yesterdayBuyer.segmentKey, 'champions');
    assert.equal(yesterdayBuyer.frequency, 1);
    assert.equal(yesterdayBuyer.monetary, 100);
    assert.equal(yesterdayBuyer.frequencyScore, 3);
    assert.equal(yesterdayBuyer.monetaryScore, 3);
});

test('buildRfmClients applies lifecycle protections to new, hibernating, at-risk, and lost clients', () => {
    const clients = buildRfmClients([
        {
            customerKey: 'new',
            name: 'Novo',
            monetary: 50,
            frequency: 1,
            recencyDays: 60,
            rfmFrequency: 1,
            rfmMonetary: 50,
            rfmFrequencyScore: 1,
            rfmMonetaryScore: 1
        },
        {
            customerKey: 'not-new',
            name: 'Não é mais novo',
            monetary: 50,
            frequency: 1,
            recencyDays: 61,
            rfmFrequency: 1,
            rfmMonetary: 50,
            rfmFrequencyScore: 1,
            rfmMonetaryScore: 1
        },
        {
            customerKey: 'hibernating',
            name: 'Hibernando',
            monetary: 50,
            frequency: 1,
            recencyDays: 250,
            rfmFrequency: 1,
            rfmMonetary: 50,
            rfmFrequencyScore: 1,
            rfmMonetaryScore: 1
        },
        {
            customerKey: 'at-risk',
            name: 'Em Risco',
            monetary: 100,
            frequency: 1,
            recencyDays: 250,
            rfmFrequency: 10,
            rfmMonetary: 1000,
            rfmFrequencyScore: 3,
            rfmMonetaryScore: 2
        },
        {
            customerKey: 'lost',
            name: 'Perdido',
            monetary: 2000,
            frequency: 1,
            recencyDays: 366,
            rfmFrequency: 1,
            rfmMonetary: 2000,
            rfmFrequencyScore: 1,
            rfmMonetaryScore: 3
        }
    ]);
    const byKey = new Map(clients.map(client => [client.customerKey, client]));

    assert.equal(byKey.get('new').segmentKey, 'new_customers');
    assert.equal(byKey.get('not-new').segmentKey, 'about_to_sleep');
    assert.equal(byKey.get('hibernating').segmentKey, 'hibernating');
    assert.equal(byKey.get('at-risk').segmentKey, 'at_risk');
    assert.equal(byKey.get('lost').segmentKey, 'lost');
    assert.equal(byKey.get('lost').rfmScore, '113');
});

test('getRfmAnalytics classifies period buyers by history through the selected range end', async () => {
    const originalConnect = pool.connect;
    const calls = [];
    const mockClient = {
        query: async (sql, params = []) => {
            calls.push({ sql, params });
            const isHistoryQuery = sql.includes('= ANY');
            const isPeriodQuery = sql.includes('FROM orders');
            const referenceDate = params[0];

            if (!isPeriodQuery) {
                return { rows: [] };
            }

            if (isHistoryQuery) {
                return {
                    rows: [
                        {
                            customer_key: '1',
                            name: 'Cliente Ontem',
                            phone: '1',
                            monetary: 5000,
                            frequency: 20,
                            quantity_purchased: 20,
                            last_purchase_date: '2026-06-14',
                            recency_days: referenceDate === '2026-06-14' ? 0 : 1,
                            frequency_score: 3,
                            monetary_score: 3
                        },
                        {
                            customer_key: '4',
                            name: 'Cliente Novo no Periodo',
                            phone: '4',
                            monetary: 25,
                            frequency: 1,
                            quantity_purchased: 1,
                            last_purchase_date: '2026-06-14',
                            recency_days: referenceDate === '2026-06-14' ? 0 : 1,
                            frequency_score: 1,
                            monetary_score: 1
                        },
                        {
                            customer_key: 'name:Cliente Sem Fone',
                            name: 'Cliente Sem Fone',
                            phone: null,
                            monetary: 1000,
                            frequency: 10,
                            quantity_purchased: 10,
                            last_purchase_date: '2026-06-14',
                            recency_days: referenceDate === '2026-06-14' ? 0 : 1,
                            frequency_score: 3,
                            monetary_score: 3
                        }
                    ]
                };
            }

            return {
                rows: [
                    {
                        customer_key: '1',
                        name: 'Cliente Ontem',
                        phone: '1',
                        monetary: 100,
                        frequency: 1,
                        quantity_purchased: 1,
                        last_purchase_date: '2026-06-14',
                        recency_days: 1
                    },
                    {
                        customer_key: '4',
                        name: 'Cliente Novo no Periodo',
                        phone: '4',
                        monetary: 25,
                        frequency: 1,
                        quantity_purchased: 1,
                        last_purchase_date: '2026-06-14',
                        recency_days: 1
                    },
                    {
                        customer_key: 'name:Cliente Sem Fone',
                        name: 'Cliente Sem Fone',
                        phone: null,
                        monetary: 30,
                        frequency: 1,
                        quantity_purchased: 1,
                        last_purchase_date: '2026-06-14',
                        recency_days: 1
                    }
                ]
            };
        },
        release: () => {}
    };
    pool.connect = async () => mockClient;

    try {
        const sevenDays = await getRfmAnalytics({ start: '2026-06-09', end: '2026-06-15' });
        const yesterday = await getRfmAnalytics({ start: '2026-06-14', end: '2026-06-14' });
        const selectCalls = calls.filter(call => call.sql.includes('FROM orders'));

        assert.match(calls[1].sql, /SET LOCAL statement_timeout/);
        assert.deepEqual(selectCalls[0].params, ['2026-06-09', '2026-06-15']);
        assert.doesNotMatch(selectCalls[0].sql, /cliente_fone IS NOT NULL/);
        assert.match(selectCalls[1].sql, /\(\$1::date - MAX\(data_pedido_date\)\)::int/);
        assert.match(selectCalls[1].sql, /data_pedido_date <= \$1::date/);
        assert.match(selectCalls[1].sql, /PERCENT_RANK\(\) OVER \(ORDER BY frequency\)/);
        assert.match(selectCalls[1].sql, /PERCENT_RANK\(\) OVER \(ORDER BY monetary\)/);
        assert.match(selectCalls[1].sql, /customer_key = ANY\(\$2::text\[\]\)/);
        assert.doesNotMatch(selectCalls[1].sql, /cliente_fone IS NOT NULL/);
        assert.deepEqual(selectCalls[1].params, ['2026-06-15', ['1', '4', 'name:Cliente Sem Fone']]);
        assert.deepEqual(selectCalls[2].params, ['2026-06-14', '2026-06-14']);
        assert.deepEqual(selectCalls[3].params, ['2026-06-14', ['1', '4', 'name:Cliente Sem Fone']]);
        assert.equal(sevenDays.clients[0].segmentKey, 'champions');
        assert.equal(yesterday.clients[0].segmentKey, 'champions');
        assert.equal(yesterday.clients[0].frequency, 1);
        assert.equal(yesterday.clients[0].monetary, 100);
        assert.equal(yesterday.clients.length, 3);
        assert.ok(!yesterday.clients.some(client => client.phone === '2'));
        assert.ok(yesterday.clients.some(client => client.phone === '4' && client.segmentKey === 'new_customers'));
        assert.ok(yesterday.clients.some(client => (
            client.customerKey === 'name:Cliente Sem Fone' &&
            client.phone === '' &&
            client.segmentKey === 'champions' &&
            client.monetary === 30
        )));
    } finally {
        pool.connect = originalConnect;
    }
});

test('getRfmAnalytics reuses client aggregate rows as RFV history for all-period ranges', async () => {
    const originalQuery = pool.query;
    const originalConnect = pool.connect;
    const calls = [];

    pool.query = async (sql, params = []) => {
        calls.push({ sql, params });

        return {
            rows: [
                {
                    customer_key: '1',
                    name: 'Cliente Frequente',
                    phone: '1',
                    total_spent: 5000,
                    order_count: 20,
                    quantity_purchased: 20,
                    last_purchase_date: '2026-06-14'
                },
                {
                    customer_key: 'name:Cliente Sem Fone',
                    name: 'Cliente Sem Fone',
                    phone: null,
                    total_spent: 50,
                    order_count: 1,
                    quantity_purchased: 1,
                    last_purchase_date: '2026-01-01'
                }
            ]
        };
    };
    pool.connect = async () => {
        throw new Error('all-period RFV should not use a checked-out client');
    };

    try {
        const result = await getRfmAnalytics({ start: '2000-01-01', end: '2026-06-15' });

        assert.equal(calls.length, 1);
        assert.match(calls[0].sql, /GROUP BY customer_key/);
        assert.doesNotMatch(calls[0].sql, /recency_days/);
        assert.doesNotMatch(calls[0].sql, /data_pedido_date >=/);
        assert.deepEqual(calls[0].params, ['2026-06-15']);
        assert.equal(result.clients.length, 2);
        assert.equal(result.segments.reduce((total, segment) => total + segment.count, 0), 2);
        assert.ok(result.clients.some(client => client.customerKey === 'name:Cliente Sem Fone' && client.phone === ''));
    } finally {
        pool.query = originalQuery;
        pool.connect = originalConnect;
    }
});