package main import ( "bytes" "encoding/json" "fmt" "os" "os/exec" "path/filepath" "reflect" "strings" "testing" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/activity" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" ) func writeOperationsConfig(t *testing.T, extra string) { t.Helper() prepareTransferTest(t) data := `hosts: - name: router address: 192.0.2.1 tags: [router] - name: fail address: 192.0.2.2 - name: okay address: 192.0.2.3 resolver: strategies: [primary_ip] ` + extra if err := os.WriteFile(config.Path(), []byte(data), 0600); err != nil { t.Fatal(err) } } func TestPostHooksFiltersAndConfirmation(t *testing.T) { dir := t.TempDir() marker := filepath.Join(dir, "post") writeOperationsConfig(t, fmt.Sprintf(` commands: success: args: [sh, -c, "exit 0", "{host}"] post_run: 'printf "%%s:%%s" "$NETSSH_HOST" "$NETSSH_EXIT_CODE" > %s' failure: args: [sh, -c, "exit 7", "{host}"] post_run: 'printf "%%s" "$NETSSH_EXIT_CODE" > %s; exit 9' postfail: args: [sh, -c, "exit 0", "{host}"] post_run: exit 9 protected: args: [sh, -c, "exit 0", "{host}"] confirm: true match: {tag: router, kind: static, name: "rou*"} timeout: args: [sh, -c, "sleep 20", "{host}"] timeout: 50ms activity: enabled: true retention_days: 30 max_entries: 50 `, marker, marker)) if out, err := runNetssh(t, "run", "--dry-run", "success", "router"); err != nil { t.Fatalf("%s %v", out, err) } if _, err := os.Stat(marker); !os.IsNotExist(err) { t.Fatal("dry-run executed post hook") } if out, err := runNetssh(t, "run", "success", "router"); err != nil { t.Fatalf("%s %v", out, err) } data, _ := os.ReadFile(marker) if string(data) != "router:0" { t.Fatal(string(data)) } for _, tc := range []struct { name string code int }{{"failure", 7}, {"postfail", 9}, {"timeout", 124}} { _, err := runNetssh(t, "run", tc.name, "router") exit, ok := err.(*exec.ExitError) if !ok || exit.ExitCode() != tc.code { t.Fatalf("%s: %v", tc.name, err) } } data, _ = os.ReadFile(marker) if string(data) != "7" { t.Fatal(string(data)) } if out, err := runNetssh(t, "run", "protected", "router"); err == nil || !strings.Contains(out, "--yes") { t.Fatalf("%q %v", out, err) } if out, err := runNetssh(t, "run", "--yes", "protected", "router"); err != nil { t.Fatalf("%q %v", out, err) } if out, err := runNetssh(t, "run", "--yes", "protected", "okay"); err == nil || !strings.Contains(out, "not allowed") { t.Fatalf("%q %v", out, err) } state, err := activity.Read() if err != nil || len(state.Records) != 5 { t.Fatalf("%+v %v", state, err) } } func TestSSHPostDisconnect(t *testing.T) { dir := t.TempDir() marker := filepath.Join(dir, "after") writeOperationsConfig(t, fmt.Sprintf("ssh:\n post_disconnect: 'printf \"%%s\" \"$NETSSH_EXIT_CODE\" > %s'\n", marker)) if err := os.WriteFile(filepath.Join(dir, "ssh"), []byte("#!/bin/sh\nexit 6\n"), 0700); err != nil { t.Fatal(err) } t.Setenv("PATH", dir+string(os.PathListSeparator)+os.Getenv("PATH")) _, err := runNetssh(t, "router") exit, ok := err.(*exec.ExitError) if !ok || exit.ExitCode() != 6 { t.Fatal(err) } data, _ := os.ReadFile(marker) if string(data) != "6" { t.Fatalf("post: %s", data) } } func TestExplainAndFavorites(t *testing.T) { writeOperationsConfig(t, "tui:\n history_limit: 25\nssh:\n rules:\n - match: {tag: router}\n post_disconnect: echo done\n") out, err := runNetssh(t, "explain", "router") if err != nil { t.Fatalf("%s %v", out, err) } var result map[string]any if err := json.Unmarshal([]byte(out), &result); err != nil { t.Fatal(err) } if result["source"] != "static" || result["address"] != "192.0.2.1" { t.Fatal(result) } for _, args := range [][]string{{"favorites", "pin", "router"}, {"favorites", "add", "okay"}} { if out, err := runNetssh(t, args...); err != nil { t.Fatalf("%s %v", out, err) } } state, err := activity.Read() if err != nil || !state.Pinned["router"] || !state.Favorites["okay"] { t.Fatalf("%+v %v", state, err) } if out, err := runNetssh(t, "favorites", "remove", "router"); err != nil { t.Fatalf("%s %v", out, err) } state, _ = activity.Read() if state.Pinned["router"] || state.Favorites["router"] { t.Fatal(state) } } func TestPortableConfigOmitsAllExecutableSecrets(t *testing.T) { c := config.Config{ NetBoxes: []config.NetBoxConfig{{Name: "prod", URL: "https://user:URLSECRET@netbox.example", Token: "TOKEN", SSH: config.SSHOptions{PreConnect: "HOOKSECRET"}}}, SSH: config.SSHConfig{SSHOptions: config.SSHOptions{Options: map[string]string{"ProxyCommand": "OPTIONSECRET"}, PostDisconnect: "POSTSECRET"}}, Commands: map[string]config.HostCommand{"check": {Args: []string{"echo", "COMMANDSECRET", "{host}"}}}, Hosts: []config.StaticHost{{Name: "router", Address: "192.0.2.1", SSH: config.SSHOptions{PreConnect: "STATICSECRET"}}}, TUI: config.TUIConfig{HistoryLimit: 25}, } data, err := json.Marshal(portableConfig(c)) if err != nil { t.Fatal(err) } for _, secret := range []string{"URLSECRET", "TOKEN", "HOOKSECRET", "OPTIONSECRET", "POSTSECRET", "COMMANDSECRET", "STATICSECRET"} { if bytes.Contains(data, []byte(secret)) { t.Fatalf("export leaked %s", secret) } } parsed, err := decodePortable(data) if err != nil { t.Fatal(err) } if parsed.TUI.HistoryLimit != 25 || len(parsed.NetBoxes) != 1 || parsed.NetBoxes[0].URL != "https://netbox.example" { t.Fatalf("%+v", parsed) } hostile := []byte("netbox:\n url: https://netbox.example\n token: bad\nssh:\n pre_connect: touch /tmp/never\ncommands:\n check:\n args: [sh, -c, evil]\n") parsed, err = decodePortable(hostile) if err != nil || parsed.NetBox.Token != "" || parsed.SSH.PreConnect != "" || len(parsed.Commands) != 0 { t.Fatalf("%+v %v", parsed, err) } } func TestBatchRetryFailedOnly(t *testing.T) { bin := filepath.Join(t.TempDir(), "netssh") build := exec.Command("go", "build", "-o", bin, ".") if out, err := build.CombinedOutput(); err != nil { t.Fatalf("build: %s %v", out, err) } old := batchExecutable batchExecutable = func() (string, error) { return bin, nil } t.Cleanup(func() { batchExecutable = old }) dir := t.TempDir() script := filepath.Join(dir, "check.sh") ready := filepath.Join(dir, "ready") if err := os.WriteFile(script, []byte(fmt.Sprintf("#!/bin/sh\nif [ \"$1\" = fail ] && [ ! -f %q ]; then exit 3; fi\nprintf 'ran %%s\\n' \"$1\"\n", ready)), 0700); err != nil { t.Fatal(err) } writeOperationsConfig(t, fmt.Sprintf("commands:\n check:\n args: [%q, \"{host}\"]\n", script)) run := func(args ...string) (string, error) { cmd := batchCmd() cmd.SetArgs(args) var out bytes.Buffer cmd.SetOut(&out) cmd.SetErr(&out) err := cmd.Execute() return out.String(), err } out, err := run("--parallel", "2", "check", "router", "fail", "okay") if err == nil || !strings.Contains(out, "2 succeeded, 1 failed") { t.Fatalf("%s %v", out, err) } data, _ := os.ReadFile(batchPath()) var retry batchRetry if err := json.Unmarshal(data, &retry); err != nil { t.Fatal(err) } if !reflect.DeepEqual(retry.Hosts, []string{"fail"}) { t.Fatalf("%+v", retry) } if err := os.WriteFile(ready, nil, 0600); err != nil { t.Fatal(err) } out, err = run("--retry-failed") if err != nil || !strings.Contains(out, "1 succeeded, 0 failed") || strings.Contains(out, "ran router") { t.Fatalf("%s %v", out, err) } } func TestImportPreservesOnlyMatchingCredentials(t *testing.T) { writeOperationsConfig(t, "") original := []byte("netboxes:\n - name: prod\n url: https://prod.example\n token: LOCALPROD\n - name: lab\n url: https://lab.example\n token: LOCALLAB\ncommands:\n local:\n args: [echo, \"{host}\"]\n") if err := os.WriteFile(config.Path(), original, 0600); err != nil { t.Fatal(err) } shared := filepath.Join(t.TempDir(), "shared.yaml") if err := os.WriteFile(shared, []byte("netboxes:\n - name: prod\n url: https://prod.example\n token: UNTRUSTED\n - name: lab\n url: https://other.example\ntui:\n history_limit: 25\nssh:\n pre_connect: evil\n"), 0600); err != nil { t.Fatal(err) } if out, err := runNetssh(t, "config", "import", shared, "--dry-run"); err != nil { t.Fatalf("%s %v", out, err) } after, _ := os.ReadFile(config.Path()) if !bytes.Equal(original, after) { t.Fatal("preview changed config") } if out, err := runNetssh(t, "config", "import", shared, "--yes"); err != nil { t.Fatalf("%s %v", out, err) } cfg, err := config.Load() if err != nil { t.Fatal(err) } if cfg.NetBoxes[0].Token != "LOCALPROD" || cfg.NetBoxes[1].Token != "" || cfg.SSH.PreConnect != "" || len(cfg.Commands) != 1 || cfg.TUI.HistoryLimit != 25 { t.Fatalf("incorrect imported settings: names=%d tui=%d", len(cfg.NetBoxes), cfg.TUI.HistoryLimit) } backup, _ := os.ReadFile(config.Path() + ".before-import") if !bytes.Equal(backup, original) { t.Fatal("backup differs") } }