ce72231560
All checks were successful
Build and Deploy / build-and-deploy (push) Successful in 2m46s
285 lines
10 KiB
JavaScript
285 lines
10 KiB
JavaScript
const assert = require('node:assert/strict');
|
|
const test = require('node:test');
|
|
|
|
const {
|
|
buildRfmClients,
|
|
buildRfmSegments,
|
|
buildDateFilter,
|
|
getPreviousDate,
|
|
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('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('getRfmAnalytics groups period buyers by their RFM tag before the selected period', async () => {
|
|
const originalQuery = pool.query;
|
|
const calls = [];
|
|
|
|
pool.query = async (sql, params) => {
|
|
calls.push({ sql, params });
|
|
const isHistoryQuery = sql.includes('recency_days');
|
|
const endDate = params[0];
|
|
|
|
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: endDate === '2026-06-13' ? 0 : 1
|
|
},
|
|
{
|
|
customer_key: '2',
|
|
name: 'Cliente Antigo',
|
|
phone: '2',
|
|
monetary: 50,
|
|
frequency: 1,
|
|
quantity_purchased: 1,
|
|
last_purchase_date: '2026-01-01',
|
|
recency_days: 164
|
|
},
|
|
{
|
|
customer_key: '3',
|
|
name: 'Cliente Medio',
|
|
phone: '3',
|
|
monetary: 100,
|
|
frequency: 2,
|
|
quantity_purchased: 2,
|
|
last_purchase_date: '2026-03-01',
|
|
recency_days: 105
|
|
}
|
|
]
|
|
};
|
|
}
|
|
|
|
return {
|
|
rows: [
|
|
{
|
|
customer_key: '1',
|
|
name: 'Cliente Ontem',
|
|
phone: '1',
|
|
monetary: 100,
|
|
frequency: 1,
|
|
quantity_purchased: 1,
|
|
last_purchase_date: '2026-06-14'
|
|
},
|
|
{
|
|
customer_key: '4',
|
|
name: 'Cliente Novo no Periodo',
|
|
phone: '4',
|
|
monetary: 25,
|
|
frequency: 1,
|
|
quantity_purchased: 1,
|
|
last_purchase_date: '2026-06-14'
|
|
}
|
|
]
|
|
};
|
|
};
|
|
|
|
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' });
|
|
|
|
assert.deepEqual(calls[0].params, ['2026-06-09', '2026-06-15']);
|
|
assert.match(calls[1].sql, /\(\$1::date - MAX\(data_pedido_date\)\)::int/);
|
|
assert.match(calls[1].sql, /data_pedido_date <= \$1::date/);
|
|
assert.deepEqual(calls[1].params, ['2026-06-08']);
|
|
assert.deepEqual(calls[2].params, ['2026-06-14', '2026-06-14']);
|
|
assert.deepEqual(calls[3].params, ['2026-06-13']);
|
|
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, 2);
|
|
assert.ok(!yesterday.clients.some(client => client.phone === '2'));
|
|
assert.ok(yesterday.clients.some(client => client.phone === '4' && client.segmentKey === 'new_customers'));
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|