mirror of
https://github.com/fsolla/teqo.git
synced 2026-11-13 15:13:07 +00:00
643 lines
22 KiB
TypeScript
643 lines
22 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
|
|
import {
|
|
CHART_TYPES,
|
|
MAX_POINTS,
|
|
MAX_POINTS_LINE,
|
|
MAX_POINTS_STORY,
|
|
MAX_SERIES,
|
|
MIN_SERIES,
|
|
RELATION_LABEL,
|
|
SIZES,
|
|
classifyRelation,
|
|
isTemporalLabel,
|
|
parseInput,
|
|
parseNumber,
|
|
validateSpec,
|
|
} from '../../scripts/lib/chartData.mjs'
|
|
|
|
describe('parseNumber — pt-BR/en amounts, never invents a zero', () => {
|
|
it('reads thousands and decimals', () => {
|
|
expect(parseNumber('1.234,56')).toBe(1234.56)
|
|
expect(parseNumber('1,5')).toBe(1.5)
|
|
expect(parseNumber('1,234.56')).toBe(1234.56)
|
|
expect(parseNumber('R$ 84')).toBe(84)
|
|
expect(parseNumber('12%')).toBe(12)
|
|
expect(parseNumber(-3)).toBe(-3)
|
|
})
|
|
|
|
it('returns null for non-numeric input', () => {
|
|
expect(parseNumber('oitenta')).toBeNull()
|
|
expect(parseNumber('')).toBeNull()
|
|
expect(parseNumber(null)).toBeNull()
|
|
})
|
|
|
|
it('reads a single separator as the decimal — the documented pt-BR rule', () => {
|
|
expect(parseNumber('1.234')).toBe(1.234)
|
|
expect(parseNumber('1,234')).toBe(1.234)
|
|
expect(parseNumber('1.500')).toBe(1.5)
|
|
})
|
|
|
|
it('refuses a repeated separator instead of guessing the thousands', () => {
|
|
expect(parseNumber('1.234.567')).toBeNull()
|
|
expect(parseNumber('1,234,567')).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('parseInput — the data as it came', () => {
|
|
it('reads a free text of label<space>value pairs', () => {
|
|
const dataset = parseInput({ text: 'Ilhéus 84\nItabuna 68\n', format: 'txt' })
|
|
expect(dataset.rows).toEqual([
|
|
{ label: 'Ilhéus', value: 84 },
|
|
{ label: 'Itabuna', value: 68 },
|
|
])
|
|
expect(dataset.issues).toEqual([])
|
|
})
|
|
|
|
it('reads colon-separated pairs and labels with spaces', () => {
|
|
const dataset = parseInput({ text: 'Votos em Ilhéus: 84\nVotos em Itabuna: 68', format: 'txt' })
|
|
expect(dataset.rows[0]).toEqual({ label: 'Votos em Ilhéus', value: 84 })
|
|
})
|
|
|
|
it('reads a GFM markdown table and drops the header', () => {
|
|
const dataset = parseInput({
|
|
text: '| Cidade | Votos |\n| --- | --- |\n| Ilhéus | 84 |\n| Itabuna | 68 |',
|
|
format: 'md',
|
|
})
|
|
expect(dataset.format).toBe('md')
|
|
expect(dataset.rows).toEqual([
|
|
{ label: 'Ilhéus', value: 84 },
|
|
{ label: 'Itabuna', value: 68 },
|
|
])
|
|
})
|
|
|
|
it('reads CSV with a header', () => {
|
|
const dataset = parseInput({ text: 'cidade,votos\nIlhéus,84\nItabuna,68\n', format: 'csv' })
|
|
expect(dataset.rows).toEqual([
|
|
{ label: 'Ilhéus', value: 84 },
|
|
{ label: 'Itabuna', value: 68 },
|
|
])
|
|
})
|
|
|
|
it('flags a non-numeric value instead of dropping it silently', () => {
|
|
const dataset = parseInput({ text: 'Ilhéus 84\nItabuna ???\n', format: 'txt' })
|
|
expect(dataset.rows).toHaveLength(1)
|
|
expect(dataset.issues.join(' ')).toContain('Itabuna')
|
|
})
|
|
|
|
it('does not mistake a first data row with a missing value for a header', () => {
|
|
const dataset = parseInput({ text: 'Ilhéus n/d\nItabuna 68\n', format: 'txt' })
|
|
expect(dataset.rows).toEqual([{ label: 'Itabuna', value: 68 }])
|
|
expect(dataset.issues.join(' ')).toContain('Ilhéus')
|
|
})
|
|
|
|
it('flags repeated labels', () => {
|
|
const dataset = parseInput({ text: 'A 1\nA 2\n', format: 'txt' })
|
|
expect(dataset.issues.join(' ')).toContain('repetido')
|
|
})
|
|
|
|
it('reads a bare number as an unlabeled single measure', () => {
|
|
const dataset = parseInput({ text: '72', format: 'txt' })
|
|
expect(dataset.rows).toEqual([{ label: '', value: 72 }])
|
|
expect(dataset.issues).toEqual([])
|
|
})
|
|
|
|
it('does not flag a single separator as ambiguous (the rule is intentional)', () => {
|
|
const dataset = parseInput({ text: 'Ilhéus 1.234\nItabuna 1,500\n', format: 'txt' })
|
|
expect(dataset.rows).toEqual([
|
|
{ label: 'Ilhéus', value: 1.234 },
|
|
{ label: 'Itabuna', value: 1.5 },
|
|
])
|
|
expect(dataset.issues).toEqual([])
|
|
})
|
|
})
|
|
|
|
describe('classifyRelation — the relation of the data picks the type', () => {
|
|
it('single measure is an anchor', () => {
|
|
expect(classifyRelation([{ label: '', value: 72 }])).toBe('anchor')
|
|
})
|
|
|
|
it('few temporal periods are columns, many are a line', () => {
|
|
expect(
|
|
classifyRelation([
|
|
{ label: '2020', value: 1 },
|
|
{ label: '2021', value: 2 },
|
|
]),
|
|
).toBe('column')
|
|
expect(
|
|
classifyRelation(
|
|
['2018', '2019', '2020', '2021', '2022', '2023', '2024'].map((label) => ({
|
|
label,
|
|
value: 1,
|
|
})),
|
|
),
|
|
).toBe('line')
|
|
})
|
|
|
|
it('non-temporal categories are a ranking (bar)', () => {
|
|
expect(
|
|
classifyRelation([
|
|
{ label: 'Ilhéus', value: 1 },
|
|
{ label: 'Itabuna', value: 2 },
|
|
]),
|
|
).toBe('bar')
|
|
})
|
|
|
|
it('honors a forced type and refuses an unknown one', () => {
|
|
expect(classifyRelation([{ label: 'A', value: 1 }], 'bar')).toBe('bar')
|
|
expect(classifyRelation([{ label: 'A', value: 1 }], 'pie')).toBe('pie')
|
|
expect(() => classifyRelation([{ label: 'A', value: 1 }], 'donut')).toThrow(/desconhecido/)
|
|
})
|
|
})
|
|
|
|
describe('isTemporalLabel', () => {
|
|
it('detects years, months, quarters and P-periods', () => {
|
|
for (const label of ['2024', '2024-06', '06/2024', 'jan/24', 'Q1', 'T3', 'P2']) {
|
|
expect(isTemporalLabel(label), label).toBe(true)
|
|
}
|
|
expect(isTemporalLabel('Ilhéus')).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('validateSpec — fail-closed guardrails', () => {
|
|
const base = { chartType: 'bar', rows: [{ label: 'A', value: 1 }], headline: 'Takeaway' }
|
|
|
|
it('accepts a valid spec', () => {
|
|
expect(validateSpec(base)).toBe(base)
|
|
})
|
|
|
|
it('refuses pizza with an actionable message', () => {
|
|
expect(() => validateSpec({ ...base, chartType: 'pie' })).toThrow(/barras horizontais/)
|
|
})
|
|
|
|
it(`refuses more than ${MAX_POINTS} points`, () => {
|
|
const rows = Array.from({ length: MAX_POINTS + 1 }, (_v, index) => ({
|
|
label: `A${index}`,
|
|
value: 1,
|
|
}))
|
|
expect(() => validateSpec({ ...base, rows })).toThrow(/resuma/)
|
|
})
|
|
|
|
it('caps a story ranking at five points (approved vertical rhythm)', () => {
|
|
const rows = Array.from({ length: MAX_POINTS_STORY + 1 }, (_v, index) => ({
|
|
label: `A${index}`,
|
|
value: index + 1,
|
|
}))
|
|
expect(() => validateSpec({ ...base, size: 'feed', rows })).not.toThrow()
|
|
expect(() => validateSpec({ ...base, size: 'story', rows })).toThrow(/cinco|5/)
|
|
})
|
|
|
|
it('refuses negative values (bars come from zero)', () => {
|
|
expect(() => validateSpec({ ...base, rows: [{ label: 'A', value: -1 }] })).toThrow(/zero/)
|
|
})
|
|
|
|
it('refuses a missing headline', () => {
|
|
expect(() => validateSpec({ ...base, headline: '' })).toThrow(/manchete/)
|
|
})
|
|
|
|
it('refuses an unknown size', () => {
|
|
expect(() => validateSpec({ ...base, size: 'huge' })).toThrow(/tamanho inválido/)
|
|
})
|
|
|
|
it('refuses a highlight that is not in the data', () => {
|
|
expect(() => validateSpec({ ...base, highlight: 'Sumiu' })).toThrow(/destaque/)
|
|
})
|
|
|
|
it('refuses an anchor with more than one value', () => {
|
|
expect(() =>
|
|
validateSpec({
|
|
...base,
|
|
chartType: 'anchor',
|
|
rows: [
|
|
{ label: 'A', value: 1 },
|
|
{ label: 'B', value: 2 },
|
|
],
|
|
}),
|
|
).toThrow(/âncora/)
|
|
})
|
|
|
|
it('refuses an unlabeled bar row', () => {
|
|
expect(() => validateSpec({ ...base, rows: [{ label: '', value: 1 }] })).toThrow(/rótulo/)
|
|
})
|
|
|
|
it('accepts an optional unit suffix and a relation kicker', () => {
|
|
expect(validateSpec({ ...base, unit: '%', kicker: 'Comparação' })).toMatchObject({
|
|
unit: '%',
|
|
kicker: 'Comparação',
|
|
})
|
|
})
|
|
|
|
it('refuses a non-string unit and an empty kicker', () => {
|
|
expect(() => validateSpec({ ...base, unit: 10 })).toThrow(/unidade/)
|
|
expect(() => validateSpec({ ...base, kicker: ' ' })).toThrow(/kicker/)
|
|
})
|
|
|
|
it('accepts the neutral piece flag and refuses the highlight conflict', () => {
|
|
expect(validateSpec({ ...base, noHighlight: true })).toMatchObject({ noHighlight: true })
|
|
expect(() => validateSpec({ ...base, noHighlight: 'sim' })).toThrow(/noHighlight/)
|
|
expect(() => validateSpec({ ...base, noHighlight: true, highlight: 'A' })).toThrow(/exclusivos/)
|
|
})
|
|
|
|
it('certifies the two-positive column pair and fails closed outside it', () => {
|
|
const pair = {
|
|
...base,
|
|
chartType: 'column',
|
|
rows: [
|
|
{ label: 'Municipal', value: 60.57 },
|
|
{ label: 'Estadual', value: 54.67 },
|
|
],
|
|
}
|
|
expect(validateSpec({ ...pair, dualPositive: true })).toMatchObject({ dualPositive: true })
|
|
expect(() => validateSpec({ ...pair, dualPositive: 'sim' })).toThrow(/dualPositive/)
|
|
expect(() => validateSpec({ ...base, dualPositive: true })).toThrow(/coluna/)
|
|
expect(() =>
|
|
validateSpec({ ...pair, dualPositive: true, rows: [{ label: 'A', value: 1 }] }),
|
|
).toThrow(/2 categorias/)
|
|
expect(() => validateSpec({ ...pair, dualPositive: true, highlight: 'Municipal' })).toThrow(
|
|
/destaque/,
|
|
)
|
|
expect(() => validateSpec({ ...pair, dualPositive: true, noHighlight: true })).toThrow(
|
|
/no-highlight/,
|
|
)
|
|
expect(() => validateSpec({ ...pair, dualPositive: true, size: 'square' })).toThrow(/feed/)
|
|
})
|
|
})
|
|
|
|
describe('parseInput — two aligned measures become series, not a ranking', () => {
|
|
it('reads a time table with two measures as two series', () => {
|
|
const dataset = parseInput({
|
|
text: 'Ano,Estadual,Municipal\n2017,9807,24002\n2018,10636,24438\n',
|
|
format: 'csv',
|
|
})
|
|
expect(dataset.rows).toEqual([])
|
|
expect(dataset.series).toEqual([
|
|
{
|
|
name: 'Estadual',
|
|
rows: [
|
|
{ label: '2017', value: 9807 },
|
|
{ label: '2018', value: 10636 },
|
|
],
|
|
},
|
|
{
|
|
name: 'Municipal',
|
|
rows: [
|
|
{ label: '2017', value: 24002 },
|
|
{ label: '2018', value: 24438 },
|
|
],
|
|
},
|
|
])
|
|
expect(dataset.issues).toEqual([])
|
|
})
|
|
|
|
it('reads a time table with three measures as three series (C204)', () => {
|
|
const dataset = parseInput({
|
|
text: 'Ano,Estadual,Municipal,Privada\n2015,235,93,832\n2016,235,93,724\n',
|
|
format: 'csv',
|
|
})
|
|
expect(dataset.series).toHaveLength(3)
|
|
expect(dataset.series?.[2]).toMatchObject({ name: 'Privada' })
|
|
expect(dataset.issues).toEqual([])
|
|
})
|
|
|
|
it('keeps a two-column table on the single-series path', () => {
|
|
const dataset = parseInput({ text: 'cidade,votos\nIlhéus,84\nItabuna,68\n', format: 'csv' })
|
|
expect(dataset.series).toBeUndefined()
|
|
expect(dataset.rows).toHaveLength(2)
|
|
})
|
|
|
|
it('flags a non-numeric cell of a series table instead of dropping the column', () => {
|
|
const dataset = parseInput({
|
|
text: 'Ano,Estadual,Municipal\n2017,9807,???\n2018,10636,24438\n',
|
|
format: 'csv',
|
|
})
|
|
expect(dataset.issues.join(' ')).toContain('Municipal · 2017')
|
|
})
|
|
})
|
|
|
|
describe('parseInput — the variation bar (delta)', () => {
|
|
it('reads a table whose header names the two periods', () => {
|
|
const dataset = parseInput({
|
|
text: 'Tipo\t2020\tjul/2026\nESF · Saúde da Família\t58\t63\nENASF-AB · Ampliado\t5\t5\n',
|
|
format: 'tsv',
|
|
delta: true,
|
|
})
|
|
expect(dataset.startLabel).toBe('2020')
|
|
expect(dataset.endLabel).toBe('jul/2026')
|
|
expect(dataset.rows).toEqual([
|
|
{ label: 'ESF · Saúde da Família', initial: 58, final: 63 },
|
|
{ label: 'ENASF-AB · Ampliado', initial: 5, final: 5 },
|
|
])
|
|
expect(dataset.issues).toEqual([])
|
|
})
|
|
|
|
it('flags a missing measure instead of completing it', () => {
|
|
const dataset = parseInput({
|
|
text: 'Tipo\t2020\t2026\nECR · Consultórios na Rua\t-\t1\n',
|
|
format: 'tsv',
|
|
delta: true,
|
|
})
|
|
expect(dataset.rows).toEqual([])
|
|
expect(dataset.issues.join(' ')).toContain('inicial')
|
|
})
|
|
|
|
it('reads the delta table from the free-text path too', () => {
|
|
const dataset = parseInput({
|
|
text: 'Tipo\t2020\t2026\nESB · Saúde Bucal\t40\t53\n',
|
|
format: 'txt',
|
|
delta: true,
|
|
})
|
|
expect(dataset.rows).toEqual([{ label: 'ESB · Saúde Bucal', initial: 40, final: 53 }])
|
|
})
|
|
})
|
|
|
|
describe('validateSpec — the two-series time line', () => {
|
|
const seriesSpec = (overrides = {}) => ({
|
|
chartType: 'line',
|
|
headline: 'Internações crescem no hospital estadual e recuam no municipal',
|
|
series: [
|
|
{
|
|
name: 'Estadual',
|
|
tone: 'good',
|
|
rows: [
|
|
{ label: '2017', value: 9807 },
|
|
{ label: '2026', value: 23294 },
|
|
],
|
|
},
|
|
{
|
|
name: 'Municipal',
|
|
tone: 'bad',
|
|
rows: [
|
|
{ label: '2017', value: 24002 },
|
|
{ label: '2026', value: 15948 },
|
|
],
|
|
},
|
|
],
|
|
...overrides,
|
|
})
|
|
|
|
it('accepts aligned temporal series with paired tones', () => {
|
|
expect(validateSpec(seriesSpec())).toBeTruthy()
|
|
})
|
|
|
|
it('refuses a multi-series spec that is not a line', () => {
|
|
expect(() => validateSpec(seriesSpec({ chartType: 'bar' }))).toThrow(/linha/)
|
|
})
|
|
|
|
it(`refuses fewer than ${MIN_SERIES} and more than ${MAX_SERIES} series`, () => {
|
|
const [first, second] = seriesSpec().series
|
|
const third = { ...first, name: 'Terceira' }
|
|
expect(() => validateSpec(seriesSpec({ series: [first] }))).toThrow(/séries/)
|
|
expect(() =>
|
|
validateSpec(seriesSpec({ series: [first, second, third, { ...third, name: 'Quarta' }] })),
|
|
).toThrow(/séries/)
|
|
})
|
|
|
|
it('refuses misaligned periods between the series', () => {
|
|
const [first, second] = seriesSpec().series
|
|
const drifted = {
|
|
...second,
|
|
rows: [
|
|
{ label: '2018', value: 1 },
|
|
{ label: '2026', value: 2 },
|
|
],
|
|
}
|
|
expect(() => validateSpec(seriesSpec({ series: [first, drifted] }))).toThrow(/mesmos períodos/)
|
|
})
|
|
|
|
it('refuses categorical labels on the time axis', () => {
|
|
const categorical = (name: string, tone: string) => ({
|
|
name,
|
|
tone,
|
|
rows: [
|
|
{ label: 'Ilhéus', value: 1 },
|
|
{ label: 'Itabuna', value: 2 },
|
|
],
|
|
})
|
|
expect(() =>
|
|
validateSpec(
|
|
seriesSpec({ series: [categorical('Estadual', 'good'), categorical('Municipal', 'bad')] }),
|
|
),
|
|
).toThrow(/períodos/)
|
|
})
|
|
|
|
it('refuses a one-sided, repeated or unknown tone', () => {
|
|
const [first, second] = seriesSpec().series
|
|
expect(() =>
|
|
validateSpec(seriesSpec({ series: [{ ...first, tone: undefined }, second] })),
|
|
).toThrow(/tom/)
|
|
expect(() => validateSpec(seriesSpec({ series: [{ ...first, tone: 'bad' }, second] }))).toThrow(
|
|
/mesmo tom/,
|
|
)
|
|
expect(() =>
|
|
validateSpec(seriesSpec({ series: [{ ...first, tone: 'ótimo' }, second] })),
|
|
).toThrow(/tom inválido/)
|
|
})
|
|
|
|
it(`caps each series at ${MAX_POINTS_LINE} points`, () => {
|
|
const [first, second] = seriesSpec().series
|
|
const rows = Array.from({ length: MAX_POINTS_LINE + 1 }, (_v, index) => ({
|
|
label: `${2000 + index}`,
|
|
value: index + 1,
|
|
}))
|
|
expect(() => validateSpec(seriesSpec({ series: [{ ...first, rows }, second] }))).toThrow(
|
|
/resuma/,
|
|
)
|
|
expect(MAX_POINTS_LINE).toBeGreaterThan(MAX_POINTS)
|
|
})
|
|
|
|
it('marks the projection only on the last period', () => {
|
|
expect(validateSpec(seriesSpec({ projectedLabel: '2026' }))).toBeTruthy()
|
|
expect(() => validateSpec(seriesSpec({ projectedLabel: '2017' }))).toThrow(/último período/)
|
|
})
|
|
|
|
it('refuses --highlight on a two-series line (the tones carry the meaning)', () => {
|
|
expect(() => validateSpec(seriesSpec({ highlight: 'Estadual' }))).toThrow(/highlight/)
|
|
})
|
|
|
|
it('accepts a confirmed crossing and refuses an unconfirmed one', () => {
|
|
expect(validateSpec(seriesSpec({ crossingLabel: '2026' }))).toBeTruthy()
|
|
expect(() => validateSpec(seriesSpec({ crossingLabel: '2017' }))).toThrow(/primeiro/)
|
|
const [first, second] = seriesSpec().series
|
|
const alreadyAhead = {
|
|
...second,
|
|
rows: [
|
|
{ label: '2017', value: 1 },
|
|
{ label: '2026', value: 2 },
|
|
],
|
|
}
|
|
expect(() =>
|
|
validateSpec(seriesSpec({ crossingLabel: '2026', series: [first, alreadyAhead] })),
|
|
).toThrow(/ultrapassagem/)
|
|
})
|
|
|
|
it('refuses a crossing annotation without the tone pair', () => {
|
|
const { series } = seriesSpec()
|
|
const neutral = series.map(({ name, rows }) => ({ name, rows }))
|
|
expect(() => validateSpec(seriesSpec({ crossingLabel: '2026', series: neutral }))).toThrow(
|
|
/tons/,
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('validateSpec — the three-series time line (C205 extension, C207 projection)', () => {
|
|
const annual = (values: number[]) =>
|
|
values.map((value, index) => ({ label: `${2015 + index}`, value }))
|
|
const tripleSpec = (overrides = {}) => ({
|
|
chartType: 'line',
|
|
size: 'feed',
|
|
headline: 'Hospital estadual puxa a ampliação de leitos de internação',
|
|
series: [
|
|
{
|
|
name: 'Hospital Estadual',
|
|
tone: 'good',
|
|
rows: annual([235, 235, 256, 256, 256, 256, 256, 256, 369, 369, 369, 369]),
|
|
},
|
|
{
|
|
name: 'Rede municipal',
|
|
tone: 'neutral',
|
|
rows: annual([93, 93, 105, 93, 93, 93, 93, 93, 113, 113, 113, 113]),
|
|
},
|
|
{
|
|
name: 'Rede privada',
|
|
tone: 'neutral-dark',
|
|
rows: annual([832, 724, 707, 644, 521, 496, 459, 489, 508, 536, 500, 510]),
|
|
},
|
|
],
|
|
...overrides,
|
|
})
|
|
|
|
it('accepts three aligned temporal series with the informed triad', () => {
|
|
expect(validateSpec(tripleSpec())).toBeTruthy()
|
|
})
|
|
|
|
it('accepts the twelve points per series of the certified extension', () => {
|
|
expect(tripleSpec().series[0].rows).toHaveLength(MAX_POINTS_LINE)
|
|
})
|
|
|
|
it('refuses a partial or repeated triad', () => {
|
|
const [first, second, third] = tripleSpec().series
|
|
expect(() =>
|
|
validateSpec(tripleSpec({ series: [{ ...first, tone: undefined }, second, third] })),
|
|
).toThrow(/três tons/)
|
|
expect(() =>
|
|
validateSpec(tripleSpec({ series: [{ ...first, tone: 'neutral' }, second, third] })),
|
|
).toThrow(/distintos/)
|
|
expect(() =>
|
|
validateSpec(tripleSpec({ series: [first, second, { ...third, tone: 'bad' }] })),
|
|
).toThrow(/tom inválido/)
|
|
expect(() =>
|
|
validateSpec(tripleSpec({ series: [first, second, { ...third, tone: 'medium' }] })),
|
|
).toThrow(/tom inválido/)
|
|
})
|
|
|
|
it('certifies the projected last period (C207) and still refuses crossing', () => {
|
|
expect(validateSpec(tripleSpec({ projectedLabel: '2026' }))).toBeTruthy()
|
|
expect(() => validateSpec(tripleSpec({ projectedLabel: '2017' }))).toThrow(/último período/)
|
|
expect(() => validateSpec(tripleSpec({ crossingLabel: '2026' }))).toThrow(/cruzamento/)
|
|
})
|
|
|
|
it('certifies the three-series line on the feed canvas only', () => {
|
|
expect(validateSpec(tripleSpec({ size: 'feed' }))).toBeTruthy()
|
|
expect(() => validateSpec(tripleSpec({ size: 'square' }))).toThrow(/feed/)
|
|
expect(() => validateSpec(tripleSpec({ size: 'story' }))).toThrow(/feed/)
|
|
})
|
|
|
|
it('keeps the alignment, temporal and ceiling guardrails of the pair', () => {
|
|
const [first, second, third] = tripleSpec().series
|
|
const drifted = {
|
|
...third,
|
|
rows: third.rows.map((row, index) => (index === 0 ? { ...row, label: '2014' } : row)),
|
|
}
|
|
expect(() => validateSpec(tripleSpec({ series: [first, second, drifted] }))).toThrow(
|
|
/mesmos períodos/,
|
|
)
|
|
const rows = Array.from({ length: MAX_POINTS_LINE + 1 }, (_v, index) => ({
|
|
label: `${2000 + index}`,
|
|
value: index + 1,
|
|
}))
|
|
expect(() => validateSpec(tripleSpec({ series: [{ ...first, rows }, second, third] }))).toThrow(
|
|
/resuma/,
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('validateSpec — the variation bar (delta)', () => {
|
|
const deltaSpec = (overrides = {}) => ({
|
|
chartType: 'delta',
|
|
headline: 'Quatro dos sete tipos seguem sem ampliação desde 2020',
|
|
startLabel: '2020',
|
|
endLabel: 'jul/2026',
|
|
rows: [
|
|
{ label: 'ESF · Saúde da Família', initial: 58, final: 63 },
|
|
{ label: 'ESB · Saúde Bucal', initial: 40, final: 53 },
|
|
{ label: 'ENASF-AB · Ampliado', initial: 5, final: 5 },
|
|
],
|
|
...overrides,
|
|
})
|
|
|
|
it('accepts a zero-based variation with the two periods named', () => {
|
|
expect(validateSpec(deltaSpec())).toBeTruthy()
|
|
})
|
|
|
|
it('refuses a retraction and points to the two-series line', () => {
|
|
expect(() =>
|
|
validateSpec(deltaSpec({ rows: [{ label: 'ESF', initial: 63, final: 58 }] })),
|
|
).toThrow(/linha de duas séries/)
|
|
})
|
|
|
|
it('refuses --highlight (the two-tone pair is fixed and there is no valence)', () => {
|
|
expect(() => validateSpec(deltaSpec({ highlight: 'ESB · Saúde Bucal' }))).toThrow(/destaque/)
|
|
})
|
|
|
|
it('requires the two period labels of the gutter', () => {
|
|
expect(() => validateSpec(deltaSpec({ startLabel: '' }))).toThrow(/startLabel/)
|
|
expect(() => validateSpec(deltaSpec({ endLabel: undefined }))).toThrow(/endLabel/)
|
|
})
|
|
|
|
it(`caps the categories at ${MAX_POINTS}`, () => {
|
|
const rows = Array.from({ length: MAX_POINTS + 1 }, (_v, index) => ({
|
|
label: `Tipo ${index}`,
|
|
initial: 1,
|
|
final: 2,
|
|
}))
|
|
expect(() => validateSpec(deltaSpec({ rows }))).toThrow(/resuma/)
|
|
})
|
|
|
|
it('allows the seven categories on the Stories canvas (no ranking cut)', () => {
|
|
const rows = Array.from({ length: MAX_POINTS }, (_v, index) => ({
|
|
label: `Tipo ${index}`,
|
|
initial: 1,
|
|
final: 2,
|
|
}))
|
|
expect(validateSpec(deltaSpec({ size: 'story', rows }))).toBeTruthy()
|
|
})
|
|
|
|
it('refuses a missing or negative measure and a non-positive final', () => {
|
|
expect(() => validateSpec(deltaSpec({ rows: [{ label: 'ESF', initial: 1 }] }))).toThrow(
|
|
/final ausente/,
|
|
)
|
|
expect(() =>
|
|
validateSpec(deltaSpec({ rows: [{ label: 'ESF', initial: -1, final: 2 }] })),
|
|
).toThrow(/negativo/)
|
|
expect(() =>
|
|
validateSpec(deltaSpec({ rows: [{ label: 'ESF', initial: 0, final: 0 }] })),
|
|
).toThrow(/não positivo/)
|
|
})
|
|
|
|
it('is the relation of a two-measure table and still honours an explicit type', () => {
|
|
const rows = [{ label: 'ESF', initial: 1, final: 2 }]
|
|
expect(classifyRelation(rows)).toBe('delta')
|
|
expect(classifyRelation(rows, 'bar')).toBe('bar')
|
|
})
|
|
})
|
|
|
|
describe('contracts', () => {
|
|
it('declares the v1 types plus the delta variant, labels and sizes', () => {
|
|
expect(CHART_TYPES).toEqual(['bar', 'column', 'line', 'anchor', 'delta'])
|
|
expect(RELATION_LABEL.line).toBe('Série de tempo')
|
|
expect(RELATION_LABEL.delta).toBe('Variação no período')
|
|
expect(SIZES.story).toMatchObject({ width: 1080, height: 1920, safeTop: 250, safeBottom: 250 })
|
|
expect(SIZES.feed).toMatchObject({ width: 1080, height: 1350 })
|
|
expect(SIZES.square).toMatchObject({ width: 1080, height: 1080 })
|
|
})
|
|
})
|