--!nonstrict
local Dashboard = require("format/dashboard")
local Util = require("format/util")
local env = _G :: any
-- grid_cols lê o global `ctx` (a gaveta lateral come largura da grade).
local function com_menu(aberto)
env.ctx = { menu = aberto and "true" or "false" }
end
local function par(nome, projeto, extras)
local svc = {
id = "id-" .. nome,
status = "Running",
spec = { name = nome, port = 8080, project_id = "p-" .. projeto },
containers = {},
}
for k, v in extras or {} do
svc[k] = v
end
return { svc = svc, proj = projeto }
end
function test_deployments__filtra_por_servico_ou_projeto_e_formata_o_estado()
local entradas = {
{ service_name = "api", project_name = "loja", deployment = { state = "Live", started_at = "2026-03-01T10:00:00Z", finished_at = "2026-03-01T10:00:30Z" } },
{ service_name = "web", project_name = "blog", deployment = { state = "Failed", started_at = "2026-03-01T10:00:00Z", finished_at = "2026-03-01T10:00:05Z" } },
}
local todas = json.decode(Dashboard.deployments(entradas, ""))
assert_eq(#todas, 2)
assert_eq(todas[1].state_label, "LIVE")
assert_eq(todas[1].state_kind, "ok")
assert_eq(todas[1].duration, "30s")
assert_eq(todas[1].start_iso, "2026-03-01T10:00:00Z")
assert_eq(todas[2].state_kind, "bad")
local so_blog = json.decode(Dashboard.deployments(entradas, "blog"))
assert_eq(#so_blog, 1)
assert_eq(so_blog[1].service, "web")
assert_eq(Dashboard.deployments(entradas, "zzz"), "[]")
assert_eq(Dashboard.deployments(nil, nil), "[]")
end
function test_cards_de_servico__status_porta_e_metricas()
local cartoes = json.decode(Dashboard.services(
{ par("api", "loja") },
{ ["id-api"] = { cpu_percent = 12.34, mem_used_bytes = 5 * 1024 * 1024 } },
""
))
assert_eq(#cartoes, 1)
assert_eq(cartoes[1].name, "api")
assert_eq(cartoes[1].project, "loja")
assert_eq(cartoes[1].port, "8080")
assert_eq(cartoes[1].status_label, "Running")
assert_eq(cartoes[1].cpu, "12.3%")
assert_eq(cartoes[1].mem, "5 MB")
assert_eq(cartoes[1].filler, "0")
end
function test_cards_de_servico__sem_metricas_o_card_mostra()
local c = json.decode(Dashboard.services({ par("api", "loja") }, nil, ""))[1]
assert_eq(c.cpu, "—")
assert_eq(c.mem, "—")
assert_eq(c.container_name, "—")
assert_eq(c.container_extra, "")
end
function test_cards_de_servico__o_container_primario_e_o_live_senao_o_primeiro_em_execucao_n_quando_ha_mais()
local com_live = par("a", "p", {
live_container_id = "idb",
containers = {
{ id = "ida", name = "c-a", state = "exited" },
{ id = "idb", name = "c-b", state = "exited" },
{ id = "idc", name = "c-c", state = "running" },
},
})
local c = json.decode(Dashboard.services({ com_live }, nil, ""))[1]
assert_eq(c.container_name, "c-b")
assert_eq(c.container_extra, "+2")
local sem_live = par("a", "p", {
containers = {
{ id = "ida", name = "c-a", state = "exited" },
{ id = "idc", name = "c-c", state = "running" },
},
})
c = json.decode(Dashboard.services({ sem_live }, nil, ""))[1]
assert_eq(c.container_name, "c-c")
assert_eq(c.container_id, "idc")
end
function test_cards_de_servico__o_selo_de_aquecimento_so_existe_quando_ha_warm()
local quente = par("a", "p")
quente.warm = { warm = true, reason = "build ok" }
local linhas = json.decode(Dashboard.services({ quente, par("b", "p") }, nil, ""))
assert_eq(linhas[1].has_warm, "true")
assert_eq(linhas[1].warm_label, "quente")
assert_eq(linhas[1].warm_reason, "build ok")
assert_eq(linhas[2].has_warm, "false")
assert_eq(linhas[2].warm_label, "")
end
function test_cards_de_servico__a_busca_casa_servico_ou_projeto()
local pares = { par("api", "loja"), par("worker", "blog") }
assert_eq(#json.decode(Dashboard.services(pares, nil, "blog")), 1)
assert_eq(#json.decode(Dashboard.services(pares, nil, "api")), 1)
assert_eq(#json.decode(Dashboard.services(pares, nil, "")), 2)
assert_eq(Dashboard.services(pares, nil, "zzz"), "[]")
end
local function linhas_para(n)
local pares = {}
for i = 1, n do
table.insert(pares, par("s" .. i, "p"))
end
return json.decode(Dashboard.service_rows(pares, nil, ""))
end
function test_grade__1_a_3_colunas_todas_as_fileiras_com_a_mesma_largura()
com_menu(false)
local linhas = linhas_para(7)
local colunas = #linhas[1].cards
assert_eq(colunas >= 1 and colunas <= 3, true)
for _, linha in linhas do
assert_eq(#linha.cards, colunas)
end
end
function test_grade__a_ultima_fileira_e_completada_com_cards_vazios_a_grade_nao_tem_grid()
com_menu(false)
local linhas = linhas_para(7)
local colunas = #linhas[1].cards
assert_eq(#linhas, math.ceil(7 / colunas))
local reais, vazios = 0, 0
for _, linha in linhas do
for _, card in linha.cards do
if card.filler == "1" then
vazios += 1
else
reais += 1
end
end
end
assert_eq(reais, 7)
assert_eq(vazios, #linhas * colunas - 7)
end
function test_grade__o_card_vazio_carrega_os_campos_dos_dois_contratos_como_texto()
com_menu(false)
local linhas = linhas_para(1)
local vazio
for _, card in linhas[1].cards do
if card.filler == "1" then
vazio = card
end
end
if vazio then
for _, campo in { "id", "name", "project", "port", "status_label", "cpu", "mem", "description", "service_count", "can_delete" } do
assert_eq(vazio[campo], "")
end
end
end
function test_grade__a_gaveta_aberta_nunca_da_mais_colunas_que_a_fechada()
com_menu(false)
local fechada = #linhas_para(9)[1].cards
com_menu(true)
local aberta = #linhas_para(9)[1].cards
assert_eq(aberta <= fechada, true)
assert_eq(aberta >= 1, true)
end
function test_grade__sem_servicos_nao_ha_fileiras()
com_menu(false)
assert_eq(Dashboard.service_rows({}, nil, ""), "[]")
end
function test_grade__project_rows_segue_a_mesma_regra_de_grade()
com_menu(false)
local projetos = {}
for i = 1, 4 do
table.insert(projetos, { id = "p" .. i, name = "proj" .. i })
end
local linhas = json.decode(Dashboard.project_rows(projetos, {}, ""))
local colunas = #linhas[1].cards
for _, linha in linhas do
assert_eq(#linha.cards, colunas)
end
assert_eq(#linhas, math.ceil(4 / colunas))
end
function test_projetos__conta_servicos_e_os_que_estao_rodando_e_so_deixa_apagar_projeto_vazio()
local pares = {
par("a", "x"), -- project_id "p-x"
par("b", "x", { status = "Stopped" }),
}
local projetos = {
{ id = "p-x", name = "x", description = "meu projeto" },
{ id = "p-y", name = "y" },
}
local cartoes = json.decode(Dashboard.projects(projetos, pares, ""))
assert_eq(cartoes[1].service_count, "2")
assert_eq(cartoes[1].running_count, "1")
assert_eq(cartoes[1].can_delete, "0")
assert_eq(cartoes[1].description, "meu projeto")
assert_eq(cartoes[2].service_count, "0")
assert_eq(cartoes[2].can_delete, "1")
assert_eq(cartoes[2].description, "")
end
function test_projetos__a_busca_olha_nome_e_descricao()
local projetos = { { id = "1", name = "loja", description = "vendas" }, { id = "2", name = "blog" } }
assert_eq(#json.decode(Dashboard.projects(projetos, {}, "vend")), 1)
assert_eq(#json.decode(Dashboard.projects(projetos, {}, "blog")), 1)
assert_eq(Dashboard.projects(nil, {}, ""), "[]")
end
function test_docker__docker_rows_ordena_por_nome_e_resume_a_imagem()
local linhas = json.decode(Dashboard.docker_rows({
par("zeta", "p", { live_container_id = "0123456789abcdefff" }),
par("alfa", "p"),
}, ""))
assert_eq(linhas[1].name, "alfa")
assert_eq(linhas[2].name, "zeta")
assert_eq(linhas[2].container, "0123456789ab")
assert_eq(linhas[1].container, "—")
assert_eq(linhas[1].status_kind, "ok")
end
local imagens = {
{ id = "sha256:aaaaaaaaaaaaaaaa", tags = { "web:1" }, size_bytes = 2048, containers = 1, project = "loja", service = "web", created = "2026-03-01T10:00:00Z" },
{ id = "sha256:bbbbbbbbbbbbbbbb", tags = {}, size_bytes = 1024, containers = 0 },
{ id = "cccc", tags = { "api:2" }, containers = 0 },
}
function test_docker__imagens_ordenadas_por_tag_sem_sha256_e_com_none_para_as_sem_tag()
local linhas = json.decode(Dashboard.docker_images(imagens, "", false))
assert_eq(#linhas, 3)
-- ordem por tags unidas: "" < "api:2" < "web:1"
assert_eq(linhas[1].tags, "<none>")
assert_eq(linhas[2].tags, "api:2")
assert_eq(linhas[3].tags, "web:1")
assert_eq(linhas[3].id_full, "aaaaaaaaaaaaaaaa")
assert_eq(linhas[3].id, "aaaaaaaaaaaa")
end
function test_docker__imagens_em_uso_dono_e_tamanhos_crus_para_ordenar()
local linhas = json.decode(Dashboard.docker_images(imagens, "", false))
local web = linhas[3]
assert_eq(web.in_use_label, "EM USO")
assert_eq(web.in_use_kind, "ok")
assert_eq(web.owner, Util.ellipsis("loja / web", Util.column_budgets().proj))
assert_eq(web.size, "2 KB")
assert_eq(web.size_bytes, 2048)
assert_eq(web.created_iso, "2026-03-01T10:00:00Z")
assert_eq(linhas[1].in_use_label, "SEM USO")
assert_eq(linhas[1].project, "—")
assert_eq(linhas[2].size_bytes, 0)
end
function test_docker__imagens_somente_em_uso_esconde_as_orfas_e_a_busca_olha_tags_e_dono()
local em_uso = json.decode(Dashboard.docker_images(imagens, "", true))
assert_eq(#em_uso, 1)
assert_eq(em_uso[1].tags, "web:1")
assert_eq(#json.decode(Dashboard.docker_images(imagens, "loja", false)), 1)
assert_eq(#json.decode(Dashboard.docker_images(imagens, "api", false)), 1)
end
function test_docker__volumes_filtro_de_uso_tamanho_desconhecido_e_dono()
local volumes = {
{ name = "dados", driver = "local", mountpoint = "/v/dados", in_use = true, size_bytes = 5 * 1024 * 1024 },
{ name = "antigo", driver = "local", mountpoint = "/v/antigo", in_use = false },
{ name = "neg", driver = "nfs", mountpoint = "/v/n", in_use = false, size_bytes = -1 },
}
local todos = json.decode(Dashboard.docker_volumes(volumes, "", false))
assert_eq(#todos, 3)
assert_eq(todos[1].name, "antigo")
assert_eq(todos[1].size, "—")
assert_eq(todos[1].size_bytes, -1)
assert_eq(todos[2].name, "dados")
assert_eq(todos[2].size, "5 MB")
assert_eq(todos[2].in_use_label, "EM USO")
assert_eq(todos[3].size, "—")
local em_uso = json.decode(Dashboard.docker_volumes(volumes, "", true))
assert_eq(#em_uso, 1)
assert_eq(em_uso[1].name_full, "dados")
assert_eq(#json.decode(Dashboard.docker_volumes(volumes, "nfs", false)), 1)
end
function test_docker__redes_ordem_contagem_de_containers_e_filtro()
local redes = {
{ name = "zz", id = "n2", driver = "bridge", scope = "local", in_use = false },
{ name = "aa", id = "n1", driver = "bridge", scope = "local", in_use = true, container_count = 3, project = "loja" },
}
local linhas = json.decode(Dashboard.docker_networks(redes, "", false))
assert_eq(linhas[1].name, "aa")
assert_eq(linhas[1].containers, "3")
assert_eq(linhas[1].project, "loja")
assert_eq(linhas[2].containers, "0")
assert_eq(linhas[2].project, "—")
assert_eq(#json.decode(Dashboard.docker_networks(redes, "", true)), 1)
end
function test_docker__containers_dono_removivel_so_parado_imagem_sem_sha256()
local linhas = json.decode(Dashboard.docker_containers({
{ id = "0123456789abcdef", name = "rp_api", image = "sha256:abcdef", state = "running", project = "loja", service = "api" },
{ id = "b", name = "rp_db", image = "pg:16", state = "exited", managed = true },
{ id = "c", name = "outro", image = "x", state = "created" },
}, ""))
assert_eq(#linhas, 3)
-- ordenados por nome: outro, rp_api, rp_db
assert_eq(linhas[1].name, "outro")
assert_eq(linhas[1].owner, "—")
assert_eq(linhas[2].id, "0123456789ab")
assert_eq(linhas[2].image, "abcdef")
assert_eq(linhas[2].can_remove, "0")
assert_eq(linhas[2].state_kind, "ok")
assert_eq(linhas[3].owner, Util.ellipsis("rustploy", Util.column_budgets().state))
assert_eq(linhas[3].can_remove, "1")
end
function test_docker__containers_a_busca_olha_nome_imagem_estado_e_dono()
local lista = {
{ name = "a", image = "pg:16", state = "running" },
{ name = "b", image = "x", state = "exited", project = "loja", service = "web" },
}
assert_eq(#json.decode(Dashboard.docker_containers(lista, "pg")), 1)
assert_eq(#json.decode(Dashboard.docker_containers(lista, "exited")), 1)
assert_eq(#json.decode(Dashboard.docker_containers(lista, "loja")), 1)
assert_eq(Dashboard.docker_containers(nil, ""), "[]")
end
function test_ingress_portas_e_monitoramento__ingress_uma_linha_por_rota_com_a_porta_do_upstream()
local a = par("api", "loja")
a.svc.spec.domains = { { domain = "a.com", port = 3000, tls = true }, { domain = "b.com" } }
local texto, total = Dashboard.ingress({ a })
local linhas = json.decode(texto)
assert_eq(total, 2)
assert_eq(linhas[1].url, "https://a.com")
assert_eq(linhas[1].upstream, ":3000")
assert_eq(linhas[1].tls, "TLS")
assert_eq(linhas[2].url, "http://b.com")
assert_eq(linhas[2].upstream, ":8080")
assert_eq(linhas[2].tls, "—")
end
function test_ingress_portas_e_monitoramento__ingress_ignora_dominio_em_branco_e_entende_o_campo_legado()
local vazio = par("a", "p")
vazio.svc.spec.domains = { { domain = " " } }
local legado = par("b", "p")
legado.svc.spec.domain = "velho.com"
local _, total = Dashboard.ingress({ vazio, legado, par("c", "p") })
assert_eq(total, 1)
local texto, zero = Dashboard.ingress({})
assert_eq(texto, "[]")
assert_eq(zero, 0)
end
function test_ingress_portas_e_monitoramento__portas_de_host_so_quem_tem_host_port_em_ordem_numerica()
local a, b = par("a", "p"), par("b", "p")
a.svc.spec.host_port = 9000
b.svc.spec.host_port = 80
local texto, total = Dashboard.host_ports({ a, b, par("c", "p") })
local linhas = json.decode(texto)
assert_eq(total, 2)
assert_eq(linhas[1].host_port, "80")
assert_eq(linhas[2].host_port, "9000")
assert_eq(linhas[1].container_port, "8080")
assert_eq(linhas[1].host_port_n, 80)
end
function test_ingress_portas_e_monitoramento__monitoramento_so_servicos_com_metricas_vivas_com_valores_crus()
local linhas = json.decode(Dashboard.monitoring(
{ par("api", "loja"), par("web", "loja") },
{ ["id-api"] = { cpu_percent = 50, mem_used_bytes = 2048, net_rx_bytes = 1024, net_tx_bytes = 0 } }
))
assert_eq(#linhas, 1)
assert_eq(linhas[1].name, "api")
assert_eq(linhas[1].cpu, "50.0%")
assert_eq(linhas[1].mem, "2 KB")
assert_eq(linhas[1].rx, "1 KB")
assert_eq(linhas[1].tx, "—")
assert_eq(linhas[1].cpu_n, 50)
assert_eq(linhas[1].mem_n, 2048)
assert_eq(Dashboard.monitoring({ par("a", "p") }, nil), "[]")
end
local function info(estado, extras)
local base = { state = estado, service_name = "api", project_name = "loja", elapsed_secs = 75, current_state_secs = 5, service_id = "s1", deployment_id = "d1", states = {} }
for k, v in extras or {} do
base[k] = v
end
return base
end
local function status_dos_passos(i)
local passos = json.decode(Dashboard.deploy_engine_detail_steps(i))
local lista = {}
for _, passo in passos do
table.insert(lista, passo.status)
end
return lista, passos
end
function test_motor_de_deploy__sao_oito_passos_do_fila_ao_live()
local _, passos = status_dos_passos(info("Pending"))
assert_eq(#passos, 8)
assert_eq(passos[1].text, "● Fila")
assert_eq(passos[8].text, "○ Live")
end
function test_motor_de_deploy__em_andamento_os_anteriores_feitos_o_atual_marcado_os_seguintes_pendentes()
assert_eq(status_dos_passos(info("BuildingImage")), { "done", "done", "done", "current", "pending", "pending", "pending", "pending" })
assert_eq(status_dos_passos(info("Pending")), { "current", "pending", "pending", "pending", "pending", "pending", "pending", "pending" })
assert_eq(status_dos_passos(info("Draining")), { "done", "done", "done", "done", "done", "done", "current", "pending" })
end
function test_motor_de_deploy__os_quatro_estados_de_obter_caem_no_mesmo_passo()
for _, estado in { "PullingImage", "CloningRepo", "BuildingImage", "ComposingUp" } do
assert_eq(status_dos_passos(info(estado))[4], "current")
end
end
function test_motor_de_deploy__live_stopped_e_pruning_terminam_com_tudo_feito()
for _, estado in { "Live", "Stopped", "Pruning" } do
local lista = status_dos_passos(info(estado))
for _, status in lista do
assert_eq(status, "done")
end
end
end
function test_motor_de_deploy__falha_marca_o_passo_em_que_estava_achado_no_historico()
local falhou = info("Failed", {
states = {
{ from = "Pending", to = "BuildingImage" },
{ from = "BuildingImage", to = "HealthcheckPolling" },
{ from = "HealthcheckPolling", to = "Failed" },
},
})
assert_eq(status_dos_passos(falhou), { "done", "done", "done", "done", "done", "failed", "pending", "pending" })
end
function test_motor_de_deploy__falha_sem_historico_nao_marca_nenhum_passo_como_atual()
local lista = status_dos_passos(info("Failed"))
for _, status in lista do
assert_ne(status, "current")
end
end
function test_motor_de_deploy__estado_desconhecido_deixa_tudo_pendente()
local lista = status_dos_passos(info("Qualquer"))
for _, status in lista do
assert_eq(status, "pending")
end
end
function test_motor_de_deploy__detalhe_duracao_entre_transicoes_tipo_e_motivo()
local linhas = json.decode(Dashboard.deploy_engine_detail(info("Failed", {
states = {
{ to = "Pending", at = "2026-03-01T10:00:00Z" },
{ to = "BuildingImage", at = "2026-03-01T10:00:10Z" },
{ to = "Failed", at = "2026-03-01T10:01:10Z", message = "\nerro no build\nlinha 2" },
},
})))
assert_eq(#linhas, 3)
assert_eq(linhas[1].label, "Pending")
assert_eq(linhas[1].dur, "10s")
assert_eq(linhas[1].kind, "ok")
assert_eq(linhas[2].dur, "1m 0s")
assert_eq(linhas[3].kind, "bad")
assert_eq(linhas[3].dur, "—")
assert_eq(linhas[3].msg, "erro no build")
end
function test_motor_de_deploy__detalhe_a_transicao_corrente_mostra_o_tempo_no_estado_e_fica_info()
local linhas = json.decode(Dashboard.deploy_engine_detail(info("BuildingImage", {
current_state_secs = 42,
states = {
{ to = "Pending", at = "2026-03-01T10:00:00Z" },
{ to = "BuildingImage", at = "2026-03-01T10:00:10Z" },
},
})))
assert_eq(linhas[2].dur, "42s")
assert_eq(linhas[2].kind, "info")
assert_eq(linhas[1].kind, "ok")
end
function test_motor_de_deploy__detalhe_timestamp_invalido_nao_da_duracao_negativa()
local linhas = json.decode(Dashboard.deploy_engine_detail(info("Live", {
states = { { to = "Pending", at = "lixo" }, { to = "Live", at = "lixo" } },
})))
assert_eq(linhas[1].dur, "0s")
end
function test_motor_de_deploy__executando_agora_traz_estado_tempos_e_os_passos()
local linhas = json.decode(Dashboard.deploy_engine_active({ info("BuildingImage") }))
assert_eq(#linhas, 1)
assert_eq(linhas[1].service, "api")
assert_eq(linhas[1].state_label, "BUILDING")
assert_eq(linhas[1].total, "1m 15s")
assert_eq(linhas[1].phase, "5s")
assert_eq(linhas[1].deployment_id, "d1")
assert_eq(#linhas[1].steps, 8)
assert_eq(Dashboard.deploy_engine_active(nil), "[]")
end
function test_motor_de_deploy__a_fila_numera_de_1_e_guarda_o_id_para_cancelar()
local linhas = json.decode(Dashboard.deploy_engine_queued({ info("Pending", { deployment_id = "q1" }), info("Pending", { deployment_id = "q2" }) }))
assert_eq(linhas[1].pos, "1")
assert_eq(linhas[2].pos, "2")
assert_eq(linhas[2].deployment_id, "q2")
assert_eq(Dashboard.deploy_engine_queued({}), "[]")
end
function test_motor_de_deploy__o_historico_escolhe_o_icone_pelo_resultado()
local linhas = json.decode(Dashboard.deploy_engine_recent({
info("Live", { started_at = "2026-03-01T10:00:00Z" }),
info("Failed"),
info("Stopped"),
}))
assert_eq(linhas[1].icon, "✓")
assert_eq(linhas[2].icon, "✕")
assert_eq(linhas[3].icon, "○")
assert_eq(linhas[1].duration, "1m 15s")
assert_match(linhas[1].start, "^%d%d:%d%d:%d%d$")
assert_eq(linhas[1].start_iso, "2026-03-01T10:00:00Z")
assert_eq(linhas[2].start_iso, "")
assert_eq(linhas[1].elapsed_secs, 75)
end