--!nonstrict
local Jobs = require("format/jobs")
local Util = require("format/util")
function test_recorrencia__sem_recorrencia_e_manual()
assert_eq(Jobs.recurrence_label(nil), "manual")
end
function test_recorrencia__intervalo_diaria_e_semanal()
assert_eq(Jobs.recurrence_label({ IntervalHours = 6 }), "every 6h")
assert_eq(
Jobs.recurrence_label({ Daily = { hour = 3, minute = 5 } }),
"daily at 03:05"
)
assert_eq(
Jobs.recurrence_label({
Weekly = { weekday = 0, hour = 9, minute = 30 },
}),
"weekly mon at 09:30"
)
assert_eq(
Jobs.recurrence_label({
Weekly = { weekday = 6, hour = 23, minute = 0 },
}),
"weekly sun at 23:00"
)
end
function test_recorrencia__o_dia_da_semana_da_a_volta_modulo_7()
assert_has(
Jobs.recurrence_label({
Weekly = { weekday = 7, hour = 0, minute = 0 },
}),
"mon"
)
assert_has(
Jobs.recurrence_label({
Weekly = { weekday = 9, hour = 0, minute = 0 },
}),
"wed"
)
end
function test_recorrencia__forma_desconhecida_vira_traco()
assert_eq(Jobs.recurrence_label({ Mensal = {} }), "—")
end
function test_estado__ultima_execucao_nunca_rodando_ok_falhou()
local label, kind = Jobs.run_status(nil)
assert_eq(label, "never ran")
assert_eq(kind, "muted")
label, kind = Jobs.run_status({})
assert_eq(label, "running…")
assert_eq(kind, "warn")
label, kind = Jobs.run_status({ success = true })
assert_eq(label, "ok")
assert_eq(kind, "ok")
label, kind = Jobs.run_status({ success = false })
assert_eq(label, "failed")
assert_eq(kind, "bad")
end
function test_estado__aquecimento_aquecendo_vence_quente_e_nil_conta_como()
assert_eq(Jobs.warm_status({ warming = true, warm = true }), "warming…")
assert_eq(Jobs.warm_status({ warm = true }), "warm")
assert_eq(Jobs.warm_status({}), "cold")
assert_eq(Jobs.warm_status(nil), "cold")
assert_eq(select(2, Jobs.warm_status({ warm = true })), "ok")
assert_eq(select(2, Jobs.warm_status({ warming = true })), "warn")
end
function test_estado__servico_sem_build_nao_tem_selo()
local label, kind = Jobs.service_warm_status(nil)
assert_eq(label, "")
assert_eq(kind, "muted")
assert_eq(Jobs.service_warm_status({ warm = true }), "warm")
end
function test_estado__motivo_de_frio_traduzido()
assert_eq(Jobs.warm_reason("nunca aquecido"), "never warmed")
assert_eq(
Jobs.warm_reason(
"a fonte do serviço mudou desde o último aquecimento"
),
"the service source changed since the last warm-up"
)
assert_eq(
Jobs.warm_reason("a imagem rp_api:abc não está mais no host"),
"image rp_api:abc is no longer on the host"
)
assert_eq(
Jobs.warm_reason("o cache de build foi limpo em 16/11 04:00 UTC"),
"the build cache was cleaned on 16/11 04:00 UTC"
)
assert_eq(
Jobs.warm_reason("motivo novo do daemon"),
"motivo novo do daemon"
)
assert_eq(Jobs.warm_reason(nil), "")
end
local function resumo(sobrescrita)
local base = {
job = {
id = "j1",
name = "migrate",
recurrence = { IntervalHours = 2 },
enabled = true,
},
project_name = "loja",
trigger_service_name = "api",
last_run = { id = "r1", success = true },
}
for k, v in sobrescrita or {} do
base[k] = v
end
return base
end
function test_tela_schedules__uma_linha_por_job_com_o_total()
local json_texto, total = Jobs.summaries({
resumo(),
resumo({ job = { id = "j2", name = "x", enabled = false } }),
}, nil)
assert_eq(total, 2)
local linhas = json.decode(json_texto)
assert_eq(#linhas, 2)
assert_eq(linhas[1].id, "j1")
assert_eq(linhas[1].recurrence, "every 2h")
assert_eq(linhas[1].enabled_label, "Pause")
assert_eq(linhas[2].enabled_label, "Enable")
assert_eq(linhas[1].last_run_label, "ok")
assert_eq(linhas[1].last_run_id, "r1")
end
function test_tela_schedules__o_dono_mostra_projeto_servico_gatilho_ou_so_o()
local autonomo = resumo()
autonomo.trigger_service_name = nil
local linhas = json.decode((Jobs.summaries({ resumo(), autonomo }, nil)))
-- O orçamento de caracteres depende da largura da janela (ver
-- Util.column_budgets), então o esperado passa pelo mesmo ellipsis.
local orcamento = Util.column_budgets().proj
assert_eq(linhas[1].owner, Util.ellipsis("loja / api", orcamento))
assert_eq(linhas[2].owner, Util.ellipsis("loja", orcamento))
assert_eq(linhas[1].trigger_service, "api")
end
function test_tela_schedules__o_nome_comprido_e_truncado_na_exibicao_e()
local longo = string.rep("n", 80)
local linha = json.decode(
(Jobs.summaries({ resumo({ job = { id = "j", name = longo } }) }, nil))
)[1]
assert_eq(linha.name_full, longo)
assert_eq(utf8.len(linha.name) < 80, true)
end
function test_tela_schedules__running_reflete_o_servidor_ou_o_clique_em_voo()
local rodando = resumo({ last_run = {} })
local parado = resumo()
local linhas = json.decode((Jobs.summaries({ rodando, parado }, nil)))
assert_eq(linhas[1].running, true)
assert_eq(linhas[2].running, false)
linhas = json.decode((Jobs.summaries({ parado }, { j1 = true })))
assert_eq(linhas[1].running, true)
linhas = json.decode((Jobs.summaries({ parado }, { j1 = false })))
assert_eq(linhas[1].running, false)
end
function test_tela_schedules__proxima_execucao_e_aquecimento()
local linha = json.decode((Jobs.summaries({
resumo({
job = {
id = "j",
name = "n",
next_run_at = "2026-03-01T10:00:00Z",
},
warm = {
warm = true,
warmed_at = "2026-03-01T09:00:00Z",
reason = "build ok",
},
}),
}, nil)))[1]
assert_match(linha.next_run_at, "^%d%d/%d%d %d%d:%d%d$")
assert_eq(linha.is_warm, true)
assert_eq(linha.is_warming, false)
assert_eq(linha.warm_label, "warm")
assert_eq(linha.warm_reason, "build ok")
assert_match(linha.warmed_at_label, "^%d%d/%d%d")
end
function test_tela_schedules__sem_next_run_at_nem_aquecimento_os_campos_tem()
local linha = json.decode((Jobs.summaries({ resumo() }, nil)))[1]
assert_eq(linha.next_run_at, "—")
assert_eq(linha.is_warm, false)
assert_eq(linha.warm_label, "cold")
assert_eq(linha.warm_reason, "")
assert_eq(linha.warmed_at_label, "")
end
function test_tela_schedules__job_que_nunca_rodou()
local nunca = resumo()
nunca.last_run = nil
local linha = json.decode((Jobs.summaries({ nunca }, nil)))[1]
assert_eq(linha.last_run_label, "never ran")
assert_eq(linha.last_run_id, "")
assert_eq(linha.running, false)
end
function test_tela_schedules__sem_jobs_da_e_zero()
local texto, total = Jobs.summaries(nil, nil)
assert_eq(texto, "[]")
assert_eq(total, 0)
end
local jobs = {
{ id = "a", name = "migrar" },
{ id = "b", name = "seed" },
{ id = "c", name = "limpar" },
}
function test_fila_de_pre_deploy__a_fila_respeita_a_ordem_configurada_e()
local fila = json.decode(
Jobs.pre_deploy_queue({ pre_deploy_job_ids = { "c", "a" } }, jobs)
)
assert_eq(#fila, 2)
assert_eq(fila[1].name, "limpar")
assert_eq(fila[1].index, "1")
assert_eq(fila[2].name, "migrar")
assert_eq(fila[2].index, "2")
end
function test_fila_de_pre_deploy__um_job_apagado_por_fora_aparece_como()
local fila = json.decode(
Jobs.pre_deploy_queue({ pre_deploy_job_ids = { "zzz" } }, jobs)
)
assert_eq(fila[1].id, "zzz")
assert_eq(fila[1].name, "(job removed: zzz)")
end
function test_fila_de_pre_deploy__o_id_legado_vale_quando_a_fila_nova_esta()
local fila =
json.decode(Jobs.pre_deploy_queue({ pre_deploy_job_id = "b" }, jobs))
assert_eq(fila[1].name, "seed")
end
function test_fila_de_pre_deploy__os_disponiveis_sao_os_que_ainda_nao_estao()
local livres = json.decode(
Jobs.pre_deploy_available({ pre_deploy_job_ids = { "a" } }, jobs)
)
assert_eq(#livres, 2)
assert_eq(livres[1].id, "b")
assert_eq(livres[2].id, "c")
end
function test_fila_de_pre_deploy__fila_e_disponiveis_juntos_cobrem_todos_os()
local spec = { pre_deploy_job_ids = { "b" } }
local na_fila = json.decode(Jobs.pre_deploy_queue(spec, jobs))
local livres = json.decode(Jobs.pre_deploy_available(spec, jobs))
assert_eq(#na_fila + #livres, #jobs)
end
function test_fila_de_pre_deploy__sem_jobs_da()
assert_eq(Jobs.pre_deploy_queue({}, nil), "[]")
assert_eq(Jobs.pre_deploy_available({}, nil), "[]")
end
function test_historico__cada_execucao_com_seu_estado_codigo_de_saida_e()
local linhas = json.decode(Jobs.runs({
{
id = "r1",
started_at = "2026-03-01T10:00:00Z",
finished_at = "2026-03-01T10:00:09Z",
exit_code = 0,
success = true,
},
{
id = "r2",
started_at = "2026-03-01T10:00:00Z",
exit_code = 1,
success = false,
},
{ id = "r3", started_at = "2026-03-01T10:00:00Z" },
}))
assert_eq(linhas[1].status_label, "ok")
assert_eq(linhas[1].exit_code, "0")
assert_match(linhas[1].finished_at, "^%d%d/%d%d %d%d:%d%d:%d%d$")
assert_eq(linhas[2].status_label, "failed")
assert_eq(linhas[2].status_kind, "bad")
assert_eq(linhas[2].finished_at, "—")
assert_eq(linhas[3].status_label, "running…")
assert_eq(linhas[3].exit_code, "—")
end
function test_historico__sem_execucoes_da()
assert_eq(Jobs.runs(nil), "[]")
end