From 374781d0b6c034d967fcc424f1e79549ec42a878 Mon Sep 17 00:00:00 2001 From: Paulo Victor T Silva Date: Sat, 14 Nov 2026 16:04:35 -0300 Subject: [PATCH 1/3] =?UTF-8?q?fix(cli):=20desfazer=20com=20zero=20pend?= =?UTF-8?q?=C3=AAncias=20pergunta=20e=20revalida=20antes=20de=20remover=20?= =?UTF-8?q?o=20backup=20(privacidade=20e=20anima=C3=A7=C3=B5es);=20testes?= =?UTF-8?q?=20do=20--yes=20com=20mudan=C3=A7a=20entre=20leituras?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CLAUDE.md | 2 +- docs/otimizacao.md | 2 +- docs/privacidade.md | 2 +- internal/cli/apps_nativos_fake_test.go | 7 + internal/cli/otimizacao_animacoes.go | 14 +- internal/cli/privacidade.go | 32 ++- internal/cli/privacidade_test.go | 21 +- internal/cli/toctou_yes_test.go | 313 +++++++++++++++++++++++++ internal/msg/msg.go | 80 ++++--- 9 files changed, 413 insertions(+), 60 deletions(-) create mode 100644 internal/cli/toctou_yes_test.go diff --git a/CLAUDE.md b/CLAUDE.md index 970dd00..5c17648 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -12,7 +12,7 @@ Ferramenta em Go para preparar máquinas Windows, Linux e macOS com um comando ( - `docs/diagnostico.md`: `toolkit diagnostico` (só leitura; funciona sem admin e lê mais quando já roda como admin, sem nunca elevar sozinho: `Deps.Admin`, `Skipped.NeedsAdmin`): o que cada SO lê, regras e limiares do resumo "o que está ruim e o que fazer", série, UUID, MAC e hostname lidos, informações sem máscara (decisão do Paulo: é ferramenta de análise), `--completo`, `--json`, `--relatorio`. Código em `internal/diagnostico` (coleta_win/lin/mac, analise, relatorio) e `internal/cli/diagnostico.go`; coletores só pelo `exec.ReadOnlyRunner` e `Deps` injetáveis. - `docs/rede.md`: `toolkit rede` (só leitura; sem Elevate, sem varredura, sem escrita, sem requisição externa): o que cada SO lê, achados e severidades (5 níveis, portas sensíveis em lista fechada), administrador, limites honestos, o que NUNCA faz. Aba da TUI em `docs/tui.md` (Rede › Análise). IP público e portal cativo SÓ sob pedido (`toolkit rede ip`/`portal`, tecla `o`/`w` na TUI; PR9, decisões 1 e 2 do plano): sem serviço padrão, só com URL informada, confirmação que nomeia o serviço, sem redirecionamento. - `docs/otimizacao.md`: `toolkit otimizacao` (só Windows, SÓ LEITURA; parte A da função 3: gargalos de CPU, memória, disco do sistema, inicialização, serviços automáticos e boot (evento 100; sem evento = "sem dado", nunca "rápido")): o que lê (CIM `Win32_PerfFormattedData_*`, não `Get-Counter`, que é traduzido), limiares com fronteira testada, lista fixa do que NÃO faz (`NeverList`/`NeverRecommendTerms`), `--completo`, `--json`, `--relatorio`, seção Otimização da TUI. Código em `internal/otimizacao` e `internal/cli/otimizacao.go`. **Parte B (PR12, EXPERIMENTAL): `toolkit otimizacao animacoes [--dry-run] [--yes]` e `... desfazer`** (`internal/animacoes`, `internal/cli/otimizacao_animacoes.go`): catálogo FECHADO só HKCU com o único valor confirmado em fonte oficial (`MinAnimate` REG_SZ "0"; `TaskbarAnimations` e `VisualFXSetting` ficaram fora, A VERIFICAR), plano antes, backup por SID (0600, dono gravado) ANTES da 1ª escrita e validado contra o catálogo antes de qualquer leitura/escrita, reaplicar não sobrescreve o original, desfazer restaura tipo e conteúdo (apaga só o que não existia), System das animações recusa tudo fora de `HKCU\\` (`ErrSoHKCU`), nunca Elevate, reaproveita o `reg.exe` da privacidade (ausência provada). TUI: Máquina › Otimização, `m` alterna Gargalos/Animações (`internal/tui/otimizacao_anim.go`: p, a…, d…, c; confirmação única, plano por ID de uso único, faixa de resultado). -- `docs/privacidade.md`: `toolkit privacidade` (só Windows): perfis, plano antes, backup e `desfazer`, administrador explícito, `--dry-run`. +- `docs/privacidade.md`: `toolkit privacidade` (só Windows): perfis, plano antes, backup e `desfazer` (com zero pendências também pergunta e revalida antes de remover o backup; o mesmo nas animações), administrador explícito, `--dry-run`. - `docs/apps-nativos.md`: `toolkit apps-nativos` (só Windows): catálogo fechado e lista de negação, perfis, escopo usuário x todos, administrador, backup, como reinstalar (sem desfazer automático), aba da TUI. - `docs/receitas.md`: formato das receitas, ciclo de reboot e retomada, exemplos e a seção do `diag-rede` (Linux e macOS, só leitura, sem máscara, alvos por `TOOLKIT_DIAG_*` e idioma por `TOOLKIT_LANG`/`LANG`). Resumo legível dos diagnósticos: campo `render` (renderizadores em `internal/diagfmt`: windows/linux/macos memory e disks), tecla `d` na aba Diagnóstico e `recipe run --detalhes` mostram a saída original; Log da TUI com `✓ nome`. - `SECURITY.md`: como reportar e as regras garantidas (hash obrigatório etc.). diff --git a/docs/otimizacao.md b/docs/otimizacao.md index 91ff272..24df09e 100644 --- a/docs/otimizacao.md +++ b/docs/otimizacao.md @@ -142,7 +142,7 @@ backup; se algo falha no meio, o que não foi restaurado fica no backup. **Revalidação depois da confirmação (CLI).** Depois do `[s/N]` (e também com `--yes`, logo antes de aplicar) e ANTES de qualquer backup ou escrita, o comando recalcula o plano e exige o MESMO texto e as mesmas pendências do que foi mostrado; no desfazer -reconfere também o backup (mesmo conteúdo). Divergência (outro processo mexeu no valor durante a pergunta) = +reconfere também o backup (mesmo conteúdo). Isso vale também para o desfazer com ZERO pendências: pergunta "Tudo já está como antes. Remover o backup? [s/N]" (sem terminal exige `--yes`), revalida e só então remove o backup; `--dry-run` nunca remove. Divergência (outro processo mexeu no valor durante a pergunta) = `o estado mudou desde o plano mostrado; nada foi alterado; veja o plano de novo`, zero mutações e backup intacto. **Leitura do registro.** Pelo mesmo `reg.exe` da privacidade (caminho absoluto, `ReadOnlyRunner` para ler e `MutatingRunner` para diff --git a/docs/privacidade.md b/docs/privacidade.md index 2547bab..b72ce2c 100644 --- a/docs/privacidade.md +++ b/docs/privacidade.md @@ -33,7 +33,7 @@ Limite real: no Windows Home e Pro o mínimo de dados de diagnóstico é "obriga ## Backup e desfazer - Arquivos na pasta de estado do toolkit (`C:\ProgramData\toolkit` como administrador, `%LOCALAPPDATA%\toolkit` como usuário), permissão 0600, escrita atômica, e SEPARADOS por escopo: `privacidade-backup-.json` (só os valores `HKCU`, de cada usuário; o SID vem de `whoami /user`) e `privacidade-backup-maquina.json` (`HKLM`, serviços e tarefas, compartilhados). Cada arquivo grava o dono; um arquivo de outro dono (copiado ou renomeado) é recusado e fica intacto. Dois administradores não compartilham nem desfazem o `HKCU` um do outro. -- O backup é tratado como dado não confiável: ANTES de ler ou mudar qualquer coisa, o `desfazer` confere CADA entrada contra o catálogo (ID, chave e nome, serviço ou caminho da tarefa idênticos aos do catálogo; tipo de valor e de início conhecidos). Entrada fora do catálogo ou de tipo desconhecido recusa o desfazer inteiro, sem mutação, e o arquivo é preservado. O `desfazer --dry-run` nunca remove nem escreve nada, nem com zero pendências. +- O backup é tratado como dado não confiável: ANTES de ler ou mudar qualquer coisa, o `desfazer` confere CADA entrada contra o catálogo (ID, chave e nome, serviço ou caminho da tarefa idênticos aos do catálogo; tipo de valor e de início conhecidos). Entrada fora do catálogo ou de tipo desconhecido recusa o desfazer inteiro, sem mutação, e o arquivo é preservado. O `desfazer --dry-run` nunca remove nem escreve nada, nem com zero pendências. Com zero pendências ("tudo já está como antes") o `desfazer` NÃO remove o backup direto: pergunta "Tudo já está como antes. Remover o backup? [s/N]" (sem terminal exige `--yes`), relê o backup e o estado e só remove se forem idênticos aos mostrados; senão recusa com "o estado mudou desde o plano mostrado; nada foi alterado" e o backup fica intacto (mesmo critério com e sem `--yes`; na TUI o botão `Remover backup` já usa o plano por ID revalidado). - Guarda o estado ORIGINAL de cada item (valor do registro ou "não existia", tipo de início e se rodava o serviço, se a tarefa estava habilitada). Aplicar duas vezes nunca sobrescreve o original. - `desfazer` restaura o valor (ou apaga o que não existia), reconfigura serviços e tarefas e, no fim, apaga o backup. Falha no meio deixa no backup só o que sobrou. - Como o backup fica na pasta de estado de quem aplicou, rode o `desfazer` no mesmo nível (administrador ou usuário) em que rodou o `aplicar`. diff --git a/internal/cli/apps_nativos_fake_test.go b/internal/cli/apps_nativos_fake_test.go index e263254..160f2fd 100644 --- a/internal/cli/apps_nativos_fake_test.go +++ b/internal/cli/apps_nativos_fake_test.go @@ -18,6 +18,9 @@ type natSys struct { others []appsnativos.Package provisioned []appsnativos.Provisioned removes []string + // onList (opcional) roda no início de cada ListInstalled, com o número da chamada: simula outro processo. + lists int + onList func(call int) } func newNatSys(admin bool, names ...string) *natSys { @@ -36,6 +39,10 @@ func natPkg(name string) appsnativos.Package { func (s *natSys) IsAdmin(context.Context) bool { return s.admin } func (s *natSys) UserSID(context.Context) (string, error) { return "S-1-5-21-1-2-3-1001", nil } func (s *natSys) ListInstalled(_ context.Context, all bool) ([]appsnativos.Package, error) { + s.lists++ + if s.onList != nil { + s.onList(s.lists) + } if all && !s.admin { return nil, exec.ErrNotElevated } diff --git a/internal/cli/otimizacao_animacoes.go b/internal/cli/otimizacao_animacoes.go index addf760..04348d2 100644 --- a/internal/cli/otimizacao_animacoes.go +++ b/internal/cli/otimizacao_animacoes.go @@ -150,11 +150,13 @@ func runAnimUndo(ctx context.Context, out io.Writer, deps Deps, f animFlags) err _, _ = fmt.Fprintln(out, msg.PrivDryRunDone) return nil } - if plan.Pending() == 0 { + zero := plan.Pending() == 0 // tudo já está como antes: só o backup seria removido, mas com a MESMA cautela do restaurar + question := msg.AnimConfirmUndo + if zero { _, _ = fmt.Fprintln(out, msg.AnimUndoNothing) - return cleanErr(e.store.Remove()) + question = msg.AnimConfirmUndoNothing } - if ok, err := privConfirm(ctx, out, deps, f.yes, msg.AnimConfirmUndo); !ok || err != nil { + if ok, err := privConfirm(ctx, out, deps, f.yes, question); !ok || err != nil { return err } // Reconfere backup (mesmo conteúdo) e estado atual (mesmo plano) antes de restaurar qualquer coisa. @@ -168,6 +170,12 @@ func runAnimUndo(ctx context.Context, out io.Writer, deps Deps, f animFlags) err if formatAnimUndo(fresh) != formatAnimUndo(plan) || fresh.Pending() != plan.Pending() || !reflect.DeepEqual(freshBk, bk) { return errors.New(msg.AnimStateChanged) } + if zero { + if err := e.store.Remove(); err != nil { + return cleanErr(err) + } + return nil + } res, err := animacoes.ApplyUndo(ctx, e.sys, e.store, fresh, freshBk) if err != nil { if res != nil && len(res.Applied) > 0 { diff --git a/internal/cli/privacidade.go b/internal/cli/privacidade.go index a0a0596..45819b3 100644 --- a/internal/cli/privacidade.go +++ b/internal/cli/privacidade.go @@ -237,34 +237,40 @@ func runPrivUndo(ctx context.Context, out io.Writer, deps Deps, f privFlags) err if err != nil { return cleanErr(err) } - if plan.Pending() == 0 { - _, _ = fmt.Fprintln(out, textsafe.Multiline(formatUndo(plan))) - if f.dryRun { // dry-run nunca remove nem escreve nada - _, _ = fmt.Fprintln(out, msg.PrivDryRunDone) - return nil - } - _, _ = fmt.Fprintln(out, msg.PrivUndoNothing) - return e.store.Remove() - } + zero := plan.Pending() == 0 // tudo já está como antes: só o backup seria removido, mas com a MESMA cautela do restaurar _, _ = fmt.Fprint(out, textsafe.Multiline(formatUndo(plan))) - if f.dryRun { + if f.dryRun { // dry-run nunca remove nem escreve nada, nem com zero pendências _, _ = fmt.Fprintln(out, msg.PrivDryRunDone) return nil } - if plan.NeedsAdmin() && !e.sys.IsAdmin(ctx) { + question := msg.PrivConfirmUndo + if zero { + _, _ = fmt.Fprintln(out, msg.PrivUndoNothing) + question = msg.PrivConfirmUndoNothing + } else if plan.NeedsAdmin() && !e.sys.IsAdmin(ctx) { return errors.New(msg.PrivUndoNeedsAdm) } - if ok, err := privConfirm(ctx, out, deps, f.yes, msg.PrivConfirmUndo); !ok || err != nil { + if ok, err := privConfirm(ctx, out, deps, f.yes, question); !ok || err != nil { return err } - // backup e sistema são relidos DEPOIS da confirmação e comparados ao que foi mostrado, antes de restaurar qualquer coisa. + // backup e sistema são relidos DEPOIS da confirmação e comparados ao que foi mostrado, antes de restaurar ou + // remover qualquer coisa (vale também com --yes e com zero pendências). fresh, freshBk, err := privacidade.BuildUndo(ctx, e.sys, e.store, e.lang) + if errors.Is(err, privacidade.ErrNoBackup) { + return errors.New(msg.PrivStale) + } if err != nil { return cleanErr(err) } if formatUndo(fresh) != formatUndo(plan) || fresh.Pending() != plan.Pending() || !reflect.DeepEqual(freshBk, bk) { return errors.New(msg.PrivStale) } + if zero { + if err := e.store.Remove(); err != nil { + return cleanErr(err) + } + return nil + } plan, bk = fresh, freshBk res, err := privacidade.ApplyUndo(ctx, e.sys, e.store, plan, bk) if err != nil { diff --git a/internal/cli/privacidade_test.go b/internal/cli/privacidade_test.go index b49243e..28b6c75 100644 --- a/internal/cli/privacidade_test.go +++ b/internal/cli/privacidade_test.go @@ -22,6 +22,10 @@ type privSys struct { svcs map[string]*privacidade.ServiceState tasks map[string]*privacidade.TaskState writes int + // onEdition (opcional) roda no INÍCIO de cada Edition (uma por Build/BuildUndo), com o número da chamada (1, 2...): + // simula outro processo mexendo entre a leitura do plano e a de revalidação. + editions int + onEdition func(call int) // gate bloqueia a PRÓXIMA leitura de edição (armed) até o teste liberar: simula um plano lento/cancelado. armed atomic.Bool entered chan struct{} @@ -45,6 +49,10 @@ func newPrivSys(admin bool) *privSys { func pk(key, name string) string { return strings.ToUpper(key) + "|" + name } func (s *privSys) Edition(context.Context) (string, error) { + s.editions++ + if s.onEdition != nil { + s.onEdition(s.editions) + } if s.armed.CompareAndSwap(true, false) { s.entered <- struct{}{} <-s.gate @@ -102,9 +110,18 @@ func (s *privSys) TaskSetEnabled(_ context.Context, p string, e bool) error { return nil } -type privStore struct{ b *privacidade.Backup } +type privStore struct { + b *privacidade.Backup + // afterLoad (opcional) roda DEPOIS de cada Load, com o número da chamada: simula o backup mudando entre leituras. + loads int + afterLoad func(call int) +} func (m *privStore) Load() (*privacidade.Backup, error) { + m.loads++ + if m.afterLoad != nil { + defer m.afterLoad(m.loads) + } if m.b == nil { return nil, nil } @@ -356,7 +373,7 @@ func TestUndoDryRunSemPendenciasPreservaOBackup(t *testing.T) { if st.b == nil || len(st.b.Entries) != 1 { t.Fatal("desfazer --dry-run apagou o backup") } - if _, err := runPriv(t, privDeps(t, sys, st, "windows", false, ""), "desfazer"); err != nil || st.b != nil { + if _, err := runPriv(t, privDeps(t, sys, st, "windows", false, ""), "desfazer", "--yes"); err != nil || st.b != nil { t.Errorf("sem --dry-run o backup sem pendências deve ser removido: %v %v", err, st.b) } } diff --git a/internal/cli/toctou_yes_test.go b/internal/cli/toctou_yes_test.go new file mode 100644 index 0000000..71b2a31 --- /dev/null +++ b/internal/cli/toctou_yes_test.go @@ -0,0 +1,313 @@ +package cli + +import ( + "context" + "encoding/json" + "errors" + "strings" + "testing" + + "github.com/PiluTech/toolkit/internal/privacidade" + "github.com/PiluTech/toolkit/internal/tui" +) + +// Lupa #85: com --yes não há pergunta, mas ainda existe a janela entre a leitura que monta o plano mostrado e a de +// revalidação. Estes testes mudam o sistema ou o backup ENTRE as duas leituras (hook no System/Store falso). + +func mustStale(t *testing.T, err error) { + t.Helper() + if err == nil || !strings.Contains(err.Error(), staleMsg) { + t.Fatalf("esperava %q, veio err=%v", staleMsg, err) + } +} + +func TestPrivacidadeAplicarYesRecusaSeEstadoMudaEntreLeituras(t *testing.T) { + sys, st := newPrivSys(true), &privStore{} + sys.onEdition = func(call int) { + if call == 2 { // início da releitura de revalidação + sys.regs[pk(advKey, "Enabled")] = privacidade.DWORD(1) + } + } + _, err := runPriv(t, privDeps(t, sys, st, "windows", false, ""), "aplicar", "--perfil", "basico", "--yes") + mustStale(t, err) + if sys.writes != 0 || st.b != nil { + t.Errorf("zero mutações: writes=%d backup=%v", sys.writes, st.b) + } + if v := sys.regs[pk(advKey, "Enabled")]; v.DWORD != 1 { + t.Errorf("valor do outro processo perdido: %+v", v) + } +} + +func TestPrivacidadeDesfazerYesRecusaSeBackupOuEstadoMudaEntreLeituras(t *testing.T) { + cases := map[string]func(sys *privSys, st *privStore){ + "estado": func(sys *privSys, _ *privStore) { sys.svcs["DiagTrack"].StartType = "manual" }, + "backup": func(_ *privSys, st *privStore) { // a Edition #1 vem depois do Load do plano: a releitura já vê a mudança + for k, e := range st.b.Entries { + if e.Kind == "reg" { + e.Existed = !e.Existed + st.b.Entries[k] = e + return + } + } + }, + } + for name, mut := range cases { + t.Run(name, func(t *testing.T) { + sys, st := newPrivSys(true), &privStore{} + if _, err := runPriv(t, privDeps(t, sys, st, "windows", false, ""), "aplicar", "--perfil", "recomendado", "--yes"); err != nil { + t.Fatal(err) + } + w := sys.writes + sys.editions = 0 + at := map[bool]int{true: 2, false: 1}[name == "estado"] + sys.onEdition = func(call int) { + if call == at { + mut(sys, st) + } + } + _, err := runPriv(t, privDeps(t, sys, st, "windows", false, ""), "desfazer", "--yes") + mustStale(t, err) + if sys.writes != w || st.b == nil { + t.Errorf("nada pode mudar: writes=%d backup=%v", sys.writes-w, st.b) + } + }) + } +} + +func TestAnimacoesDesfazerYesRecusaSeBackupOuEstadoMudaEntreLeituras(t *testing.T) { + cases := map[string]func(sys *animSys, st *privStore){ + "estado": func(sys *animSys, _ *privStore) { sys.set(animStr("5")) }, + "backup": func(_ *animSys, st *privStore) { + for id, e := range st.b.Entries { + e.Existed, e.Str = false, "" + st.b.Entries[id] = e + } + }, + } + for name, mut := range cases { + t.Run(name, func(t *testing.T) { + sys, st := animApplied(t) + before, _ := json.Marshal(st.b) + w := sys.writes + sys.afterRead = func() { mut(sys, st) } // depois da 1ª leitura (a do plano mostrado) + _, err := runAnim(t, animDeps(t, sys, st, "windows", false, ""), "animacoes", "desfazer", "--yes") + mustStale(t, err) + after, _ := json.Marshal(st.b) + if sys.writes != w || st.b == nil || (name == "estado" && string(before) != string(after)) { + t.Errorf("nada pode mudar: writes=%d backup=%v", sys.writes-w, st.b) + } + }) + } +} + +func TestAppsNativosRemoverYesRecusaSeEstadoMudaEntreLeituras(t *testing.T) { + sys, st := newNatSys(false, pkgWeather), &natStore{} + sys.onList = func(call int) { + if call == 2 { // início da releitura de revalidação + sys.installed[0].Version = "9.9.9.0" + sys.installed[0].PackageFullName = pkgWeather + "_9.9.9.0_x64__8wekyb3d8bbwe" + } + } + _, err := runNat(t, natDeps(t, sys, st, "windows", false, ""), "remover", "--app", "bing-weather", "--yes") + mustStale(t, err) + if len(sys.removes) != 0 || st.b != nil { + t.Errorf("nada pode mudar: removes=%v backup=%v", sys.removes, st.b) + } +} + +// ---- desfazer com ZERO pendências: a remoção do backup também só vem depois da revalidação ---- + +// privZeroStore: backup com uma entrada de registro que não existia e continua não existindo (zero pendências). +func privZeroStore() (*privSys, *privStore) { + e := privacidade.Entry{ID: "reg:" + advKey + "|Enabled", Kind: "reg", Key: advKey, Name: "Enabled"} + return newPrivSys(false), &privStore{b: &privacidade.Backup{Version: 1, Entries: map[string]privacidade.Entry{e.ID: e}}} +} + +func TestPrivacidadeDesfazerZeroPendenciasRevalidaAntesDeRemover(t *testing.T) { + cases := map[string]func(sys *privSys, st *privStore){ + "estado": func(sys *privSys, _ *privStore) { sys.regs[pk(advKey, "Enabled")] = privacidade.DWORD(1) }, + "backup": func(_ *privSys, st *privStore) { + for k, e := range st.b.Entries { + e.Existed = true + st.b.Entries[k] = e + } + }, + "sumiu": func(_ *privSys, st *privStore) { st.b = nil }, + } + for name, mut := range cases { + for _, yes := range []bool{true, false} { + t.Run(name+map[bool]string{true: "/yes", false: "/pergunta"}[yes], func(t *testing.T) { + sys, st := privZeroStore() + orig, _ := json.Marshal(st.b) + at := map[bool]int{true: 2, false: 1}[name == "estado"] + sys.onEdition = func(call int) { + if call == at { + mut(sys, st) + } + } + deps, args := privDeps(t, sys, st, "windows", !yes, "s\n"), []string{"desfazer"} + if yes { + args = append(args, "--yes") + } + _, err := runPriv(t, deps, args...) + mustStale(t, err) + if name == "sumiu" { + return + } + if st.b == nil { + t.Fatal("o backup foi removido sem revalidar") + } + if name == "estado" { + if cur, _ := json.Marshal(st.b); string(cur) != string(orig) { + t.Errorf("backup alterado:\n%s\n%s", orig, cur) + } + } + }) + } + } +} + +func TestPrivacidadeDesfazerZeroPendenciasPerguntaERemove(t *testing.T) { + sys, st := privZeroStore() + out, err := runPriv(t, privDeps(t, sys, st, "windows", true, "s\n"), "desfazer") + if err != nil || st.b != nil { + t.Fatalf("err=%v backup=%v\n%s", err, st.b, out) + } + sys, st = privZeroStore() + if _, err = runPriv(t, privDeps(t, sys, st, "windows", true, "n\n"), "desfazer"); err != nil || st.b == nil { + t.Errorf("recusa da pergunta não remove: err=%v backup=%v", err, st.b) + } + sys, st = privZeroStore() + if _, err = runPriv(t, privDeps(t, sys, st, "windows", false, ""), "desfazer"); err == nil || st.b == nil { + t.Errorf("sem terminal e sem --yes exige --yes e preserva o backup: err=%v", err) + } +} + +// animZero: backup e estado iguais (zero pendências). +func animZero(t *testing.T) (*animSys, *privStore) { + t.Helper() + sys, st := animApplied(t) + sys.set(animStr("1")) // volta ao valor original: nada a restaurar + return sys, st +} + +func TestAnimacoesDesfazerZeroPendenciasRevalidaAntesDeRemover(t *testing.T) { + cases := map[string]func(sys *animSys, st *privStore){ + "estado": func(sys *animSys, _ *privStore) { sys.set(animStr("5")) }, + "backup": func(_ *animSys, st *privStore) { + for id, e := range st.b.Entries { + e.Existed, e.Str = false, "" + st.b.Entries[id] = e + } + }, + "sumiu": func(_ *animSys, st *privStore) { st.b = nil }, + } + for name, mut := range cases { + for _, yes := range []bool{true, false} { + t.Run(name+map[bool]string{true: "/yes", false: "/pergunta"}[yes], func(t *testing.T) { + sys, st := animZero(t) + orig, _ := json.Marshal(st.b) + sys.afterRead = func() { mut(sys, st) } + d, args := animDeps(t, sys, st, "windows", !yes, "s\n"), []string{"animacoes", "desfazer"} + if yes { + args = append(args, "--yes") + } + _, err := runAnim(t, d, args...) + mustStale(t, err) + if name == "sumiu" { + return + } + if st.b == nil { + t.Fatal("o backup foi removido sem revalidar") + } + if name == "estado" { + if cur, _ := json.Marshal(st.b); string(cur) != string(orig) { + t.Errorf("backup alterado:\n%s\n%s", orig, cur) + } + } + }) + } + } +} + +func TestAnimacoesDesfazerZeroPendenciasPerguntaERemove(t *testing.T) { + sys, st := animZero(t) + if _, err := runAnim(t, animDeps(t, sys, st, "windows", true, "s\n"), "animacoes", "desfazer"); err != nil || st.b != nil { + t.Fatalf("err=%v backup=%v", err, st.b) + } + sys, st = animZero(t) + if _, err := runAnim(t, animDeps(t, sys, st, "windows", true, "n\n"), "animacoes", "desfazer"); err != nil || st.b == nil { + t.Errorf("recusa da pergunta não remove: err=%v backup=%v", err, st.b) + } + sys, st = animZero(t) + if _, err := runAnim(t, animDeps(t, sys, st, "windows", false, ""), "animacoes", "desfazer"); err == nil || st.b == nil { + t.Errorf("sem terminal e sem --yes exige --yes e preserva o backup: err=%v", err) + } + sys, st = animZero(t) + if _, err := runAnim(t, animDeps(t, sys, st, "windows", false, ""), "animacoes", "desfazer", "--dry-run"); err != nil || st.b == nil { + t.Errorf("--dry-run nunca remove: err=%v backup=%v", err, st.b) + } +} + +// ---- TUI: o plano de desfazer por ID já revalida; zero pendências não é exceção ---- + +func TestPrivacyBackendUndoZeroPendenciasRevalida(t *testing.T) { + ctx := context.Background() + for _, name := range []string{"estado", "backup"} { + t.Run(name, func(t *testing.T) { + sys, st := privZeroStore() + b := privBackend(t, sys, st, "windows") + if up, err := b.UndoPlan(ctx); err != nil || up.Pending != 0 { + t.Fatalf("%+v %v", up, err) + } + id := b.lastID() + if name == "estado" { + sys.regs[pk(advKey, "Enabled")] = privacidade.DWORD(1) + } else { + for k, e := range st.b.Entries { + e.Existed = true + st.b.Entries[k] = e + } + } + if _, err := b.Undo(ctx, id); !errors.Is(err, tui.ErrPrivStalePlan) || st.b == nil { + t.Fatalf("err=%v backup=%v", err, st.b) + } + }) + } + sys, st := privZeroStore() // caminho feliz + b := privBackend(t, sys, st, "windows") + if _, err := b.UndoPlan(ctx); err != nil { + t.Fatal(err) + } + if res, err := b.Undo(ctx, b.lastID()); err != nil || !res.Nothing || st.b != nil { + t.Fatalf("res=%+v err=%v backup=%v", res, err, st.b) + } +} + +func TestAnimBackendUndoZeroPendenciasRevalida(t *testing.T) { + ctx := context.Background() + for _, name := range []string{"estado", "backup"} { + t.Run(name, func(t *testing.T) { + sys, st := animZero(t) + b := newAnimBackend(t, sys, st, "windows") + up, err := b.UndoPlan(ctx) + if err != nil || up.Pending != 0 { + t.Fatalf("%+v %v", up, err) + } + if name == "estado" { + sys.set(animStr("5")) + } else { + st.b.Created = st.b.Created.AddDate(0, 0, 1) + } + if _, err := b.Undo(ctx, up.ID); !errors.Is(err, tui.ErrAnimStalePlan) || st.b == nil { + t.Fatalf("err=%v backup=%v", err, st.b) + } + }) + } + sys, st := animZero(t) + b := newAnimBackend(t, sys, st, "windows") + up, _ := b.UndoPlan(ctx) + if res, err := b.Undo(ctx, up.ID); err != nil || !res.Nothing || st.b != nil { + t.Fatalf("res=%+v err=%v backup=%v", res, err, st.b) + } +} diff --git a/internal/msg/msg.go b/internal/msg/msg.go index 0793061..de45176 100644 --- a/internal/msg/msg.go +++ b/internal/msg/msg.go @@ -233,18 +233,19 @@ const ( AnimUndoShort = "Desfaz a redução de animações (restaura do backup)" AnimUndoLong = "Mostra o que será restaurado a partir do backup (tipo e conteúdo originais; apaga só o que não existia) e restaura depois da confirmação. Sem backup, não há o que desfazer." - AnimOnlyWindows = "o comando otimizacao animacoes só existe no Windows (este sistema é %s); nada foi alterado" - AnimNothingToDo = "Nada a fazer: as animações já estão como o plano manda." - AnimConfirmApply = "Aplicar estas mudanças (EXPERIMENTAL)? O valor original de cada item será guardado em backup." - AnimConfirmUndo = "Restaurar estes itens do backup?" - AnimApplied = "Aplicado: %d mudança(s). Backup em %s. Algumas animações só valem depois de reabrir a sessão ou o Explorer. Para desfazer: toolkit otimizacao animacoes desfazer." - AnimAppliedPart = "Aplicadas antes da falha: %d mudança(s). O backup em %s guarda os valores originais; `toolkit otimizacao animacoes desfazer` restaura." - AnimRestored = "Restaurado: %d item(ns). O backup foi removido." - AnimRestoredPart = "Restaurados antes da falha: %d item(ns); o que sobrou continua no backup." - AnimStateChanged = "o estado mudou desde o plano mostrado; nada foi alterado; veja o plano de novo" - AnimNoBackup = "Não há backup de animações: nada a desfazer." - AnimUndoNothing = "O backup existe, mas tudo já está como antes: nada a restaurar (o backup foi removido)." - AnimUndoHeader = "O que será restaurado (valor atual -> original):" + AnimOnlyWindows = "o comando otimizacao animacoes só existe no Windows (este sistema é %s); nada foi alterado" + AnimNothingToDo = "Nada a fazer: as animações já estão como o plano manda." + AnimConfirmApply = "Aplicar estas mudanças (EXPERIMENTAL)? O valor original de cada item será guardado em backup." + AnimConfirmUndo = "Restaurar estes itens do backup?" + AnimConfirmUndoNothing = "Tudo já está como antes. Remover o backup?" + AnimApplied = "Aplicado: %d mudança(s). Backup em %s. Algumas animações só valem depois de reabrir a sessão ou o Explorer. Para desfazer: toolkit otimizacao animacoes desfazer." + AnimAppliedPart = "Aplicadas antes da falha: %d mudança(s). O backup em %s guarda os valores originais; `toolkit otimizacao animacoes desfazer` restaura." + AnimRestored = "Restaurado: %d item(ns). O backup foi removido." + AnimRestoredPart = "Restaurados antes da falha: %d item(ns); o que sobrou continua no backup." + AnimStateChanged = "o estado mudou desde o plano mostrado; nada foi alterado; veja o plano de novo" + AnimNoBackup = "Não há backup de animações: nada a desfazer." + AnimUndoNothing = "O backup existe, mas tudo já está como antes: nada a restaurar (o backup foi removido)." + AnimUndoHeader = "O que será restaurado (valor atual -> original):" ) // Textos do comando privacidade (só Windows). @@ -262,33 +263,34 @@ const ( FlagPrivYes = "não pergunta: aplica direto depois de mostrar o plano" FlagPrivUser = "aplica só os itens do usuário (sem administrador) e ignora os que exigem administrador" - PrivOnlyWindows = "o comando privacidade só existe no Windows (este sistema é %s); nada foi alterado" - PrivStateHeader = "Estado de privacidade do Windows (só leitura, nada foi alterado)" - PrivProfileSep = "=== perfil %s ===" - PrivStateHint = "Para aplicar: toolkit privacidade aplicar --perfil basico|recomendado (use --dry-run para só ver o plano). Para desfazer: toolkit privacidade desfazer." - PrivNeedPerfil = "informe o perfil: --perfil basico ou --perfil recomendado" - PrivBadPerfil = "perfil %q desconhecido: use basico ou recomendado" - PrivNothingToDo = "Nada a fazer: tudo já está como o perfil manda." - PrivDryRunDone = "--dry-run: nada foi alterado." - PrivUserOnlyNote = "--somente-usuario: os itens que exigem administrador foram ignorados (ficam para uma execução num terminal como administrador)." - PrivNeedsAdmin = "este plano tem itens que exigem administrador e este terminal não é administrador: nada foi alterado. Abra o terminal como administrador (botão direito, \"Executar como administrador\") e rode o mesmo comando de novo, ou use --somente-usuario para aplicar só o que é do usuário. O toolkit nunca eleva sozinho" - PrivUndoNeedsAdm = "o backup tem itens que exigem administrador e este terminal não é administrador: nada foi alterado. Abra o terminal como administrador e rode `toolkit privacidade desfazer` de novo" - PrivNeedsYes = "sem terminal para confirmar: nada foi alterado; rode de novo com --yes (depois de conferir o plano com --dry-run)" - PrivConfirmApply = "Aplicar estas mudanças? O valor original de cada item será guardado em backup." - PrivConfirmUndo = "Restaurar estes itens do backup?" - PrivCancelled = "Cancelado: nada foi alterado." - PrivStale = "o estado mudou desde o plano mostrado; nada foi alterado" - PrivApplied = "Aplicado: %d mudança(s). Backup em %s. Para desfazer: toolkit privacidade desfazer." - PrivAppliedPart = "Aplicadas antes da falha: %d mudança(s). O backup em %s guarda os valores originais; `toolkit privacidade desfazer` restaura." - PrivRestored = "Restaurado: %d item(ns). O backup foi removido." - PrivNoBackup = "Não há backup de privacidade: nada a desfazer." - PrivUndoNothing = "O backup existe, mas tudo já está como antes: nada a restaurar (o backup foi removido)." - PrivUndoHeader = "O que será restaurado (valor atual -> original):" - PrivRestoredPart = "Restaurados antes da falha: %d item(ns); o que sobrou continua no backup." - PrivPendingFormat = " ! %s: %s -> %s" - PrivUndoLine = " desfazer: %s" - PrivAdminTag = " [exige administrador]" - PrivMissing = "Não existe nesta versão do Windows (ignorado): %s" + PrivOnlyWindows = "o comando privacidade só existe no Windows (este sistema é %s); nada foi alterado" + PrivStateHeader = "Estado de privacidade do Windows (só leitura, nada foi alterado)" + PrivProfileSep = "=== perfil %s ===" + PrivStateHint = "Para aplicar: toolkit privacidade aplicar --perfil basico|recomendado (use --dry-run para só ver o plano). Para desfazer: toolkit privacidade desfazer." + PrivNeedPerfil = "informe o perfil: --perfil basico ou --perfil recomendado" + PrivBadPerfil = "perfil %q desconhecido: use basico ou recomendado" + PrivNothingToDo = "Nada a fazer: tudo já está como o perfil manda." + PrivDryRunDone = "--dry-run: nada foi alterado." + PrivUserOnlyNote = "--somente-usuario: os itens que exigem administrador foram ignorados (ficam para uma execução num terminal como administrador)." + PrivNeedsAdmin = "este plano tem itens que exigem administrador e este terminal não é administrador: nada foi alterado. Abra o terminal como administrador (botão direito, \"Executar como administrador\") e rode o mesmo comando de novo, ou use --somente-usuario para aplicar só o que é do usuário. O toolkit nunca eleva sozinho" + PrivUndoNeedsAdm = "o backup tem itens que exigem administrador e este terminal não é administrador: nada foi alterado. Abra o terminal como administrador e rode `toolkit privacidade desfazer` de novo" + PrivNeedsYes = "sem terminal para confirmar: nada foi alterado; rode de novo com --yes (depois de conferir o plano com --dry-run)" + PrivConfirmApply = "Aplicar estas mudanças? O valor original de cada item será guardado em backup." + PrivConfirmUndo = "Restaurar estes itens do backup?" + PrivConfirmUndoNothing = "Tudo já está como antes. Remover o backup?" + PrivCancelled = "Cancelado: nada foi alterado." + PrivStale = "o estado mudou desde o plano mostrado; nada foi alterado" + PrivApplied = "Aplicado: %d mudança(s). Backup em %s. Para desfazer: toolkit privacidade desfazer." + PrivAppliedPart = "Aplicadas antes da falha: %d mudança(s). O backup em %s guarda os valores originais; `toolkit privacidade desfazer` restaura." + PrivRestored = "Restaurado: %d item(ns). O backup foi removido." + PrivNoBackup = "Não há backup de privacidade: nada a desfazer." + PrivUndoNothing = "O backup existe, mas tudo já está como antes: nada a restaurar (o backup foi removido)." + PrivUndoHeader = "O que será restaurado (valor atual -> original):" + PrivRestoredPart = "Restaurados antes da falha: %d item(ns); o que sobrou continua no backup." + PrivPendingFormat = " ! %s: %s -> %s" + PrivUndoLine = " desfazer: %s" + PrivAdminTag = " [exige administrador]" + PrivMissing = "Não existe nesta versão do Windows (ignorado): %s" ) // Textos do comando apps-nativos (só Windows). From fad13da18c26024de3dab8737c9f0b306eb642f2 Mon Sep 17 00:00:00 2001 From: Paulo Victor T Silva Date: Sat, 14 Nov 2026 16:14:42 -0300 Subject: [PATCH 2/3] =?UTF-8?q?fix(cli):=20desfazer=20sem=20pend=C3=AAncia?= =?UTF-8?q?s=20s=C3=B3=20anuncia=20'backup=20removido'=20depois=20de=20Rem?= =?UTF-8?q?ove()=20retornar=20nil;=20texto=20pr=C3=A9vio=20neutro?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/otimizacao.md | 4 ++ docs/privacidade.md | 4 ++ internal/cli/otimizacao_animacoes.go | 1 + internal/cli/privacidade.go | 1 + internal/cli/privacidade_test.go | 13 ++++-- internal/cli/toctou_yes_test.go | 67 ++++++++++++++++++++++++++++ internal/msg/msg.go | 6 ++- 7 files changed, 91 insertions(+), 5 deletions(-) diff --git a/docs/otimizacao.md b/docs/otimizacao.md index 24df09e..623550a 100644 --- a/docs/otimizacao.md +++ b/docs/otimizacao.md @@ -172,3 +172,7 @@ confirmação são recusadas: nunca há plano armado fora da tela (só `c` e `m` ou o Explorer? A reversão devolve o mesmo estado visual? - A pasta do backup quando o usuário que eleva é outro (SID e `%LOCALAPPDATA%` diferentes): coberto pelo dono gravado no arquivo, mas não testado numa máquina real. + +## Acompanhamento: janela entre a revalidação e a remoção do backup + +No desfazer com zero pendências o CLI pergunta "Tudo já está como antes. Remover o backup? [s/N]", relê o backup e o estado depois da confirmação e só então remove; a frase "O backup foi removido." só sai DEPOIS de `Remove()` retornar sem erro (cancelar, sem terminal, estado ou backup alterado e erro de `Remove()` deixam o backup e não anunciam remoção). Resta uma janela mínima entre a revalidação e o `Remove()`: o `Store` não tem remoção condicional nem trava compartilhada com `Save`, então o arquivo removido pode não ser exatamente a versão revalidada se outro processo gravar nesse intervalo. Acompanhamento: uma trava compartilhada Save/Remove (ou remoção condicional por conteúdo/versão) no `Store`. diff --git a/docs/privacidade.md b/docs/privacidade.md index b72ce2c..0771ec2 100644 --- a/docs/privacidade.md +++ b/docs/privacidade.md @@ -60,3 +60,7 @@ O formato do backup nasce na v0.4.0-rc.1 (nunca houve outro publicado): não há Os botões são `Aplicar` (perfil) e `Restaurar` (desfazer; `Remover backup` quando já está tudo como antes). O plano exibido é o mesmo que o backend devolveu (uso único, por ID); a confirmação só aplica esse plano. **Faixa de resultado** (`internal/tui/result.go`, PR2 do redesign): depois de aplicar ou restaurar, o resultado aparece NA PRÓPRIA aba, logo abaixo do cabeçalho, e fica até a pessoa teclar `x` (não some por tempo nem ao trocar de aba). Traz símbolo e palavra (`✓ feito`, `! parcial`, `✗ falhou`, `i info`), o que foi feito, quantas mudanças, onde está o backup e COMO DESFAZER (`Para desfazer: tecle d nesta aba`). Falha no meio vira `! parcial` (quantas mudanças ficaram, o erro, o backup e o `d`); recusa (precisa de administrador, plano mudou) diz que NADA foi alterado. A linha de estado fica só com um resumo curto. A aba implementa `Resulter` (`Result()`/`Dismiss()`). + +## Acompanhamento: janela entre a revalidação e a remoção do backup + +No desfazer com zero pendências o CLI pergunta "Tudo já está como antes. Remover o backup? [s/N]", relê o backup e o estado depois da confirmação e só então remove; a frase "O backup foi removido." só sai DEPOIS de `Remove()` retornar sem erro (cancelar, sem terminal, estado ou backup alterado e erro de `Remove()` deixam o backup e não anunciam remoção). Resta uma janela mínima entre a revalidação e o `Remove()`: o `Store` não tem remoção condicional nem trava compartilhada com `Save`, então o arquivo removido pode não ser exatamente a versão revalidada se outro processo gravar nesse intervalo. Acompanhamento: uma trava compartilhada Save/Remove (ou remoção condicional por conteúdo/versão) no `Store`. diff --git a/internal/cli/otimizacao_animacoes.go b/internal/cli/otimizacao_animacoes.go index 04348d2..47506f5 100644 --- a/internal/cli/otimizacao_animacoes.go +++ b/internal/cli/otimizacao_animacoes.go @@ -174,6 +174,7 @@ func runAnimUndo(ctx context.Context, out io.Writer, deps Deps, f animFlags) err if err := e.store.Remove(); err != nil { return cleanErr(err) } + _, _ = fmt.Fprintln(out, msg.AnimBackupRemoved) // só DEPOIS de Remove() retornar nil return nil } res, err := animacoes.ApplyUndo(ctx, e.sys, e.store, fresh, freshBk) diff --git a/internal/cli/privacidade.go b/internal/cli/privacidade.go index 45819b3..c9f18a1 100644 --- a/internal/cli/privacidade.go +++ b/internal/cli/privacidade.go @@ -269,6 +269,7 @@ func runPrivUndo(ctx context.Context, out io.Writer, deps Deps, f privFlags) err if err := e.store.Remove(); err != nil { return cleanErr(err) } + _, _ = fmt.Fprintln(out, msg.PrivBackupRemoved) // só DEPOIS de Remove() retornar nil return nil } plan, bk = fresh, freshBk diff --git a/internal/cli/privacidade_test.go b/internal/cli/privacidade_test.go index 28b6c75..bcabd87 100644 --- a/internal/cli/privacidade_test.go +++ b/internal/cli/privacidade_test.go @@ -111,7 +111,8 @@ func (s *privSys) TaskSetEnabled(_ context.Context, p string, e bool) error { } type privStore struct { - b *privacidade.Backup + removeErr error // faz o Remove() falhar (backup preservado) + b *privacidade.Backup // afterLoad (opcional) roda DEPOIS de cada Load, com o número da chamada: simula o backup mudando entre leituras. loads int afterLoad func(call int) @@ -133,8 +134,14 @@ func (m *privStore) Load() (*privacidade.Backup, error) { return &cp, nil } func (m *privStore) Save(b *privacidade.Backup) error { m.b = b; return nil } -func (m *privStore) Remove() error { m.b = nil; return nil } -func (m *privStore) Path() string { return `C:\ProgramData\toolkit\privacidade-backup.json` } +func (m *privStore) Remove() error { + if m.removeErr != nil { + return m.removeErr + } + m.b = nil + return nil +} +func (m *privStore) Path() string { return `C:\ProgramData\toolkit\privacidade-backup.json` } func privDeps(t *testing.T, sys *privSys, st *privStore, goos string, tty bool, input string) Deps { t.Helper() diff --git a/internal/cli/toctou_yes_test.go b/internal/cli/toctou_yes_test.go index 71b2a31..c6388b9 100644 --- a/internal/cli/toctou_yes_test.go +++ b/internal/cli/toctou_yes_test.go @@ -311,3 +311,70 @@ func TestAnimBackendUndoZeroPendenciasRevalida(t *testing.T) { t.Fatalf("res=%+v err=%v backup=%v", res, err, st.b) } } + +// Lupa #88: a saída NUNCA diz que o backup foi removido antes de Remove() retornar nil: cancelar, sem terminal, estado ou +// backup alterado e erro de Remove() deixam o backup e a saída não afirma que apagou; no sucesso a frase vem DEPOIS da pergunta. +func TestDesfazerZeroPendenciasSoAnunciaRemocaoDepoisDeRemover(t *testing.T) { + type cli struct { + name string + run func(t *testing.T, tty bool, input string, hook func(), removeErr error, args ...string) (out string, err error, backup func() bool) + } + privRun := func(t *testing.T, tty bool, input string, hook func(), removeErr error, args ...string) (string, error, func() bool) { + sys, st := privZeroStore() + st.removeErr = removeErr + if hook != nil { + sys.onEdition = func(call int) { + if call == 2 { // na releitura DEPOIS da confirmação + sys.regs[pk(advKey, "Enabled")] = privacidade.DWORD(1) + } + } + } + out, err := runPriv(t, privDeps(t, sys, st, "windows", tty, input), append([]string{"desfazer"}, args...)...) + return out, err, func() bool { return st.b != nil } + } + animRun := func(t *testing.T, tty bool, input string, hook func(), removeErr error, args ...string) (string, error, func() bool) { + sys, st := animZero(t) + st.removeErr = removeErr + if hook != nil { + sys.afterRead = func() { sys.set(animStr("5")) } + } + out, err := runAnim(t, animDeps(t, sys, st, "windows", tty, input), append([]string{"animacoes", "desfazer"}, args...)...) + return out, err, func() bool { return st.b != nil } + } + for _, c := range []cli{{"privacidade", privRun}, {"animacoes", animRun}} { + fail := map[string]struct { + tty bool + input string + hook func() + removeErr error + args []string + }{ + "cancelar (n)": {tty: true, input: "n\n"}, + "sem terminal": {tty: false}, + "estado alterado": {tty: true, input: "s\n", hook: func() {}}, + "Remove() com erro": {tty: true, input: "s\n", removeErr: errors.New("disco cheio")}, + "--yes + Remove erro": {tty: false, removeErr: errors.New("disco cheio"), args: []string{"--yes"}}, + } + for name, f := range fail { + t.Run(c.name+"/"+name, func(t *testing.T) { + out, _, hasBackup := c.run(t, f.tty, f.input, f.hook, f.removeErr, f.args...) + if !hasBackup() { + t.Fatal("o backup tem de ficar") + } + if strings.Contains(strings.ToLower(out), "foi removido") { + t.Errorf("a saída afirma que o backup foi removido sem ter sido:\n%s", out) + } + }) + } + t.Run(c.name+"/sucesso anuncia só depois", func(t *testing.T) { + out, err, hasBackup := c.run(t, true, "s\n", nil, nil) + if err != nil || hasBackup() { + t.Fatalf("err=%v backup=%v\n%s", err, hasBackup(), out) + } + iq, ir := strings.Index(out, "Remover o backup?"), strings.Index(out, "O backup foi removido") + if iq < 0 || ir < 0 || ir < iq { + t.Errorf("'O backup foi removido' deve vir DEPOIS da pergunta (pergunta=%d, aviso=%d):\n%s", iq, ir, out) + } + }) + } +} diff --git a/internal/msg/msg.go b/internal/msg/msg.go index de45176..826965e 100644 --- a/internal/msg/msg.go +++ b/internal/msg/msg.go @@ -244,7 +244,8 @@ const ( AnimRestoredPart = "Restaurados antes da falha: %d item(ns); o que sobrou continua no backup." AnimStateChanged = "o estado mudou desde o plano mostrado; nada foi alterado; veja o plano de novo" AnimNoBackup = "Não há backup de animações: nada a desfazer." - AnimUndoNothing = "O backup existe, mas tudo já está como antes: nada a restaurar (o backup foi removido)." + AnimUndoNothing = "O backup existe, mas tudo já está como antes: nada a restaurar." + AnimBackupRemoved = "O backup foi removido." AnimUndoHeader = "O que será restaurado (valor atual -> original):" ) @@ -284,7 +285,8 @@ const ( PrivAppliedPart = "Aplicadas antes da falha: %d mudança(s). O backup em %s guarda os valores originais; `toolkit privacidade desfazer` restaura." PrivRestored = "Restaurado: %d item(ns). O backup foi removido." PrivNoBackup = "Não há backup de privacidade: nada a desfazer." - PrivUndoNothing = "O backup existe, mas tudo já está como antes: nada a restaurar (o backup foi removido)." + PrivUndoNothing = "O backup existe, mas tudo já está como antes: nada a restaurar." + PrivBackupRemoved = "O backup foi removido." PrivUndoHeader = "O que será restaurado (valor atual -> original):" PrivRestoredPart = "Restaurados antes da falha: %d item(ns); o que sobrou continua no backup." PrivPendingFormat = " ! %s: %s -> %s" From f2ab26b4457df1a77d9bdc8e9f7f5506d6c5409b Mon Sep 17 00:00:00 2001 From: Paulo Victor T Silva Date: Sat, 14 Nov 2026 16:16:22 -0300 Subject: [PATCH 3/3] =?UTF-8?q?test(cli):=20erro=20como=20=C3=BAltimo=20re?= =?UTF-8?q?torno=20(ST1008)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/cli/toctou_yes_test.go | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/internal/cli/toctou_yes_test.go b/internal/cli/toctou_yes_test.go index c6388b9..af90c3c 100644 --- a/internal/cli/toctou_yes_test.go +++ b/internal/cli/toctou_yes_test.go @@ -317,9 +317,9 @@ func TestAnimBackendUndoZeroPendenciasRevalida(t *testing.T) { func TestDesfazerZeroPendenciasSoAnunciaRemocaoDepoisDeRemover(t *testing.T) { type cli struct { name string - run func(t *testing.T, tty bool, input string, hook func(), removeErr error, args ...string) (out string, err error, backup func() bool) + run func(t *testing.T, tty bool, input string, hook func(), removeErr error, args ...string) (out string, backup func() bool, err error) } - privRun := func(t *testing.T, tty bool, input string, hook func(), removeErr error, args ...string) (string, error, func() bool) { + privRun := func(t *testing.T, tty bool, input string, hook func(), removeErr error, args ...string) (string, func() bool, error) { sys, st := privZeroStore() st.removeErr = removeErr if hook != nil { @@ -330,16 +330,16 @@ func TestDesfazerZeroPendenciasSoAnunciaRemocaoDepoisDeRemover(t *testing.T) { } } out, err := runPriv(t, privDeps(t, sys, st, "windows", tty, input), append([]string{"desfazer"}, args...)...) - return out, err, func() bool { return st.b != nil } + return out, func() bool { return st.b != nil }, err } - animRun := func(t *testing.T, tty bool, input string, hook func(), removeErr error, args ...string) (string, error, func() bool) { + animRun := func(t *testing.T, tty bool, input string, hook func(), removeErr error, args ...string) (string, func() bool, error) { sys, st := animZero(t) st.removeErr = removeErr if hook != nil { sys.afterRead = func() { sys.set(animStr("5")) } } out, err := runAnim(t, animDeps(t, sys, st, "windows", tty, input), append([]string{"animacoes", "desfazer"}, args...)...) - return out, err, func() bool { return st.b != nil } + return out, func() bool { return st.b != nil }, err } for _, c := range []cli{{"privacidade", privRun}, {"animacoes", animRun}} { fail := map[string]struct { @@ -357,7 +357,7 @@ func TestDesfazerZeroPendenciasSoAnunciaRemocaoDepoisDeRemover(t *testing.T) { } for name, f := range fail { t.Run(c.name+"/"+name, func(t *testing.T) { - out, _, hasBackup := c.run(t, f.tty, f.input, f.hook, f.removeErr, f.args...) + out, hasBackup, _ := c.run(t, f.tty, f.input, f.hook, f.removeErr, f.args...) if !hasBackup() { t.Fatal("o backup tem de ficar") } @@ -367,7 +367,7 @@ func TestDesfazerZeroPendenciasSoAnunciaRemocaoDepoisDeRemover(t *testing.T) { }) } t.Run(c.name+"/sucesso anuncia só depois", func(t *testing.T) { - out, err, hasBackup := c.run(t, true, "s\n", nil, nil) + out, hasBackup, err := c.run(t, true, "s\n", nil, nil) if err != nil || hasBackup() { t.Fatalf("err=%v backup=%v\n%s", err, hasBackup(), out) }