package main import ( "bytes" "context" "errors" "fmt" "net" "net/http" "net/http/httptest" "os" "path/filepath" "strings" "testing" "time" "go.yaml.in/yaml/v3" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/cache" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/resolver" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/secret" internalssh "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/ssh" ) // insightEnv writes a config and a cache with two NetBox hosts and a static host. func insightEnv(t *testing.T, yamlConfig string) string { t.Helper() configDir := t.TempDir() t.Setenv("HOME", t.TempDir()) t.Setenv("XDG_CONFIG_HOME", configDir) t.Setenv("XDG_CACHE_HOME", t.TempDir()) path := filepath.Join(t.TempDir(), "hosts.json") t.Setenv("NETSSH_CACHE_PATH", path) t.Setenv("NETSSH_SHELL_ALIAS", "") if err := os.WriteFile(filepath.Join(configDir, "netssh.yaml"), []byte(yamlConfig), 0o600); err != nil { t.Fatal(err) } cfg, err := config.Load() if err != nil { t.Fatal(err) } c := cache.New(cfg.CachePath(), 3600) c.Upsert(cache.Entry{Name: "prod/web01", IP: "10.0.0.1", Kind: "vm", Tags: []string{"prod", "Web Server"}, ID: 11, Status: "active", Site: &config.Ref{Name: "FSN 1", Slug: "fsn1"}, Role: &config.Ref{Name: "Web", Slug: "web"}, Platform: &config.Ref{Name: "Ubuntu 24.04", Slug: "ubuntu-24-04"}}) c.Upsert(cache.Entry{Name: "lab/web01", IP: "10.9.0.1", Kind: "vm", ID: 12, Status: "planned"}) c.Upsert(cache.Entry{Name: "prod/sw1", IP: "10.0.0.2", Kind: "device", ID: 13, Status: "active", Platform: &config.Ref{Name: "Junos", Slug: "junos"}, Location: []config.Ref{{Name: "Building A", Slug: "building-a"}, {Name: "Room 2.04", Slug: "room-2-04"}}, Rack: "R12", Position: "20"}) if err := c.Save(); err != nil { t.Fatal(err) } return path } const insightConfig = `netboxes: - name: prod url: https://nb.example token: t - name: lab url: https://lab.example token: t ssh: default_user: admin rules: - match: {platform: junos} proxy_jump: jump.example options: {KexAlgorithms: +diffie-hellman-group14-sha1} hosts: - name: router address: 192.168.1.1 port: 2222 tags: [home] ` func TestExportAnsibleYAML(t *testing.T) { insightEnv(t, insightConfig) cfg, err := config.Load() if err != nil { t.Fatal(err) } keys, _ := parseGroupBy("tag,site,platform,status") hosts, err := exportHosts(cfg, exportFilter{}) if err != nil { t.Fatal(err) } data, err := buildInventory(hosts, keys, true).yaml() if err != nil { t.Fatal(err) } var inv struct { All struct { Hosts map[string]map[string]any `yaml:"hosts"` Children map[string]struct { Hosts map[string]any `yaml:"hosts"` } `yaml:"children"` } `yaml:"all"` } if err := yaml.Unmarshal(data, &inv); err != nil { t.Fatalf("invalid YAML: %v\n%s", err, data) } web := inv.All.Hosts["prod-web01"] if web["ansible_host"] != "10.0.0.1" || web["ansible_user"] != "admin" || web["netbox_site"] != "FSN 1" || web["netbox_id"] != 11 { t.Fatalf("prod-web01 vars wrong: %+v\n%s", web, data) } if tags, _ := web["netbox_tags"].([]any); len(tags) != 2 { t.Fatalf("tags should stay a list: %#v", web["netbox_tags"]) } if _, ok := inv.All.Hosts["lab-web01"]; !ok { t.Fatalf("duplicate hostnames must be qualified: %v", inv.All.Hosts) } sw := inv.All.Hosts["sw1"] if sw["ansible_ssh_common_args"] != "-o ProxyJump=jump.example" { t.Fatalf("jump host missing for platform rule: %+v", sw) } router := inv.All.Hosts["router"] if router["ansible_port"] != 2222 || router["ansible_host"] != "192.168.1.1" { t.Fatalf("static host wrong: %+v", router) } for _, group := range []string{"tag_prod", "tag_web_server", "site_fsn1", "platform_junos", "status_planned", "tag_home"} { if _, ok := inv.All.Children[group]; !ok { t.Errorf("group %s missing in\n%s", group, data) } } if _, ok := inv.All.Children["platform_junos"].Hosts["sw1"]; !ok { t.Fatal("sw1 not in platform_junos") } } func TestExportAnsibleINI(t *testing.T) { insightEnv(t, insightConfig) cfg, _ := config.Load() hosts, err := exportHosts(cfg, exportFilter{instance: "prod"}) if err != nil { t.Fatal(err) } keys, _ := parseGroupBy("tag,role") out := string(buildInventory(hosts, keys, true).ini()) for _, want := range []string{ "[all]\nsw1 ansible_host=10.0.0.2 ansible_user=admin ansible_ssh_common_args=\"-o ProxyJump=jump.example\"", `web01 ansible_host=10.0.0.1`, `netbox_site="FSN 1"`, `netbox_tags="prod,Web Server"`, "\n[role_web]\nweb01\n", "\n[tag_prod]\nweb01\n", } { if !strings.Contains(out, want) { t.Errorf("missing %q in\n%s", want, out) } } if strings.Contains(out, "lab") || strings.Contains(out, "router") { t.Fatalf("--instance prod not applied:\n%s", out) } } func TestExportFiltersAndGroupByValidation(t *testing.T) { insightEnv(t, insightConfig) cfg, _ := config.Load() hosts, err := exportHosts(cfg, exportFilter{status: "active", noStatic: true}) if err != nil { t.Fatal(err) } if len(hosts) != 2 { t.Fatalf("status filter: %+v", hosts) } if _, err := parseGroupBy("site,color"); err == nil { t.Fatal("unknown group-by accepted") } if keys, err := parseGroupBy("none"); err != nil || keys != nil { t.Fatal("none should disable groups") } if _, err := exportHosts(cfg, exportFilter{tag: "missing"}); err == nil { t.Fatal("empty export should fail") } } func TestExportSSHConfig(t *testing.T) { insightEnv(t, insightConfig) cfg, _ := config.Load() hosts, err := exportHosts(cfg, exportFilter{}) if err != nil { t.Fatal(err) } var b bytes.Buffer writeSSHConfig(&b, hosts, map[string]string{"prod/sw1": "sw"}) out := b.String() for _, want := range []string{ "\nHost sw1 sw\n HostName 10.0.0.2\n User admin\n ProxyJump jump.example\n kexalgorithms +diffie-hellman-group14-sha1\n", "\nHost router\n HostName 192.168.1.1\n User admin\n Port 2222\n", "\nHost prod-web01\n HostName 10.0.0.1\n", } { if !strings.Contains(out, want) { t.Errorf("missing %q in\n%s", want, out) } } } func TestCopyIDArgv(t *testing.T) { insightEnv(t, insightConfig) cfg, _ := config.Load() h, err := resolveTargetE(cfg, "prod/sw1", false) if err != nil { t.Fatal(err) } argv, err := copyIDArgv(cfg, h, copyIDFlags{identity: "/k.pub"}) if err != nil { t.Fatal(err) } got := internalssh.Quote(argv) for _, want := range []string{"ssh-copy-id -i /k.pub", "-o ProxyJump=jump.example", "-o kexalgorithms=+diffie-hellman-group14-sha1", "admin@10.0.0.2"} { if !strings.Contains(got, want) { t.Errorf("missing %q in %s", want, got) } } if strings.Contains(got, " -J ") { t.Fatalf("ssh-copy-id has no -J: %s", got) } router, _ := resolveTargetE(cfg, "router", false) argv, _ = copyIDArgv(cfg, router, copyIDFlags{user: "root", noJump: true, check: true}) if got := internalssh.Quote(argv); !strings.Contains(got, "-n") || !strings.Contains(got, "-p 2222") || !strings.HasSuffix(got, "root@192.168.1.1") { t.Fatalf("static host argv wrong: %s", got) } } func TestRunCopyIDContinuesAfterFailure(t *testing.T) { insightEnv(t, insightConfig) cfg, _ := config.Load() var ran []string old := runCopyIDCommand runCopyIDCommand = func(argv []string) error { ran = append(ran, argv[len(argv)-1]) if strings.Contains(argv[len(argv)-1], "10.0.0.2") { return errors.New("permission denied") } return nil } t.Cleanup(func() { runCopyIDCommand = old }) stubTerminal(t, false) err := runCopyID(cfg, []string{"prod/sw1", "router"}, copyIDFlags{}) if err == nil || !strings.Contains(err.Error(), "1 of 2 hosts") || len(ran) != 2 { t.Fatalf("err %v, ran %v", err, ran) } } func stubTerminal(t *testing.T, tty bool) { t.Helper() old := stdinIsTerminal stdinIsTerminal = func() bool { return tty } t.Cleanup(func() { stdinIsTerminal = old }) } func TestConfirmStatusWarnsWithoutTerminal(t *testing.T) { stubTerminal(t, false) cfg := &config.Config{} if err := confirmStatus(cfg, resolvedHost{Name: "web", Status: "offline"}, false); err != nil { t.Fatalf("non-interactive status check must not fail: %v", err) } if err := confirmStatus(cfg, resolvedHost{Name: "web", Status: "active"}, false); err != nil { t.Fatal(err) } } func TestKnownHostsKeysAndFile(t *testing.T) { keys := knownHostsKeys("prod/web01", []string{"10.0.0.1", "10.0.0.1", "10.0.0.9"}, 2222) want := []string{"web01", "[web01]:2222", "10.0.0.1", "[10.0.0.1]:2222", "10.0.0.9", "[10.0.0.9]:2222"} if strings.Join(keys, " ") != strings.Join(want, " ") { t.Fatalf("got %v", keys) } if keys := knownHostsKeys("web", []string{"10.0.0.1"}, 22); strings.Join(keys, " ") != "web 10.0.0.1" { t.Fatalf("got %v", keys) } t.Setenv("HOME", "/home/u") if f := knownHostsFile(config.SSHOptions{Options: map[string]string{"userknownhostsfile": "~/.ssh/lab_hosts ~/.ssh/other"}}); f != "/home/u/.ssh/lab_hosts" { t.Fatalf("file %q", f) } if f := knownHostsFile(config.SSHOptions{Options: map[string]string{"userknownhostsfile": "/dev/null"}}); f != "" { t.Fatalf("file %q", f) } } func TestKnownHostsResetRemovesNameAndAddresses(t *testing.T) { insightEnv(t, insightConfig) var removed []string old := removeKnownHosts removeKnownHosts = func(keys []string, file string) error { removed = append(removed, keys...); return nil } t.Cleanup(func() { removeKnownHosts = old }) cmd := rootCmd() cmd.SetArgs([]string{"known-hosts", "reset", "--yes", "router"}) if err := cmd.Execute(); err != nil { t.Fatal(err) } if strings.Join(removed, " ") != "router [router]:2222 192.168.1.1 [192.168.1.1]:2222" { t.Fatalf("removed %v", removed) } } func TestConnectPort(t *testing.T) { for _, tc := range []struct { client internalssh.Client args []string want int }{ {internalssh.SSH, []string{"-p", "2222", "web"}, 2222}, {internalssh.SSH, []string{"-p2200", "web"}, 2200}, {internalssh.SSH, []string{"-o", "Port=2022", "web"}, 2022}, {internalssh.SFTP, []string{"-P", "23", "web"}, 23}, {internalssh.SSH, []string{"web", "-p", "1"}, 22}, } { dest := 0 for i, a := range tc.args { if a == "web" { dest = i } } if got := connectPort(tc.client, tc.args, []int{dest}); got != tc.want { t.Errorf("%v: got %d, want %d", tc.args, got, tc.want) } } } func TestApplyFallback(t *testing.T) { up := map[string]bool{"10.0.0.2": true} oldProbe, oldCandidates := fallbackProbe, fallbackCandidates fallbackProbe = func(address string, port int, _ time.Duration) bool { return up[address] && port == 22 } fallbackCandidates = func(*config.Config, resolvedHost) ([]resolver.Candidate, error) { return []resolver.Candidate{{Address: "10.0.0.1", Strategy: "management_subnet"}, {Address: "10.0.0.2", Strategy: "primary_ip"}}, nil } t.Cleanup(func() { fallbackProbe, fallbackCandidates = oldProbe, oldCandidates }) host := resolvedHost{Name: "web", Kind: "vm", IP: "10.0.0.1"} cfg := &config.Config{} if got := applyFallback(cfg, host, config.SSHOptions{}, internalssh.WrapperFlags{}, 22); got.IP != "10.0.0.1" { t.Fatal("fallback ran while disabled") } cfg.Resolver.Fallback = true if got := applyFallback(cfg, host, config.SSHOptions{}, internalssh.WrapperFlags{}, 22); got.IP != "10.0.0.2" { t.Fatalf("fallback did not switch: %s", got.IP) } if got := applyFallback(cfg, host, config.SSHOptions{ProxyJump: "jump"}, internalssh.WrapperFlags{}, 22); got.IP != "10.0.0.1" { t.Fatal("hosts behind a jump host must not be probed") } if got := applyFallback(cfg, host, config.SSHOptions{ProxyJump: "jump"}, internalssh.WrapperFlags{NoJump: true}, 22); got.IP != "10.0.0.2" { t.Fatal("--no-jump should allow the fallback") } up = map[string]bool{} if got := applyFallback(cfg, host, config.SSHOptions{}, internalssh.WrapperFlags{}, 22); got.IP != "10.0.0.1" { t.Fatal("must keep the chosen address when nothing answers") } } func TestReachableProbe(t *testing.T) { ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Skip(err) } port := ln.Addr().(*net.TCPAddr).Port if !reachable("127.0.0.1", port, time.Second) { t.Fatal("listening port reported unreachable") } ln.Close() if reachable("127.0.0.1", port, 200*time.Millisecond) { t.Fatal("closed port reported reachable") } } func TestWhoisAddresses(t *testing.T) { old := lookupHost lookupHost = func(_ context.Context, host string) ([]string, error) { if host == "mail.example.com" { return []string{"192.0.2.25"}, nil } return nil, errors.New("no such host") } t.Cleanup(func() { lookupHost = old }) for in, want := range map[string]string{"10.0.0.1": "10.0.0.1", "10.0.0.0/24": "10.0.0.0", "mail.example.com": "192.0.2.25"} { got, err := whoisAddresses(context.Background(), in) if err != nil || len(got) != 1 || got[0] != want { t.Errorf("%s: %v %v", in, got, err) } } if _, err := whoisAddresses(context.Background(), "nope.invalid"); err == nil { t.Fatal("unresolvable name accepted") } } func TestWhoisCommandUsesNetBoxAndCache(t *testing.T) { srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch r.URL.Path { case "/api/ipam/ip-addresses/": fmt.Fprint(w, `{"count":1,"results":[{"address":"10.0.0.1/24","dns_name":"web01.example.com","assigned_object":{"name":"eth0","virtual_machine":{"id":11,"name":"web01"}}}]}`) case "/api/ipam/prefixes/": fmt.Fprint(w, `{"count":1,"results":[{"prefix":"10.0.0.0/24","description":"servers"}]}`) default: http.NotFound(w, r) } })) defer srv.Close() insightEnv(t, fmt.Sprintf("netboxes:\n - name: prod\n url: %s\n token: t\n", srv.URL)) var out bytes.Buffer cmd := rootCmd() cmd.SetOut(&out) cmd.SetArgs([]string{"whois", "10.0.0.1"}) if err := cmd.Execute(); err != nil { t.Fatal(err) } for _, want := range []string{"prod/web01 (vm) eth0", "dns web01.example.com", "10.0.0.0/24 (prod)", `"servers"`, "Cache prod/web01"} { if !strings.Contains(out.String(), want) { t.Errorf("missing %q in\n%s", want, out.String()) } } } func TestOpenPrintsNetBoxURL(t *testing.T) { insightEnv(t, insightConfig) var out bytes.Buffer cmd := rootCmd() cmd.SetOut(&out) cmd.SetArgs([]string{"open", "--print", "prod/sw1"}) if err := cmd.Execute(); err != nil { t.Fatal(err) } if strings.TrimSpace(out.String()) != "https://nb.example/dcim/devices/13/" { t.Fatalf("got %q", out.String()) } cmd = rootCmd() cmd.SetArgs([]string{"open", "--print", "router"}) if err := cmd.Execute(); err == nil || !strings.Contains(err.Error(), "static host") { t.Fatalf("static host: %v", err) } } func TestTokenMigrateAndResolve(t *testing.T) { secret.MockInit() insightEnv(t, insightConfig) var saved config.Config old := saveConfig saveConfig = func(cfg config.Config) error { saved = cfg; return nil } t.Cleanup(func() { saveConfig = old }) tokenMu.Lock() tokenCache = map[string]string{} tokenMu.Unlock() var out bytes.Buffer cmd := rootCmd() cmd.SetOut(&out) cmd.SetArgs([]string{"token", "migrate"}) if err := cmd.Execute(); err != nil { t.Fatal(err) } if len(saved.NetBoxes) != 2 || !config.IsKeyringToken(saved.NetBoxes[0].Token) || !config.IsKeyringToken(saved.NetBoxes[1].Token) { t.Fatalf("tokens not replaced: %+v", saved.NetBoxes) } token, err := resolveToken(saved.NetBoxes[0]) if err != nil || token != "t" { t.Fatalf("token %q, %v", token, err) } cmd = rootCmd() cmd.SetIn(strings.NewReader("nbt_secret\n")) cmd.SetOut(&out) cmd.SetArgs([]string{"token", "set", "lab"}) if err := cmd.Execute(); err != nil { t.Fatal(err) } stored, err := secret.Get("lab") if err != nil || stored != "nbt_secret" { t.Fatalf("stored %q, %v", stored, err) } for _, n := range saved.NetBoxes { if n.Name == "lab" && n.TokenVersion != 2 { t.Fatalf("token version not detected: %+v", n) } } cmd = rootCmd() cmd.SetArgs([]string{"token", "set"}) if err := cmd.Execute(); err == nil { t.Fatal("ambiguous instance accepted") } } func TestCacheRefreshStoresAttributesAndReportsChangedAddresses(t *testing.T) { srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch r.URL.Path { case "/api/dcim/devices/": fmt.Fprint(w, `{"count":1,"results":[{"id":5,"name":"sw1","primary_ip4":{"address":"192.0.2.5/24"}, "status":{"value":"offline"},"site":{"name":"FSN1","slug":"fsn1"},"role":{"name":"Switch","slug":"switch"},"platform":{"name":"Junos","slug":"junos"}}]}`) case "/api/virtualization/virtual-machines/", "/api/ipam/ip-addresses/": fmt.Fprint(w, `{"count":0,"results":[]}`) default: http.NotFound(w, r) } })) defer srv.Close() path := prepareRefreshTest(t, srv.URL, "[primary_ip]") c := cache.New(path, 3600) c.Upsert(cache.Entry{Name: "sw1", IP: "192.0.2.99", Kind: "device"}) if err := c.Save(); err != nil { t.Fatal(err) } stdout := captureStdout(t, func() { cmd := rootCmd() cmd.SetArgs([]string{"cache", "refresh"}) if err := cmd.Execute(); err != nil { t.Fatal(err) } }) if !strings.Contains(stdout, "sw1: 192.0.2.99 → 192.0.2.5") || !strings.Contains(stdout, "known-hosts reset") { t.Fatalf("address change not reported:\n%s", stdout) } if err := c.Load(); err != nil { t.Fatal(err) } got, _ := c.Get("sw1") if got.ID != 5 || got.Status != "offline" || cache.RefOf(got.Site).Slug != "fsn1" || cache.RefOf(got.Platform).Slug != "junos" || cache.RefOf(got.Role).Name != "Switch" { t.Fatalf("attributes not cached: %+v", got) } cfg, _ := config.Load() h, _ := resolveTargetE(cfg, "sw1", false) if h.Status != "offline" || h.Platform.Slug != "junos" || h.ID != 5 { t.Fatalf("resolved host lacks attributes: %+v", h) } } func captureStdout(t *testing.T, fn func()) string { t.Helper() r, w, err := os.Pipe() if err != nil { t.Fatal(err) } old := os.Stdout os.Stdout = w done := make(chan string) go func() { var b bytes.Buffer _, _ = b.ReadFrom(r) done <- b.String() }() defer func() { os.Stdout = old }() fn() w.Close() os.Stdout = old return <-done } func TestExportLocationVarsAndGroups(t *testing.T) { insightEnv(t, insightConfig) cfg, _ := config.Load() hosts, err := exportHosts(cfg, exportFilter{instance: "prod", kind: "device"}) if err != nil { t.Fatal(err) } keys, _ := parseGroupBy("location,rack") out := string(buildInventory(hosts, keys, true).ini()) for _, want := range []string{`netbox_location="Building A/Room 2.04"`, "netbox_rack=R12", "netbox_position=20", "\n[location_building_a]\nsw1\n", "\n[location_room_2_04]\nsw1\n", "\n[rack_r12]\nsw1\n"} { if !strings.Contains(out, want) { t.Errorf("missing %q in\n%s", want, out) } } }