259 lines
8.8 KiB
Go
259 lines
8.8 KiB
Go
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")
|
|
}
|
|
}
|