f5e2de9a35
All checks were successful
Build and Deploy / build-and-deploy (push) Successful in 1m48s
1230 lines
45 KiB
JavaScript
1230 lines
45 KiB
JavaScript
const assert = require('node:assert/strict');
|
|
const test = require('node:test');
|
|
|
|
const {
|
|
buildRfmClients,
|
|
buildRfmSegments,
|
|
buildDateFilter,
|
|
getFrequencyScore,
|
|
createClientToken,
|
|
isClientToken,
|
|
getClientAnalytics,
|
|
getClientDetailsAnalytics,
|
|
getClientFilterOptions,
|
|
getClientPurchasePatternAnalytics,
|
|
getDashboardAnalytics,
|
|
getPreviousDate,
|
|
getProductAnalytics,
|
|
getProductDetailsAnalytics,
|
|
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('buildDateFilter composes client metadata predicates after date predicates', () => {
|
|
const filter = buildDateFilter({
|
|
start: '2026-05-01',
|
|
end: '2026-05-28',
|
|
marketplace: ' Mercado Livre ',
|
|
canal_venda: ' Online ',
|
|
seller: 'id:VEN-1'
|
|
});
|
|
|
|
assert.deepEqual(filter.params, ['2026-05-01', '2026-05-28', 'Mercado Livre', 'Online', 'VEN-1']);
|
|
assert.equal(filter.endParamIndex, 2);
|
|
assert.equal(
|
|
filter.whereClause,
|
|
"WHERE data_pedido_date IS NOT NULL AND data_pedido_date >= $1::date AND data_pedido_date <= $2::date AND NULLIF(TRIM(marketplace), '') = $3 AND NULLIF(TRIM(canal_venda), '') = $4 AND NULLIF(TRIM(id_vendedor), '') = $5"
|
|
);
|
|
});
|
|
|
|
test('buildDateFilter can filter seller by display name when no seller id is selected', () => {
|
|
const filter = buildDateFilter({ seller: 'name:Maria' });
|
|
|
|
assert.deepEqual(filter.params, ['%Maria%']);
|
|
assert.equal(
|
|
filter.whereClause,
|
|
"WHERE data_pedido_date IS NOT NULL AND NULLIF(TRIM(nome_vendedor), '') ILIKE $1"
|
|
);
|
|
});
|
|
|
|
test('buildDateFilter can search seller names from typed text', () => {
|
|
const filter = buildDateFilter({ seller: 'MARCUS' });
|
|
|
|
assert.deepEqual(filter.params, ['MARCUS', '%MARCUS%']);
|
|
assert.equal(
|
|
filter.whereClause,
|
|
"WHERE data_pedido_date IS NOT NULL AND (NULLIF(TRIM(id_vendedor), '') = $1 OR NULLIF(TRIM(nome_vendedor), '') ILIKE $2)"
|
|
);
|
|
});
|
|
|
|
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('getDashboardAnalytics includes seller revenue and order metrics', async () => {
|
|
const originalQuery = pool.query;
|
|
const calls = [];
|
|
|
|
pool.query = async (sql, params = []) => {
|
|
calls.push({ sql, params });
|
|
|
|
if (sql.includes('total_revenue')) {
|
|
return {
|
|
rows: [{
|
|
total_revenue: 1000,
|
|
total_items: 25,
|
|
order_line_count: 5
|
|
}]
|
|
};
|
|
}
|
|
|
|
if (sql.includes('data_pedido_date::text as date')) {
|
|
return {
|
|
rows: [{ id: '977226210', name: 'KEDMA DA SILVA', date: '2026-06-05', value: 400, orders: 2 }]
|
|
};
|
|
}
|
|
|
|
if (sql.includes('order_hour')) {
|
|
return {
|
|
rows: [{ id: '977226210', name: 'KEDMA DA SILVA', hour: 14, value: 300, orders: 1 }]
|
|
};
|
|
}
|
|
|
|
if (sql.includes('seller_orders') && sql.includes('SUM(quantidade * valor_unitario)')) {
|
|
return {
|
|
rows: [{ id: '977226210', name: 'KEDMA DA SILVA', value: 750 }]
|
|
};
|
|
}
|
|
|
|
if (sql.includes('seller_orders') && sql.includes('COUNT(DISTINCT')) {
|
|
return {
|
|
rows: [{ id: '977226210', name: 'KEDMA DA SILVA', value: 3 }]
|
|
};
|
|
}
|
|
|
|
if (sql.includes('SUM(quantidade), 0) as value')) {
|
|
return {
|
|
rows: [{ id: 'P1', name: 'Produto A', value: 10 }]
|
|
};
|
|
}
|
|
|
|
return {
|
|
rows: [{ id: 'P1', name: 'Produto A', value: 1000 }]
|
|
};
|
|
};
|
|
|
|
try {
|
|
const dashboard = await getDashboardAnalytics({ start: '2026-06-01', end: '2026-06-24' });
|
|
const sellerRevenueQuery = calls.find(call => call.sql.includes('seller_orders') && call.sql.includes('SUM(quantidade * valor_unitario)'));
|
|
const sellerOrdersQuery = calls.find(call => call.sql.includes('seller_orders') && call.sql.includes('COUNT(DISTINCT'));
|
|
|
|
assert.equal(calls.length, 7);
|
|
calls.forEach(call => {
|
|
assert.deepEqual(call.params, ['2026-06-01', '2026-06-24']);
|
|
});
|
|
assert.match(sellerRevenueQuery.sql, /substring\(NULLIF\(TRIM\(nome_vendedor\), ''\) from/);
|
|
assert.match(sellerRevenueQuery.sql, /regexp_replace\(COALESCE\(nome_vendedor, ''\)/);
|
|
assert.match(sellerOrdersQuery.sql, /COUNT\(DISTINCT COALESCE/);
|
|
assert.deepEqual(dashboard.revenueBySeller, [
|
|
{ id: '977226210', name: 'KEDMA DA SILVA', value: 750 }
|
|
]);
|
|
assert.deepEqual(dashboard.ordersBySeller, [
|
|
{ id: '977226210', name: 'KEDMA DA SILVA', value: 3 }
|
|
]);
|
|
assert.deepEqual(dashboard.sellerRevenueByDate, [
|
|
{ id: '977226210', name: 'KEDMA DA SILVA', date: '2026-06-05', value: 400, orders: 2 }
|
|
]);
|
|
assert.deepEqual(dashboard.sellerRevenueByHour, [
|
|
{ id: '977226210', name: 'KEDMA DA SILVA', hour: 14, value: 300, orders: 1 }
|
|
]);
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
test('client tokens are opaque and stable for customer keys', () => {
|
|
const phoneKey = '(16) 99103-6131';
|
|
const nameKey = 'name:Cliente Sem Fone';
|
|
const phoneToken = createClientToken(phoneKey);
|
|
const nameToken = createClientToken(nameKey);
|
|
|
|
assert.ok(isClientToken(phoneToken));
|
|
assert.ok(isClientToken(nameToken));
|
|
assert.equal(createClientToken(phoneKey), phoneToken);
|
|
assert.notEqual(createClientToken('name:Marcela Abreu'), phoneToken);
|
|
assert.doesNotMatch(phoneToken, /99103|6131|\(16\)/);
|
|
assert.doesNotMatch(nameToken, /Cliente|Sem|Fone/);
|
|
assert.equal(isClientToken('invalid-token'), false);
|
|
});
|
|
|
|
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(7), 3);
|
|
assert.equal(getRecencyScore(8), 2);
|
|
assert.equal(getRecencyScore(15), 2);
|
|
assert.equal(getRecencyScore(16), 1);
|
|
assert.equal(getRecencyScore(29), 1);
|
|
assert.equal(getRecencyScore(30), 1);
|
|
});
|
|
|
|
test('getFrequencyScore uses fixed historical order thresholds', () => {
|
|
assert.equal(getFrequencyScore(0), 1);
|
|
assert.equal(getFrequencyScore(1), 1);
|
|
assert.equal(getFrequencyScore(2), 2);
|
|
assert.equal(getFrequencyScore(4), 2);
|
|
assert.equal(getFrequencyScore(5), 3);
|
|
assert.equal(getFrequencyScore(100), 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 repeat recent buyer as potential loyal across period filters', () => {
|
|
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, 'potential_loyalists');
|
|
assert.equal(yesterdayClients[0].segmentKey, 'potential_loyalists');
|
|
assert.equal(sevenDayClients[0].phone, yesterdayClients[0].phone);
|
|
});
|
|
|
|
test('buildRfmClients requires five orders and top value for a recent Champion', () => {
|
|
const clients = buildRfmClients([
|
|
{
|
|
customerKey: 'potential',
|
|
name: 'Potencial',
|
|
monetary: 5000,
|
|
frequency: 4,
|
|
recencyDays: 7,
|
|
rfmFrequency: 4,
|
|
rfmMonetary: 5000,
|
|
rfmMonetaryScore: 3
|
|
},
|
|
{
|
|
customerKey: 'champion',
|
|
name: 'Champion',
|
|
monetary: 5000,
|
|
frequency: 5,
|
|
recencyDays: 7,
|
|
rfmFrequency: 5,
|
|
rfmMonetary: 5000,
|
|
rfmMonetaryScore: 3
|
|
}
|
|
]);
|
|
const byKey = new Map(clients.map(client => [client.customerKey, client]));
|
|
|
|
assert.equal(byKey.get('potential').frequencyScore, 2);
|
|
assert.equal(byKey.get('potential').segmentKey, 'potential_loyalists');
|
|
assert.equal(byKey.get('champion').frequencyScore, 3);
|
|
assert.equal(byKey.get('champion').segmentKey, 'champions');
|
|
});
|
|
|
|
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: 7,
|
|
rfmFrequency: 1,
|
|
rfmMonetary: 50,
|
|
rfmFrequencyScore: 1,
|
|
rfmMonetaryScore: 1
|
|
},
|
|
{
|
|
customerKey: 'not-new',
|
|
name: 'Não é mais novo',
|
|
monetary: 50,
|
|
frequency: 1,
|
|
recencyDays: 8,
|
|
rfmFrequency: 1,
|
|
rfmMonetary: 50,
|
|
rfmFrequencyScore: 1,
|
|
rfmMonetaryScore: 1
|
|
},
|
|
{
|
|
customerKey: 'hibernating',
|
|
name: 'Hibernando',
|
|
monetary: 50,
|
|
frequency: 1,
|
|
recencyDays: 16,
|
|
rfmFrequency: 1,
|
|
rfmMonetary: 50,
|
|
rfmFrequencyScore: 1,
|
|
rfmMonetaryScore: 1
|
|
},
|
|
{
|
|
customerKey: 'at-risk',
|
|
name: 'Em Risco',
|
|
monetary: 100,
|
|
frequency: 1,
|
|
recencyDays: 16,
|
|
rfmFrequency: 10,
|
|
rfmMonetary: 1000,
|
|
rfmFrequencyScore: 3,
|
|
rfmMonetaryScore: 2
|
|
},
|
|
{
|
|
customerKey: 'lost',
|
|
name: 'Perdido',
|
|
monetary: 2000,
|
|
frequency: 1,
|
|
recencyDays: 30,
|
|
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('getProductAnalytics returns exact product rows with stock and latest price', async () => {
|
|
const originalQuery = pool.query;
|
|
const calls = [];
|
|
|
|
pool.query = async (sql, params = []) => {
|
|
calls.push({ sql, params });
|
|
|
|
return {
|
|
rows: [
|
|
{
|
|
id: '919483307',
|
|
name: 'BASE LISA CAMISETA COR PRETO TAMANHO - G',
|
|
quantity_sold: 9513,
|
|
revenue: 113216.83,
|
|
order_line_count: 100,
|
|
last_price: 11.9,
|
|
stock: 11731,
|
|
first_sale_date: '2026-06-01',
|
|
last_sale_date: '2026-06-22'
|
|
},
|
|
{
|
|
id: 'stock-only',
|
|
name: 'Produto sem venda no período',
|
|
quantity_sold: 0,
|
|
revenue: 0,
|
|
order_line_count: 0,
|
|
last_price: 0,
|
|
stock: 12,
|
|
first_sale_date: null,
|
|
last_sale_date: null
|
|
}
|
|
]
|
|
};
|
|
};
|
|
|
|
try {
|
|
const products = await getProductAnalytics({ start: '2026-06-01', end: '2026-06-22' });
|
|
|
|
assert.equal(calls.length, 1);
|
|
assert.match(calls[0].sql, /WITH period_sales AS/);
|
|
assert.match(calls[0].sql, /FULL OUTER JOIN stock_rows/);
|
|
assert.doesNotMatch(calls[0].sql, /GROUP BY name/);
|
|
assert.deepEqual(calls[0].params, ['2026-06-01', '2026-06-22']);
|
|
assert.deepEqual(products[0], {
|
|
id: '919483307',
|
|
name: 'BASE LISA CAMISETA COR PRETO TAMANHO - G',
|
|
quantitySold: 9513,
|
|
revenue: 113216.83,
|
|
orderLineCount: 100,
|
|
lastPrice: 11.9,
|
|
stock: 11731,
|
|
firstSaleDate: '2026-06-01',
|
|
lastSaleDate: '2026-06-22'
|
|
});
|
|
assert.equal(products[1].id, 'stock-only');
|
|
assert.equal(products[1].stock, 12);
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
test('getProductDetailsAnalytics returns product identity and period chart without raw order download', async () => {
|
|
const originalQuery = pool.query;
|
|
const calls = [];
|
|
|
|
pool.query = async (sql, params = []) => {
|
|
calls.push({ sql, params });
|
|
|
|
if (sql.includes('selected_product AS')) {
|
|
return {
|
|
rows: [{
|
|
id: '919483307',
|
|
name: 'BASE LISA CAMISETA COR PRETO TAMANHO - G',
|
|
price: 11.9,
|
|
stock: 11731
|
|
}]
|
|
};
|
|
}
|
|
|
|
if (sql.includes('selected_base AS')) {
|
|
assert.match(sql, /COALESCE\(\s+CASE/);
|
|
assert.match(sql, /GROUP BY produto_id/);
|
|
assert.deepEqual(params, ['919483307', '2026-06-01', '2026-06-22']);
|
|
return {
|
|
rows: [
|
|
{
|
|
id: '919483307',
|
|
name: 'BASE LISA CAMISETA COR PRETO TAMANHO - G',
|
|
quantity_sold: 3,
|
|
revenue: 35.7,
|
|
order_count: 1
|
|
}
|
|
]
|
|
};
|
|
}
|
|
|
|
return {
|
|
rows: [
|
|
{
|
|
data_pedido_date: '2026-06-01',
|
|
date_label: '01-06-2026',
|
|
quantity_sold: 3,
|
|
revenue: 35.7,
|
|
order_count: 1
|
|
},
|
|
{
|
|
data_pedido_date: '2026-06-02',
|
|
date_label: '02-06-2026',
|
|
quantity_sold: 2,
|
|
revenue: 23.8,
|
|
order_count: 1
|
|
}
|
|
]
|
|
};
|
|
};
|
|
|
|
try {
|
|
const details = await getProductDetailsAnalytics('919483307', { start: '2026-06-01', end: '2026-06-22' });
|
|
|
|
assert.equal(calls.length, 3);
|
|
assert.match(calls[0].sql, /WITH selected_product AS/);
|
|
assert.match(calls[0].sql, /WHERE produto_id = \$1/);
|
|
assert.deepEqual(calls[0].params, ['919483307']);
|
|
assert.match(calls[1].sql, /produto_id = \$1/);
|
|
assert.match(calls[1].sql, /data_pedido_date >= \$2::date/);
|
|
assert.match(calls[1].sql, /data_pedido_date <= \$3::date/);
|
|
assert.deepEqual(calls[1].params, ['919483307', '2026-06-01', '2026-06-22']);
|
|
assert.deepEqual(details.productInfo, {
|
|
id: '919483307',
|
|
name: 'BASE LISA CAMISETA COR PRETO TAMANHO - G',
|
|
price: 11.9,
|
|
stock: 11731
|
|
});
|
|
assert.deepEqual(details.chartData, [
|
|
{ date: '01-06-2026', value: 3, quantitySold: 3, revenue: 35.7, orderCount: 1, averageTicket: 35.7 },
|
|
{ date: '02-06-2026', value: 2, quantitySold: 2, revenue: 23.8, orderCount: 1, averageTicket: 23.8 }
|
|
]);
|
|
assert.equal(details.totalSold, 5);
|
|
assert.equal(details.totalRevenue, 59.5);
|
|
assert.equal(details.totalOrders, 2);
|
|
assert.equal(details.averageTicket, 29.75);
|
|
assert.deepEqual(details.variantBreakdown, [
|
|
{
|
|
id: '919483307',
|
|
name: 'BASE LISA CAMISETA COR PRETO TAMANHO - G',
|
|
quantitySold: 3,
|
|
revenue: 35.7,
|
|
orderCount: 1
|
|
}
|
|
]);
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
test('getProductDetailsAnalytics keeps known products visible with zero period sales', async () => {
|
|
const originalQuery = pool.query;
|
|
|
|
pool.query = async (sql) => {
|
|
if (sql.includes('selected_product AS')) {
|
|
return {
|
|
rows: [{
|
|
id: 'stock-only',
|
|
name: 'Produto sem venda no período',
|
|
price: 0,
|
|
stock: 12
|
|
}]
|
|
};
|
|
}
|
|
|
|
return { rows: [] };
|
|
};
|
|
|
|
try {
|
|
const details = await getProductDetailsAnalytics('stock-only', { start: '2026-06-01', end: '2026-06-22' });
|
|
|
|
assert.equal(details.productInfo.id, 'stock-only');
|
|
assert.equal(details.totalSold, 0);
|
|
assert.equal(details.totalRevenue, 0);
|
|
assert.deepEqual(details.chartData, []);
|
|
assert.deepEqual(details.variantBreakdown, []);
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
test('getProductDetailsAnalytics groups single-day chart by hour', async () => {
|
|
const originalQuery = pool.query;
|
|
|
|
pool.query = async (sql) => {
|
|
if (sql.includes('selected_product AS')) {
|
|
return {
|
|
rows: [{
|
|
id: '919483307',
|
|
name: 'Produto com venda por hora',
|
|
price: 11.9,
|
|
stock: 4
|
|
}]
|
|
};
|
|
}
|
|
|
|
if (sql.includes('selected_base AS')) {
|
|
return { rows: [] };
|
|
}
|
|
|
|
assert.match(sql, /EXTRACT\(HOUR FROM created_at AT TIME ZONE 'America\/Sao_Paulo'\)::int as hour/);
|
|
return {
|
|
rows: [
|
|
{ hour: 9, quantity_sold: 2, revenue: 23.8, order_count: 1 },
|
|
{ hour: 18, quantity_sold: 3, revenue: 35.7, order_count: 1 }
|
|
]
|
|
};
|
|
};
|
|
|
|
try {
|
|
const details = await getProductDetailsAnalytics('919483307', { start: '2026-06-22', end: '2026-06-22' });
|
|
|
|
assert.equal(details.chartData.length, 24);
|
|
assert.deepEqual(details.chartData[9], { date: '09h', value: 2, quantitySold: 2, revenue: 23.8, orderCount: 1, averageTicket: 23.8 });
|
|
assert.deepEqual(details.chartData[18], { date: '18h', value: 3, quantitySold: 3, revenue: 35.7, orderCount: 1, averageTicket: 35.7 });
|
|
assert.equal(details.totalSold, 5);
|
|
assert.equal(details.totalRevenue, 59.5);
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
test('getClientAnalytics returns opaque client tokens', async () => {
|
|
const originalQuery = pool.query;
|
|
const calls = [];
|
|
|
|
pool.query = async (sql, params = []) => {
|
|
calls.push({ sql, params });
|
|
|
|
if (sql.includes('INSERT INTO client_identity_tokens')) {
|
|
return { rows: [] };
|
|
}
|
|
|
|
return {
|
|
rows: [
|
|
{
|
|
customer_key: '(16) 99103-6131',
|
|
name: 'Marcela Abreu',
|
|
phone: '(16) 99103-6131',
|
|
quantity_purchased: 10,
|
|
total_spent: 500,
|
|
order_count: 2,
|
|
last_purchase_date: '2026-06-15'
|
|
},
|
|
{
|
|
customer_key: 'name:Cliente Sem Fone',
|
|
name: 'Cliente Sem Fone',
|
|
phone: null,
|
|
quantity_purchased: 1,
|
|
total_spent: 50,
|
|
order_count: 1,
|
|
last_purchase_date: '2026-06-10'
|
|
}
|
|
]
|
|
};
|
|
};
|
|
|
|
try {
|
|
const clients = await getClientAnalytics({ start: '2026-06-01', end: '2026-06-15' });
|
|
|
|
assert.equal(calls.length, 2);
|
|
assert.equal(clients.length, 2);
|
|
assert.match(calls[1].sql, /INSERT INTO client_identity_tokens/);
|
|
assert.deepEqual(calls[1].params, [
|
|
'(16) 99103-6131',
|
|
clients[0].clientToken,
|
|
'name:Cliente Sem Fone',
|
|
clients[1].clientToken
|
|
]);
|
|
assert.doesNotMatch(clients[0].clientToken, /99103|6131|Marcela/);
|
|
assert.doesNotMatch(clients[1].clientToken, /Cliente|Fone/);
|
|
assert.ok(isClientToken(clients[0].clientToken));
|
|
assert.ok(isClientToken(clients[1].clientToken));
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
test('getClientAnalytics groups phone-less history through the customer identity CTE', async () => {
|
|
const originalQuery = pool.query;
|
|
const calls = [];
|
|
|
|
pool.query = async (sql, params = []) => {
|
|
calls.push({ sql, params });
|
|
|
|
if (sql.includes('INSERT INTO client_identity_tokens')) {
|
|
return { rows: [] };
|
|
}
|
|
|
|
return {
|
|
rows: [
|
|
{
|
|
customer_key: '(16) 99999-9999',
|
|
name: 'Cliente Com Historico',
|
|
phone: '(16) 99999-9999',
|
|
quantity_purchased: 1002,
|
|
total_spent: 50000,
|
|
order_count: 250,
|
|
last_purchase_date: '2026-06-15'
|
|
}
|
|
]
|
|
};
|
|
};
|
|
|
|
try {
|
|
const clients = await getClientAnalytics({ start: '2026-05-01', end: '2026-06-15' });
|
|
|
|
assert.equal(calls.length, 2);
|
|
assert.equal(clients.length, 1);
|
|
assert.equal(clients[0].customerKey, '(16) 99999-9999');
|
|
assert.equal(clients[0].phone, '(16) 99999-9999');
|
|
assert.match(calls[0].sql, /customer_phone_by_name AS/);
|
|
assert.match(calls[0].sql, /ARRAY_AGG\(NULLIF\(cliente_fone, ''\) ORDER BY data_pedido_date DESC NULLS LAST, id DESC\)/);
|
|
assert.match(calls[0].sql, /WHERE NULLIF\(cliente_fone, ''\) IS NOT NULL/);
|
|
assert.match(calls[0].sql, /NULLIF\(orders\.cliente_fone, ''\),\s+customer_phone_by_name\.canonical_phone/s);
|
|
assert.match(calls[0].sql, /FROM identity_orders/);
|
|
assert.match(calls[0].sql, /GROUP BY customer_key/);
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
test('getClientFilterOptions returns all distinct order metadata options', async () => {
|
|
const originalQuery = pool.query;
|
|
const calls = [];
|
|
|
|
pool.query = async (sql, params = []) => {
|
|
calls.push({ sql, params });
|
|
|
|
if (sql.includes('SELECT DISTINCT NULLIF(TRIM(marketplace)')) {
|
|
return { rows: [{ value: 'Mercado Livre' }, { value: 'Shopee' }] };
|
|
}
|
|
|
|
if (sql.includes('SELECT DISTINCT NULLIF(TRIM(canal_venda)')) {
|
|
return { rows: [{ value: 'Online' }] };
|
|
}
|
|
|
|
return {
|
|
rows: [
|
|
{ id: 'VEN-1', name: 'Maria' },
|
|
{ id: '', name: 'Sem ID' },
|
|
{ id: '', name: 'KEDMA DA SILVA #977226210' },
|
|
{ id: 'VEN-1', name: 'Maria' }
|
|
]
|
|
};
|
|
};
|
|
|
|
try {
|
|
const options = await getClientFilterOptions({ start: '2026-06-01', end: '2026-06-15' });
|
|
|
|
assert.equal(calls.length, 3);
|
|
calls.forEach(call => {
|
|
assert.deepEqual(call.params, []);
|
|
assert.doesNotMatch(call.sql, /data_pedido_date >=/);
|
|
assert.doesNotMatch(call.sql, /data_pedido_date <=/);
|
|
});
|
|
assert.match(calls[0].sql, /WHERE NULLIF\(TRIM\(marketplace\), ''\) IS NOT NULL/);
|
|
assert.match(calls[2].sql, /WITH seller_options AS/);
|
|
assert.match(calls[2].sql, /substring\(NULLIF\(TRIM\(nome_vendedor\), ''\) from/);
|
|
assert.match(calls[2].sql, /regexp_replace\(COALESCE\(nome_vendedor, ''\)/);
|
|
assert.match(calls[2].sql, /NULLIF\(TRIM\(nome_vendedor\), ''\) IS NOT NULL/);
|
|
assert.deepEqual(options.marketplaces, ['Mercado Livre', 'Shopee']);
|
|
assert.deepEqual(options.salesChannels, ['Online']);
|
|
assert.deepEqual(options.sellers, [
|
|
{ value: 'id:VEN-1', id: 'VEN-1', name: 'Maria' },
|
|
{ value: 'name:Sem ID', id: '', name: 'Sem ID' },
|
|
{ value: 'id:977226210', id: '977226210', name: 'KEDMA DA SILVA' }
|
|
]);
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
test('getClientPurchasePatternAnalytics returns all-time weekday and hour counts', async () => {
|
|
const originalQuery = pool.query;
|
|
|
|
pool.query = async (sql, params = []) => {
|
|
assert.deepEqual(params, []);
|
|
assert.match(sql, /order_events AS/);
|
|
assert.match(sql, /DISTINCT ON \(\s+customer_key,\s+COALESCE\(NULLIF\(pedido_id, ''\), data_pedido \|\| '_' \|\| valor_pedido::text\)\s+\)/);
|
|
assert.match(sql, /EXTRACT\(DOW FROM data_pedido_date\)::int as weekday/);
|
|
assert.match(sql, /EXTRACT\(HOUR FROM created_at AT TIME ZONE 'America\/Sao_Paulo'\)::int as hour/);
|
|
|
|
return {
|
|
rows: [
|
|
{ weekday: 1, hour: 9, order_count: 2 },
|
|
{ weekday: 5, hour: 18, order_count: 1 },
|
|
{ weekday: 5, hour: null, order_count: 1 }
|
|
]
|
|
};
|
|
};
|
|
|
|
try {
|
|
const pattern = await getClientPurchasePatternAnalytics();
|
|
|
|
assert.equal(pattern.purchaseWeekdays.length, 7);
|
|
assert.equal(pattern.purchaseHours.length, 24);
|
|
assert.deepEqual(pattern.purchaseWeekdays[1], { label: 'Seg', value: 2 });
|
|
assert.deepEqual(pattern.purchaseWeekdays[5], { label: 'Sex', value: 2 });
|
|
assert.deepEqual(pattern.purchaseHours[9], { label: '09h', value: 2 });
|
|
assert.deepEqual(pattern.purchaseHours[18], { label: '18h', value: 1 });
|
|
assert.deepEqual(pattern.purchaseHours[0], { label: '00h', value: 0 });
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
test('getClientDetailsAnalytics resolves legacy name tokens to the canonical phone client', async () => {
|
|
const originalQuery = pool.query;
|
|
const calls = [];
|
|
const clientToken = createClientToken('name:Cliente Sem Fone');
|
|
|
|
pool.query = async (sql, params = []) => {
|
|
calls.push({ sql, params });
|
|
|
|
if (sql.includes('FROM client_identity_tokens')) {
|
|
return { rows: [{ customer_key: 'name:Cliente Sem Fone' }] };
|
|
}
|
|
|
|
if (sql.includes('SELECT customer_key') && sql.includes('FROM identity_orders')) {
|
|
return { rows: [{ customer_key: '(16) 99999-9999' }] };
|
|
}
|
|
|
|
if (sql.includes('all_time_order_count')) {
|
|
return {
|
|
rows: [{
|
|
name: 'Cliente Sem Fone',
|
|
phone: '(16) 99999-9999',
|
|
all_time_order_count: 3
|
|
}]
|
|
};
|
|
}
|
|
|
|
return {
|
|
rows: [
|
|
{
|
|
cliente_nome: 'Cliente Sem Fone',
|
|
cliente_fone: '',
|
|
data_pedido: '10-06-2026',
|
|
data_pedido_date: '2026-06-10',
|
|
valor_pedido: 25,
|
|
produto_id: 'produto-1',
|
|
produto_descricao: 'Produto A',
|
|
quantidade: 2,
|
|
valor_unitario: 10,
|
|
pedido_id: 'pedido-1'
|
|
},
|
|
{
|
|
cliente_nome: 'Cliente Sem Fone',
|
|
cliente_fone: '(16) 99999-9999',
|
|
data_pedido: '10-06-2026',
|
|
data_pedido_date: '2026-06-10',
|
|
valor_pedido: 25,
|
|
produto_id: 'produto-2',
|
|
produto_descricao: 'Produto B',
|
|
quantidade: 1,
|
|
valor_unitario: 5,
|
|
pedido_id: 'pedido-1'
|
|
}
|
|
]
|
|
};
|
|
};
|
|
|
|
try {
|
|
const details = await getClientDetailsAnalytics(clientToken, { start: '2026-06-01', end: '2026-06-15' });
|
|
|
|
assert.equal(calls.length, 5);
|
|
assert.match(calls[0].sql, /FROM client_identity_tokens/);
|
|
assert.deepEqual(calls[0].params, [clientToken]);
|
|
assert.match(calls[1].sql, /SELECT customer_key/);
|
|
assert.deepEqual(calls[1].params, ['Cliente Sem Fone']);
|
|
assert.match(calls[2].sql, /FROM identity_orders/);
|
|
assert.match(calls[2].sql, /WHERE customer_key = \$1/);
|
|
assert.deepEqual(calls[2].params, ['(16) 99999-9999']);
|
|
assert.match(calls[3].sql, /data_pedido_date >= \$2::date/);
|
|
assert.match(calls[3].sql, /data_pedido_date <= \$3::date/);
|
|
assert.deepEqual(calls[3].params, ['(16) 99999-9999', '2026-06-01', '2026-06-15']);
|
|
assert.match(calls[4].sql, /created_at/);
|
|
assert.doesNotMatch(calls[4].sql, /data_pedido_date >=/);
|
|
assert.doesNotMatch(calls[4].sql, /data_pedido_date <=/);
|
|
assert.deepEqual(calls[4].params, ['(16) 99999-9999']);
|
|
assert.equal(details.clientName, 'Cliente Sem Fone');
|
|
assert.equal(details.clientPhone, '(16) 99999-9999');
|
|
assert.equal(details.allTimeOrderCount, 3);
|
|
assert.equal(details.periodSpent, 25);
|
|
assert.equal(details.periodItems, 3);
|
|
assert.equal(details.periodOrderCount, 1);
|
|
assert.equal(details.periodAverageTicket, 25);
|
|
assert.deepEqual(details.chartData, [{ date: '10-06-2026', value: 25 }]);
|
|
assert.equal(details.groupedOrders.length, 1);
|
|
assert.equal(details.groupedOrders[0].orderTotal, 25);
|
|
assert.equal(details.groupedOrders[0].items.length, 2);
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
test('getClientDetailsAnalytics groups single-day spend chart by hour', async () => {
|
|
const originalQuery = pool.query;
|
|
const clientToken = createClientToken('(16) 99999-9999');
|
|
|
|
pool.query = async (sql, params = []) => {
|
|
if (sql.includes('FROM client_identity_tokens')) {
|
|
return { rows: [{ customer_key: '(16) 99999-9999' }] };
|
|
}
|
|
|
|
if (sql.includes('SELECT customer_key') && sql.includes('FROM identity_orders')) {
|
|
return { rows: [{ customer_key: '(16) 99999-9999' }] };
|
|
}
|
|
|
|
if (sql.includes('all_time_order_count')) {
|
|
return {
|
|
rows: [{
|
|
name: 'Cliente Teste',
|
|
phone: '(16) 99999-9999',
|
|
all_time_order_count: 2
|
|
}]
|
|
};
|
|
}
|
|
|
|
assert.deepEqual(params[0], '(16) 99999-9999');
|
|
return {
|
|
rows: [
|
|
{
|
|
cliente_nome: 'Cliente Teste',
|
|
cliente_fone: '(16) 99999-9999',
|
|
data_pedido: '22-06-2026',
|
|
data_pedido_date: '2026-06-22',
|
|
valor_pedido: 20,
|
|
produto_id: 'produto-1',
|
|
produto_descricao: 'Produto A',
|
|
quantidade: 2,
|
|
valor_unitario: 10,
|
|
pedido_id: 'pedido-1',
|
|
created_at: '2026-06-22T09:15:00.000-03:00'
|
|
},
|
|
{
|
|
cliente_nome: 'Cliente Teste',
|
|
cliente_fone: '(16) 99999-9999',
|
|
data_pedido: '22-06-2026',
|
|
data_pedido_date: '2026-06-22',
|
|
valor_pedido: 30,
|
|
produto_id: 'produto-2',
|
|
produto_descricao: 'Produto B',
|
|
quantidade: 1,
|
|
valor_unitario: 30,
|
|
pedido_id: 'pedido-2',
|
|
created_at: '2026-06-22T18:30:00.000-03:00'
|
|
}
|
|
]
|
|
};
|
|
};
|
|
|
|
try {
|
|
const details = await getClientDetailsAnalytics(clientToken, { start: '2026-06-22', end: '2026-06-22' });
|
|
|
|
assert.equal(details.chartData.length, 24);
|
|
assert.deepEqual(details.chartData[9], { date: '09h', value: 20 });
|
|
assert.deepEqual(details.chartData[18], { date: '18h', value: 30 });
|
|
assert.equal(details.periodSpent, 50);
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
test('getClientDetailsAnalytics rejects invalid client tokens before querying', async () => {
|
|
const originalQuery = pool.query;
|
|
pool.query = async () => {
|
|
throw new Error('invalid client token should not query');
|
|
};
|
|
|
|
try {
|
|
assert.equal(await getClientDetailsAnalytics('not-a-token', { start: '2026-06-01', end: '2026-06-15' }), null);
|
|
} finally {
|
|
pool.query = originalQuery;
|
|
}
|
|
});
|
|
|
|
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, /WHERE\s+cliente_fone IS NOT NULL/);
|
|
assert.match(selectCalls[0].sql, /FROM identity_orders/);
|
|
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, /WHEN frequency <= 1 THEN 1/);
|
|
assert.match(selectCalls[1].sql, /WHEN frequency <= 4 THEN 2/);
|
|
assert.doesNotMatch(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, /WHERE\s+cliente_fone IS NOT NULL/);
|
|
assert.match(selectCalls[1].sql, /FROM identity_orders/);
|
|
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 });
|
|
|
|
if (sql.includes('INSERT INTO client_identity_tokens')) {
|
|
return { rows: [] };
|
|
}
|
|
|
|
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, 2);
|
|
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.match(calls[1].sql, /INSERT INTO client_identity_tokens/);
|
|
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;
|
|
}
|
|
});
|