v1
Test / test (push) Successful in 3m36s
Release / release (push) Successful in 7m31s

This commit is contained in:
Sebastian Unterschütz committed 2026-11-17 19:00:44 +01:00
commit 8d4915543e
132 files changed
+20628

No files matched your search

+206
View File
@@ -0,0 +1,206 @@
package hook
import (
"fmt"
"os"
"path/filepath"
"regexp"
"sort"
"strings"
"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/shortcuts"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage"
)
// AliasEntry holds a single shell alias mapping.
type AliasEntry struct {
Command string // configured host command; empty means the default SSH alias
Name string // short alias name (e.g. "web01")
Host string // canonical NetBox hostname (e.g. "web01.example.com")
}
// AliasesPath returns the path for the bash/zsh aliases file.
func AliasesPath() string {
cacheDir := os.Getenv("XDG_CACHE_HOME")
if cacheDir == "" {
var err error
cacheDir, err = os.UserCacheDir()
if err != nil {
cacheDir = filepath.Join(os.Getenv("HOME"), ".cache")
}
}
return filepath.Join(cacheDir, "netssh", "aliases.sh")
}
// FishAliasesPath returns the path for the fish conf.d aliases file.
// Fish auto-sources every file in conf.d, so no explicit source line is needed.
func FishAliasesPath() string {
return filepath.Join(FishConfigDir(), "conf.d", "netssh.fish")
}
// WriteAliasFiles writes alias definitions to disk for all supported shells.
//
// The bash/zsh file (~/.cache/netssh/aliases.sh) is always written.
// The fish file (~/.config/fish/conf.d/netssh.fish) is written only when
// ~/.config/fish/ already exists (i.e. fish is configured on this system).
func WriteAliasFiles(entries []AliasEntry) error {
if err := writeShAliasFile(entries); err != nil {
return err
}
writeFishAliasFile(entries) // best-effort — never blocks the caller on failure
alias := ""
for _, entry := range entries {
if entry.Host == "" && entry.Command == "" {
alias = entry.Name
break
}
}
return SyncCommandCompletion(alias)
}
func writeShAliasFile(entries []AliasEntry) error {
p := AliasesPath()
if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
return fmt.Errorf("creating aliases dir: %w", err)
}
var b strings.Builder
b.WriteString("# netssh aliases — generated automatically, do not edit\n")
b.WriteString("# Regenerated on every shell start and after 'netssh cache refresh'.\n")
for _, e := range entries {
b.WriteString(e.Definition("bash") + "\n")
}
return storage.WriteFile(p, []byte(b.String()), 0o600)
}
func writeFishAliasFile(entries []AliasEntry) {
// Only write if fish is configured on this system.
if _, err := os.Stat(FishConfigDir()); err != nil {
return
}
p := FishAliasesPath()
if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
return
}
var b strings.Builder
b.WriteString("# netssh aliases — generated automatically, do not edit\n")
b.WriteString("# Regenerated on every shell start and after 'netssh cache refresh'.\n")
for _, e := range entries {
b.WriteString(e.Definition("fish") + "\n")
}
storage.WriteFile(p, []byte(b.String()), 0o600) //nolint:errcheck
}
// Empty Host represents an alias for the netssh command itself.
func (e AliasEntry) Definition(shell string) string {
command := "netssh"
if e.Command != "" {
command += " run " + shellQuote(e.Command, shell) + " --"
}
if e.Host != "" {
host := e.Host
if !regexp.MustCompile(`^[a-zA-Z0-9_.:-]+$`).MatchString(host) {
host = shellQuote(host, shell)
}
command += " " + host
}
if shell == "fish" {
return fmt.Sprintf("alias %s %s", e.Name, shellQuote(command, shell))
}
return fmt.Sprintf("alias %s=%s", e.Name, shellQuote(command, shell))
}
func shellQuote(value, shell string) string {
if shell == "fish" {
value = strings.ReplaceAll(value, `\`, `\\`)
return "'" + strings.ReplaceAll(value, "'", `\'`) + "'"
}
return "'" + strings.ReplaceAll(value, "'", `'\''`) + "'"
}
// BuildAliasEntries gives the configured command alias priority over host aliases.
func BuildAliasEntries(entries []cache.Entry, cfg config.Config) []AliasEntry {
sort.Slice(entries, func(i, j int) bool { return entries[i].Name < entries[j].Name })
seen := map[string]bool{"netssh": true}
var out []AliasEntry
if cfg.Shell.Alias != "" && config.ValidateCommandAlias(cfg.Shell.Alias) == nil {
seen[cfg.Shell.Alias] = true
out = append(out, AliasEntry{Name: cfg.Shell.Alias})
}
withoutPrefix := make(map[string]bool, len(cfg.NetBoxes))
for _, source := range cfg.NetBoxes {
withoutPrefix[strings.ToLower(source.Name)] = source.DisablePrefix
}
// Reserve canonical aliases as well as requested bare aliases before
// generating any output, so cache ordering cannot redirect a collision.
canonical := make(map[string]bool, len(entries))
counts := make(map[string]int, len(entries))
candidates := make([]string, len(entries))
for i, e := range entries {
name := shortcuts.AliasName(e.Name, cfg.Shortcuts)
canonical[name] = true
source, host, qualified := strings.Cut(e.Name, "/")
if qualified && withoutPrefix[strings.ToLower(source)] {
name = shortcuts.AliasName(host, cfg.Shortcuts)
}
candidates[i] = name
counts[name]++
}
validAlias := regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_-]*$`)
for i, e := range entries {
name := candidates[i]
full := shortcuts.AliasName(e.Name, cfg.Shortcuts)
if name != full && (counts[name] > 1 || canonical[name] || seen[name] || !validAlias.MatchString(name)) {
name = full
}
if seen[name] || name == "" || !validAlias.MatchString(name) {
continue
}
seen[name] = true
out = append(out, AliasEntry{Name: name, Host: e.Name})
}
// Build from the final SSH aliases, preserving per-instance prefix and
// collision handling. Never replace an existing SSH or command alias.
hostAliases := append([]AliasEntry(nil), out...)
var commands []string
for name := range cfg.Commands {
commands = append(commands, name)
}
sort.Strings(commands)
var candidatesForCommands []AliasEntry
commandCounts := make(map[string]int)
for _, name := range commands {
prefix := cfg.Commands[name].AliasPrefix
if prefix == "" {
continue
}
for _, host := range hostAliases {
if host.Host == "" {
continue
}
alias := prefix + host.Name
commandCounts[alias]++
candidatesForCommands = append(candidatesForCommands, AliasEntry{Name: alias, Host: host.Host, Command: name})
}
}
for _, c := range candidatesForCommands {
if seen[c.Name] || commandCounts[c.Name] != 1 {
continue
}
seen[c.Name] = true
out = append(out, c)
}
return out
}
// FishConfigDir follows fish's XDG layout on both Linux and macOS.
func FishConfigDir() string {
dir := os.Getenv("XDG_CONFIG_HOME")
if dir == "" {
dir = filepath.Join(os.Getenv("HOME"), ".config")
}
return filepath.Join(dir, "fish")
}
+418
View File
@@ -0,0 +1,418 @@
package hook_test
import (
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"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/hook"
)
func TestAliasesPath_UnderCacheDir(t *testing.T) {
dir := t.TempDir()
orig := os.Getenv("XDG_CACHE_HOME")
os.Setenv("XDG_CACHE_HOME", dir)
defer os.Setenv("XDG_CACHE_HOME", orig)
p := hook.AliasesPath()
if !strings.HasPrefix(p, dir) {
t.Errorf("AliasesPath should be under XDG_CACHE_HOME, got %q", p)
}
if !strings.HasSuffix(p, "aliases.sh") {
t.Errorf("AliasesPath should end with aliases.sh, got %q", p)
}
}
func TestFishAliasesPath_UnderConfigDir(t *testing.T) {
dir := t.TempDir()
orig := os.Getenv("XDG_CONFIG_HOME")
os.Setenv("XDG_CONFIG_HOME", dir)
defer os.Setenv("XDG_CONFIG_HOME", orig)
p := hook.FishAliasesPath()
if !strings.HasPrefix(p, dir) {
t.Errorf("FishAliasesPath should be under XDG_CONFIG_HOME, got %q", p)
}
if !strings.HasSuffix(p, "netssh.fish") {
t.Errorf("FishAliasesPath should end with netssh.fish, got %q", p)
}
}
// TestWriteAliasFiles_ShFile verifies the bash/zsh file is always written.
func TestWriteAliasFiles_ShFile(t *testing.T) {
cacheDir := t.TempDir()
orig := os.Getenv("XDG_CACHE_HOME")
os.Setenv("XDG_CACHE_HOME", cacheDir)
defer os.Setenv("XDG_CACHE_HOME", orig)
entries := []hook.AliasEntry{
{Name: "web01", Host: "web01.example.com"},
{Name: "db01", Host: "db01.example.com"},
}
if err := hook.WriteAliasFiles(entries); err != nil {
t.Fatalf("WriteAliasFiles: %v", err)
}
data, err := os.ReadFile(hook.AliasesPath())
if err != nil {
t.Fatalf("aliases.sh not created: %v", err)
}
content := string(data)
for _, want := range []string{
"alias web01='netssh web01.example.com'",
"alias db01='netssh db01.example.com'",
} {
if !strings.Contains(content, want) {
t.Errorf("aliases.sh missing %q\ncontent:\n%s", want, content)
}
}
}
// TestWriteAliasFiles_FishFile verifies the fish file is written when fish config dir exists.
func TestWriteAliasFiles_FishFile(t *testing.T) {
configDir := t.TempDir()
orig := os.Getenv("XDG_CONFIG_HOME")
os.Setenv("XDG_CONFIG_HOME", configDir)
defer os.Setenv("XDG_CONFIG_HOME", orig)
// Create the fish config directory so WriteAliasFiles knows fish is set up.
fishDir := filepath.Join(configDir, "fish")
os.MkdirAll(fishDir, 0o755)
cacheDir := t.TempDir()
origCache := os.Getenv("XDG_CACHE_HOME")
os.Setenv("XDG_CACHE_HOME", cacheDir)
defer os.Setenv("XDG_CACHE_HOME", origCache)
entries := []hook.AliasEntry{{Name: "web01", Host: "web01.example.com"}}
if err := hook.WriteAliasFiles(entries); err != nil {
t.Fatalf("WriteAliasFiles: %v", err)
}
data, err := os.ReadFile(hook.FishAliasesPath())
if err != nil {
t.Fatalf("netssh.fish not created: %v", err)
}
if !strings.Contains(string(data), "alias web01 'netssh web01.example.com'") {
t.Errorf("fish alias file missing expected line\ncontent:\n%s", string(data))
}
}
// TestWriteAliasFiles_SkipsFishWhenNotConfigured verifies that fish file is NOT written
// when fish is not set up (no ~/.config/fish directory).
func TestWriteAliasFiles_SkipsFishWhenNotConfigured(t *testing.T) {
configDir := t.TempDir() // no fish subdir
orig := os.Getenv("XDG_CONFIG_HOME")
os.Setenv("XDG_CONFIG_HOME", configDir)
defer os.Setenv("XDG_CONFIG_HOME", orig)
cacheDir := t.TempDir()
origCache := os.Getenv("XDG_CACHE_HOME")
os.Setenv("XDG_CACHE_HOME", cacheDir)
defer os.Setenv("XDG_CACHE_HOME", origCache)
entries := []hook.AliasEntry{{Name: "web01", Host: "web01.example.com"}}
if err := hook.WriteAliasFiles(entries); err != nil {
t.Fatalf("WriteAliasFiles: %v", err)
}
if _, err := os.Stat(hook.FishAliasesPath()); err == nil {
t.Error("fish alias file should not be created when fish is not configured")
}
}
// TestWriteAliasFiles_EmptyEntries verifies an empty (but valid) file is written.
func TestWriteAliasFiles_EmptyEntries(t *testing.T) {
cacheDir := t.TempDir()
orig := os.Getenv("XDG_CACHE_HOME")
os.Setenv("XDG_CACHE_HOME", cacheDir)
defer os.Setenv("XDG_CACHE_HOME", orig)
if err := hook.WriteAliasFiles(nil); err != nil {
t.Fatalf("WriteAliasFiles with nil entries: %v", err)
}
data, err := os.ReadFile(hook.AliasesPath())
if err != nil {
t.Fatalf("aliases.sh not created: %v", err)
}
// Should contain only the header comment, no alias lines.
if strings.Contains(string(data), "alias ") {
t.Error("aliases.sh should have no alias lines for empty entries")
}
}
// --- InstallAliasesSource ---
func TestInstallAliasesSource_Fresh(t *testing.T) {
profile := writeProfile(t, "existing line\n")
installed, err := hook.InstallAliasesSource(profile)
if err != nil {
t.Fatalf("InstallAliasesSource: %v", err)
}
if !installed {
t.Error("should report installed=true on first install")
}
data, _ := os.ReadFile(profile)
if !strings.Contains(string(data), hook.AliasesMarker) {
t.Error("profile should contain aliases source line")
}
}
func TestInstallAliasesSource_Idempotent(t *testing.T) {
profile := writeProfile(t, "")
hook.InstallAliasesSource(profile)
installed, err := hook.InstallAliasesSource(profile)
if err != nil {
t.Fatalf("second InstallAliasesSource: %v", err)
}
if installed {
t.Error("second call should report installed=false")
}
data, _ := os.ReadFile(profile)
if count := strings.Count(string(data), hook.AliasesMarker); count != 1 {
t.Errorf("aliases source line should appear once, got %d", count)
}
}
// TestUninstall_AlsoRemovesAliasesSourceLine verifies that Uninstall removes both lines.
func TestUninstall_AlsoRemovesAliasesSourceLine(t *testing.T) {
content := "export PATH=$PATH\n" +
hook.Line + "\n" +
hook.AliasesSourceLine + "\n" +
"export FOO=bar\n"
profile := writeProfile(t, content)
removed, err := hook.Uninstall(profile)
if err != nil {
t.Fatalf("Uninstall: %v", err)
}
if !removed {
t.Error("should report removed=true")
}
data, _ := os.ReadFile(profile)
s := string(data)
if strings.Contains(s, hook.Marker) {
t.Error("shell-init line should be removed")
}
if strings.Contains(s, hook.AliasesMarker) {
t.Error("aliases source line should be removed")
}
if !strings.Contains(s, "export PATH") || !strings.Contains(s, "export FOO") {
t.Error("other content should be preserved")
}
}
func TestCommandAliasGenerationAndCollision(t *testing.T) {
cfg := config.Config{Shell: config.ShellConfig{Alias: "j"}}
entries := hook.BuildAliasEntries([]cache.Entry{{Name: "j"}, {Name: "netssh"}, {Name: "web-01"}}, cfg)
if len(entries) != 2 {
t.Fatalf("entries: %+v", entries)
}
if got := entries[0].Definition("bash"); got != "alias j='netssh'" {
t.Fatal(got)
}
if got := entries[0].Definition("fish"); got != "alias j 'netssh'" {
t.Fatal(got)
}
if got := entries[1].Definition("bash"); got != "alias web-01='netssh web-01'" {
t.Fatal(got)
}
}
func TestAliasesIncludeInstanceName(t *testing.T) {
cfg := config.Config{Shortcuts: config.ShortcutsConfig{Domains: []string{".example.com"}}}
entries := hook.BuildAliasEntries([]cache.Entry{{Name: "office/web01.example.com"}, {Name: "lab/web01.example.com"}}, cfg)
if len(entries) != 2 {
t.Fatalf("missing qualified aliases: %+v", entries)
}
got := map[string]string{}
for _, entry := range entries {
got[entry.Name] = entry.Host
}
if got["office_web01"] != "office/web01.example.com" || got["lab_web01"] != "lab/web01.example.com" {
t.Fatalf("alias lost source: %+v", entries)
}
}
func TestAliasesUseRewriteRules(t *testing.T) {
cfg := config.Config{Shortcuts: config.ShortcutsConfig{
Domains: []string{".hoster.de"},
Rewrites: []config.ShortcutRewrite{{Pattern: `^([a-z]+)[0-9]+-`, Replace: "$1"}},
}}
entries := hook.BuildAliasEntries([]cache.Entry{{Name: "fsn1-bx1.hoster.de"}}, cfg)
if len(entries) != 1 || entries[0].Definition("bash") != "alias fsnbx1='netssh fsn1-bx1.hoster.de'" {
t.Fatalf("entries: %+v", entries)
}
}
func TestAliasesOptionalInstancePrefix(t *testing.T) {
cfg := config.Config{
NetBoxes: []config.NetBoxConfig{
{Name: "OFFICE", DisablePrefix: true},
{Name: "lab"},
},
Shortcuts: config.ShortcutsConfig{
Domains: []string{".example.com"},
Rewrites: []config.ShortcutRewrite{{Pattern: "^web-", Replace: "app"}},
},
}
entries := hook.BuildAliasEntries([]cache.Entry{
{Name: "office/web-01.example.com"},
{Name: "lab/web-01.example.com"},
}, cfg)
got := map[string]string{}
for _, e := range entries {
got[e.Name] = e.Host
// Both output formats must keep the fully qualified destination.
for _, shell := range []string{"bash", "zsh", "fish"} {
if !strings.Contains(e.Definition(shell), e.Host) {
t.Fatalf("%s alias lost its target: %s", shell, e.Definition(shell))
}
}
}
if len(got) != 2 || got["app01"] != "office/web-01.example.com" || got["lab_app01"] != "lab/web-01.example.com" {
t.Fatalf("unexpected aliases: %+v", entries)
}
}
func TestAliasesWithoutPrefixCollisions(t *testing.T) {
cfg := config.Config{
NetBoxes: []config.NetBoxConfig{
{Name: "office", DisablePrefix: true},
{Name: "lab", DisablePrefix: true},
},
Shell: config.ShellConfig{Alias: "j"},
Shortcuts: config.ShortcutsConfig{Domains: []string{".example.com"}},
}
for _, tc := range []struct {
name string
hosts []string
want map[string]string
}{
{"two instances", []string{"office/web.example.com", "lab/web.example.com"},
map[string]string{"j": "", "office_web": "office/web.example.com", "lab_web": "lab/web.example.com"}},
{"static host", []string{"office/web.example.com", "web"},
map[string]string{"j": "", "office_web": "office/web.example.com", "web": "web"}},
{"command aliases", []string{"office/j", "office/netssh"},
map[string]string{"j": "", "office_j": "office/j", "office_netssh": "office/netssh"}},
{"reserved qualified alias", []string{"office/lab_web", "lab/web"},
map[string]string{"j": "", "office_lab_web": "office/lab_web", "web": "lab/web"}},
{"invalid bare alias", []string{"office/123.example.com"},
map[string]string{"j": "", "office_123": "office/123.example.com"}},
{"normalized names", []string{"office/web.example.com", "office/web"},
map[string]string{"j": "", "office_web": "office/web"}},
} {
t.Run(tc.name, func(t *testing.T) {
var input []cache.Entry
for _, host := range tc.hosts {
input = append(input, cache.Entry{Name: host})
}
entries := hook.BuildAliasEntries(input, cfg)
if len(entries) != len(tc.want) {
t.Fatalf("aliases: %+v, want %+v", entries, tc.want)
}
for _, e := range entries {
if host, ok := tc.want[e.Name]; !ok || host != e.Host {
t.Fatalf("unexpected alias: %+v", e)
}
}
})
}
}
func TestCustomCommandAliases(t *testing.T) {
cfg := config.Config{
NetBoxes: []config.NetBoxConfig{{Name: "office", DisablePrefix: true}},
Shortcuts: config.ShortcutsConfig{Rewrites: []config.ShortcutRewrite{{Pattern: "^xzi-groß", Replace: "xg"}}},
Commands: map[string]config.HostCommand{
"mtr": {AliasPrefix: "m", Args: []string{"mtr", "{address}"}},
"ping": {AliasPrefix: "p", Args: []string{"ping", "{address}"}},
"manual": {Args: []string{"echo", "{host}"}},
},
}
entries := hook.BuildAliasEntries([]cache.Entry{{Name: "office/xzi-groß1", IP: "10.0.0.1"}}, cfg)
got := map[string]hook.AliasEntry{}
for _, e := range entries {
got[e.Name] = e
}
if len(entries) != 3 || got["mxg1"].Command != "mtr" || got["pxg1"].Command != "ping" {
t.Fatalf("unexpected aliases: %+v", entries)
}
if got["mxg1"].Host != "office/xzi-groß1" {
t.Fatal("instance lost")
}
for _, shell := range []string{"bash", "zsh", "fish"} {
def := got["mxg1"].Definition(shell)
if !strings.Contains(def, "netssh run") || !strings.Contains(def, "office/xzi-groß1") || strings.Contains(def, "10.0.0.1") {
t.Fatalf("%s alias must resolve at invocation: %s", shell, def)
}
}
}
func TestCustomCommandAliasesPreserveExistingNames(t *testing.T) {
cfg := config.Config{
Shell: config.ShellConfig{Alias: "mfoo"},
Commands: map[string]config.HostCommand{
"mtr": {AliasPrefix: "m", Args: []string{"mtr", "{address}"}},
"ping": {AliasPrefix: "mp", Args: []string{"ping", "{address}"}},
},
}
entries := hook.BuildAliasEntries([]cache.Entry{
{Name: "foo"}, {Name: "web"}, {Name: "mweb"}, {Name: "x"}, {Name: "px"},
}, cfg)
for _, e := range entries {
if e.Name == "mfoo" && (e.Host != "" || e.Command != "") {
t.Fatal("command alias overwritten")
}
if e.Name == "mweb" && (e.Host != "mweb" || e.Command != "") {
t.Fatal("SSH alias overwritten")
}
if e.Name == "mpx" {
t.Fatal("ambiguous custom alias generated")
}
}
}
func TestCustomAliasShellArgumentQuoting(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "netssh"), []byte("#!/bin/sh\nprintf '%s\\n' \"$@\"\n"), 0700); err != nil {
t.Fatal(err)
}
t.Setenv("PATH", dir+string(os.PathListSeparator)+os.Getenv("PATH"))
entry := hook.AliasEntry{Name: "mxg1", Host: "office/xzi-groß1'$(oops)", Command: "mtr"}
for _, shell := range []string{"bash", "zsh", "fish"} {
t.Run(shell, func(t *testing.T) {
path, err := exec.LookPath(shell)
if err != nil {
t.Skip("shell not installed")
}
// A separate parse models invoking an alias after sourcing the file.
script := entry.Definition(shell) + "\neval 'mxg1 --report'\n"
args := []string{"-c", script}
if shell == "bash" {
args = []string{"--noprofile", "--norc", "-O", "expand_aliases", "-c", script}
}
if shell == "zsh" {
args = []string{"-f", "-c", script}
}
if shell == "fish" {
args = []string{"--no-config", "-c", script}
}
out, err := exec.Command(path, args...).CombinedOutput()
want := "run\nmtr\n--\n" + entry.Host + "\n--report\n"
if err != nil || string(out) != want {
t.Fatalf("%q (%v), want %q", out, err, want)
}
})
}
}
+159
View File
@@ -0,0 +1,159 @@
package hook
import (
"fmt"
"os"
"path/filepath"
"strings"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage"
)
const completionMarker = "# netssh command alias completion — generated automatically"
// SyncCommandCompletion installs lazy loaders for the configured command alias.
// The loaders obtain the canonical completion from the current netssh binary,
// so aliases configured by the wizard work without a separate completion install.
func SyncCommandCompletion(alias string) error {
if err := config.ValidateCommandAlias(alias); err != nil {
return err
}
statePath := filepath.Join(filepath.Dir(AliasesPath()), "completion_alias")
data, err := os.ReadFile(statePath)
if err != nil && !os.IsNotExist(err) {
return err
}
previous := strings.TrimSpace(string(data))
if err := config.ValidateCommandAlias(previous); err != nil {
return fmt.Errorf("invalid completion alias state: %w", err)
}
if alias == "" && previous == "" {
return nil
}
for _, shell := range []string{"bash", "zsh", "fish"} {
if previous != "" && previous != alias {
path := commandCompletionPath(shell, previous)
data, err := os.ReadFile(path)
if err != nil && !os.IsNotExist(err) {
return err
}
// Only delete files owned by netssh; preserve any user replacements.
if strings.HasPrefix(string(data), completionMarker+"\n") || strings.HasPrefix(string(data), "#compdef "+previous+"\n"+completionMarker+"\n") {
if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
return err
}
}
}
if alias == "" {
continue
}
if shell == "fish" {
if _, err := os.Stat(FishConfigDir()); os.IsNotExist(err) {
continue
} else if err != nil {
return err
}
}
path := commandCompletionPath(shell, alias)
script := commandCompletionScript(shell, alias)
existing, err := os.ReadFile(path)
if err != nil && !os.IsNotExist(err) {
return err
}
if string(existing) == script {
continue
}
if err := storage.WriteFile(path, []byte(script), 0o644); err != nil {
return fmt.Errorf("writing %s alias completion: %w", shell, err)
}
}
if alias == "" {
if err := os.Remove(statePath); err != nil && !os.IsNotExist(err) {
return err
}
return nil
}
return storage.WriteFile(statePath, []byte(alias+"\n"), 0o600)
}
func commandCompletionPath(shell, alias string) string {
switch shell {
case "bash":
return filepath.Join(os.Getenv("HOME"), ".local", "share", "bash-completion", "completions", alias)
case "zsh":
return filepath.Join(ZshFuncDir(), "_"+alias)
default:
return filepath.Join(FishConfigDir(), "completions", alias+".fish")
}
}
func commandCompletionScript(shell, alias string) string {
switch shell {
case "bash":
return fmt.Sprintf(`%s
source <(netssh completion bash)
if [[ $(type -t compopt) == builtin ]]; then
complete -o default -F __start_netssh %s
else
complete -o default -o nospace -F __start_netssh %s
fi
`, completionMarker, alias, alias)
case "zsh":
return fmt.Sprintf(`#compdef %s
%s
source <(netssh completion zsh)
compdef _netssh %s
_netssh "$@"
`, alias, completionMarker, alias)
default:
return fmt.Sprintf(`%s
netssh completion fish | source
complete --command %s --wraps netssh
`, completionMarker, alias)
}
}
// CompletionFiles lists the completion and alias files netssh may have
// installed for itself and for the given command aliases.
func CompletionFiles(aliases ...string) []string {
files := []string{
filepath.Join(os.Getenv("HOME"), ".local", "share", "bash-completion", "completions", "netssh"),
filepath.Join(ZshFuncDir(), "_netssh"),
filepath.Join(FishConfigDir(), "completions", "netssh.fish"),
FishAliasesPath(),
}
// oh-my-zsh caches generated completions separately.
for _, dir := range []string{os.Getenv("ZSH_CACHE_DIR"), filepath.Join(os.Getenv("ZSH"), "cache"), filepath.Join(os.Getenv("HOME"), ".oh-my-zsh", "cache")} {
if dir != "" && dir != "cache" {
files = append(files, filepath.Join(dir, "completions", "_netssh"))
}
}
for _, alias := range aliases {
if config.ValidateCommandAlias(alias) != nil || alias == "" {
continue
}
for _, shell := range []string{"bash", "zsh", "fish"} {
files = append(files, commandCompletionPath(shell, alias))
}
}
return files
}
// CompletionAliasState returns the command alias whose completion files were
// last generated, or "" when there is none.
func CompletionAliasState() string {
data, err := os.ReadFile(filepath.Join(filepath.Dir(AliasesPath()), "completion_alias"))
if err != nil {
return ""
}
return strings.TrimSpace(string(data))
}
// IsGenerated reports whether a completion file was written by netssh,
// so uninstall never removes a user's own file of the same name.
func IsGenerated(path string) bool {
data, err := os.ReadFile(path)
return err == nil && strings.Contains(string(data), "netssh")
}
+207
View File
@@ -0,0 +1,207 @@
package hook_test
import (
"bytes"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/hook"
"github.com/spf13/cobra"
)
func completionEnvironment(t *testing.T) map[string]string {
t.Helper()
home := t.TempDir()
t.Setenv("HOME", home)
t.Setenv("XDG_CONFIG_HOME", filepath.Join(home, "config"))
t.Setenv("XDG_CACHE_HOME", filepath.Join(home, "cache"))
if err := os.MkdirAll(hook.FishConfigDir(), 0o755); err != nil {
t.Fatal(err)
}
return map[string]string{
"bash": filepath.Join(home, ".local", "share", "bash-completion", "completions", "j"),
"zsh": filepath.Join(home, ".zfunc", "_j"),
"fish": filepath.Join(hook.FishConfigDir(), "completions", "j.fish"),
}
}
func TestCommandCompletionTracksAliasChanges(t *testing.T) {
paths := completionEnvironment(t)
if err := hook.WriteAliasFiles([]hook.AliasEntry{{Name: "j"}}); err != nil {
t.Fatal(err)
}
for _, path := range paths {
if _, err := os.Stat(path); err != nil {
t.Fatal(err)
}
}
// A manually replaced completion file must survive removal of the old alias.
custom := "# user-owned completion\n"
if err := os.WriteFile(paths["bash"], []byte(custom), 0o644); err != nil {
t.Fatal(err)
}
if err := hook.WriteAliasFiles([]hook.AliasEntry{{Name: "k"}}); err != nil {
t.Fatal(err)
}
for shell, path := range paths {
if shell == "bash" {
data, err := os.ReadFile(path)
if err != nil || string(data) != custom {
t.Fatal("user completion was removed")
}
} else if _, err := os.Stat(path); !os.IsNotExist(err) {
t.Fatalf("stale %s completion remains: %v", shell, err)
}
}
if err := hook.WriteAliasFiles(nil); err != nil {
t.Fatal(err)
}
for _, path := range []string{
filepath.Join(os.Getenv("HOME"), ".local", "share", "bash-completion", "completions", "k"),
filepath.Join(os.Getenv("HOME"), ".zfunc", "_k"),
filepath.Join(hook.FishConfigDir(), "completions", "k.fish"),
} {
if _, err := os.Stat(path); !os.IsNotExist(err) {
t.Fatalf("disabled completion remains: %s: %v", path, err)
}
}
}
func TestCommandAliasCompletesServerNamesAcrossShells(t *testing.T) {
for _, shell := range []string{"bash", "zsh", "fish"} {
t.Run(shell, func(t *testing.T) {
executable, err := exec.LookPath(shell)
if err != nil {
t.Skipf("%s unavailable", shell)
}
paths := completionEnvironment(t)
if err := hook.SyncCommandCompletion("j"); err != nil {
t.Fatal(err)
}
fixtures := t.TempDir()
root := &cobra.Command{Use: "netssh"}
var canonical bytes.Buffer
switch shell {
case "bash":
err = root.GenBashCompletionV2(&canonical, true)
case "zsh":
_, err = canonical.WriteString(hook.ZshCompletionScript)
case "fish":
err = root.GenFishCompletion(&canonical, true)
}
if err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(fixtures, shell), canonical.Bytes(), 0o644); err != nil {
t.Fatal(err)
}
// Exercise Cobra's actual generated shell code with a deterministic backend.
backend := `#!/bin/bash
case "$1" in
completion) cat "$COMPLETION_FIXTURES/$2" ;;
__complete|__completeNoDesc) printf 'server01\n:4\n' ;;
*) exit 1 ;;
esac
`
if err := os.WriteFile(filepath.Join(fixtures, "netssh"), []byte(backend), 0o755); err != nil {
t.Fatal(err)
}
t.Setenv("COMPLETION_FIXTURES", fixtures)
t.Setenv("ALIAS_COMPLETION", paths[shell])
t.Setenv("PATH", fixtures+string(os.PathListSeparator)+os.Getenv("PATH"))
var script string
var args []string
switch shell {
case "bash":
library := ""
for _, path := range []string{"/usr/share/bash-completion/bash_completion", "/etc/bash_completion"} {
if _, err := os.Stat(path); err == nil {
library = path
break
}
}
if library == "" {
t.Skip("bash-completion unavailable")
}
t.Setenv("BASH_COMPLETION_LIBRARY", library)
args = []string{"--noprofile", "--norc", "-c"}
script = `source "$BASH_COMPLETION_LIBRARY"
shopt -s expand_aliases
alias j=netssh
_completion_loader j
COMP_WORDS=(j ser)
COMP_CWORD=1
COMP_LINE='j ser'
COMP_POINT=5
COMP_TYPE=9
COMP_KEY=9
__start_netssh j ser j
printf '%s\n' "${COMPREPLY[@]}"
`
case "zsh":
args = []string{"-f", "-c"}
script = `fpath=("$HOME/.zfunc" $fpath)
autoload -Uz compinit
compinit -u -D
alias j=netssh
autoload -Uz _j
# Capture matches without requiring an interactive ZLE completion widget.
_describe() { print -rl -- "${(P)4}"; }
compadd() { print -rl -- "$@"; }
words=(j ser)
CURRENT=2
_j
`
case "fish":
args = []string{"--no-config", "-c"}
script = `alias j netssh
set -p fish_complete_path "$XDG_CONFIG_HOME/fish/completions"
complete --do-complete 'j ser'
`
}
cmd := exec.Command(executable, append(args, script)...)
out, err := cmd.CombinedOutput()
if err != nil || !strings.Contains(string(out), "server01") {
t.Fatalf("%s completion: %v\n%s", shell, err, out)
}
})
}
}
func TestZshCompletionSplitsHostsAndCommands(t *testing.T) {
zsh, err := exec.LookPath("zsh")
if err != nil {
t.Skip("zsh unavailable")
}
dir := t.TempDir()
backend := "#!/bin/sh\nprintf 'web01\\nweb:02\\ncache\\tManage the cache\\n:36\\n'\n"
if err := os.WriteFile(filepath.Join(dir, "netssh"), []byte(backend), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "_netssh"), []byte(hook.ZshCompletionScript), 0o644); err != nil {
t.Fatal(err)
}
script := `compdef() { :; }
source "$DIR/_netssh"
_describe() { print -r -- "describe ${(P)4}"; }
compadd() { print -r -- "compadd $*"; }
_files() { print -r -- files; }
words=(netssh "")
CURRENT=2
_netssh
`
cmd := exec.Command(zsh, "-f", "-c", script)
cmd.Env = append(os.Environ(), "DIR="+dir, "PATH="+dir+string(os.PathListSeparator)+os.Getenv("PATH"))
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("%v\n%s", err, out)
}
// Directive 36 = NoFileComp|KeepOrder: unsorted host group, no file fallback.
want := "describe cache:Manage the cache\ncompadd -V hosts -X %Bhosts%b -M l:|=* -- web01 web:02\n"
if string(out) != want {
t.Fatalf("got:\n%s\nwant:\n%s", out, want)
}
}
+280
View File
@@ -0,0 +1,280 @@
package hook
import (
"fmt"
"os"
"path/filepath"
"regexp"
"strings"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage"
)
const (
// Marker is the unique string used to detect an existing hook line.
Marker = "netssh shell-init"
BlockStart = "# >>> netssh >>>"
BlockEnd = "# <<< netssh <<<"
// Line is the full line written into the shell profile.
Line = "netssh shell-init # netssh cache auto-refresh"
// AliasesMarker is the unique string used to detect the aliases source line.
AliasesMarker = "netssh/aliases.sh"
// AliasesSourceLine is the bash/zsh line that sources the generated aliases file.
AliasesSourceLine = "source ~/.cache/netssh/aliases.sh 2>/dev/null # netssh aliases"
)
// ProfilePath returns the canonical shell profile path for the given shell name.
func ProfilePath(shell string) (string, error) {
switch shell {
case "bash":
return filepath.Join(os.Getenv("HOME"), ".bashrc"), nil
case "zsh":
dir := os.Getenv("ZDOTDIR")
if dir == "" {
dir = os.Getenv("HOME")
}
return filepath.Join(dir, ".zshrc"), nil
case "fish":
return filepath.Join(FishConfigDir(), "config.fish"), nil
default:
return "", fmt.Errorf("unsupported shell %q — supported: bash, zsh, fish", shell)
}
}
// ReloadNote returns the shell-specific hint for reloading the profile.
func ReloadNote(profilePath string) string {
return "Reload with: source " + profilePath
}
// IsInstalled reports whether the hook marker is present in the profile file.
// Returns false if the file does not exist or cannot be read.
func IsInstalled(profilePath string) bool {
data, err := os.ReadFile(profilePath)
if err != nil {
return false
}
for _, line := range strings.Split(string(data), "\n") {
if strings.TrimSpace(line) == BlockStart || hookLinePattern.MatchString(strings.TrimSpace(line)) {
return true
}
}
return false
}
// Install writes the managed netssh block into the profile. Entries written by
// older versions without markers are replaced instead of duplicated; an
// existing managed block (e.g. from install.sh) is left untouched.
// Returns (true, nil) when the profile changed, (false, nil) when already present.
// Creates the profile file (and any parent directories) if they do not exist.
func Install(profilePath, shell string) (installed bool, err error) {
data, err := os.ReadFile(profilePath)
if err != nil && !os.IsNotExist(err) {
return false, fmt.Errorf("reading profile: %w", err)
}
for _, line := range strings.Split(string(data), "\n") {
if strings.TrimSpace(line) == BlockStart {
return false, nil
}
}
cleaned, _, err := clean(string(data), profilePath)
if err != nil {
return false, err
}
if cleaned != "" && !strings.HasSuffix(cleaned, "\n") {
cleaned += "\n"
}
if cleaned != "" {
cleaned += "\n"
}
cleaned += Block(shell)
if err := os.MkdirAll(filepath.Dir(profilePath), 0o755); err != nil {
return false, fmt.Errorf("creating directory: %w", err)
}
if err := writeProfile(profilePath, cleaned); err != nil {
return false, err
}
return true, nil
}
// Block returns the managed profile block for shell.
func Block(shell string) string {
var b strings.Builder
b.WriteString(BlockStart + "\n")
b.WriteString("netssh shell-init\n")
if shell != "fish" {
aliases := shellQuote(AliasesPath(), "bash")
fmt.Fprintf(&b, "[ ! -f %s ] || . %s\n", aliases, aliases)
}
if shell == "zsh" {
b.WriteString(ZshRegistration(ZshFuncDir()))
}
b.WriteString(BlockEnd + "\n")
return b.String()
}
// ZshRegistration adds dir to fpath and registers the completion even when
// compinit already ran earlier in .zshrc (e.g. via oh-my-zsh).
func ZshRegistration(dir string) string {
return fmt.Sprintf("fpath=(%s $fpath)\nif (( $+functions[compdef] )); then autoload -Uz _netssh && compdef _netssh netssh; fi\n", shellQuote(dir, "bash"))
}
// InstallAliasesSource appends the aliases source line to a bash/zsh profile.
// This is a no-op for fish (which uses conf.d auto-sourcing instead).
// Returns (true, nil) when newly added, (false, nil) when already present.
func InstallAliasesSource(profilePath string) (installed bool, err error) {
data, err := os.ReadFile(profilePath)
if err != nil && !os.IsNotExist(err) {
return false, fmt.Errorf("reading profile: %w", err)
}
for _, line := range strings.Split(string(data), "\n") {
if strings.TrimSpace(line) == BlockStart || aliasesLinePattern.MatchString(strings.TrimSpace(line)) {
return false, nil
}
}
f, err := os.OpenFile(profilePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
if err != nil {
return false, fmt.Errorf("opening profile: %w", err)
}
defer f.Close()
if _, err := fmt.Fprintf(f, "%s\n", "source "+shellQuote(AliasesPath(), "bash")+" 2>/dev/null # netssh aliases"); err != nil {
return false, err
}
return true, nil
}
var hookLinePattern = regexp.MustCompile(`^(?:[^\s]*/)?netssh\s+shell-init\s*(?:#.*)?$`)
var aliasesLinePattern = regexp.MustCompile(`^(?:source|\.)\s+["']?[^;|&]*netssh/aliases\.sh["']?(?:\s+2>/dev/null)?\s*(?:#.*)?$`)
// legacyPatterns match the unmarked lines written by older versions and by
// manual setup instructions. They mirror the patterns in install.sh.
var legacyPatterns = []*regexp.Regexp{
hookLinePattern,
aliasesLinePattern,
regexp.MustCompile(`^eval\s+["']?\$\((?:[^\s]*/)?netssh\s+alias(?:\s+--shell\s+(?:bash|zsh))?\)["']?\s*(?:#.*)?$`),
regexp.MustCompile(`^(?:[^\s]*/)?netssh\s+alias(?:\s+--shell\s+fish)?\s*\|\s*source\s*(?:#.*)?$`),
regexp.MustCompile(`^source\s+<\((?:[^\s]*/)?netssh\s+alias\)\s*(?:#.*)?$`),
regexp.MustCompile(`^alias\s+[A-Za-z0-9_.-]+(?:=|\s+)["']netssh(?:\s+[^"']+)?["']\s*(?:#.*)?$`),
}
func isLegacyLine(line string) bool {
for _, pattern := range legacyPatterns {
if pattern.MatchString(line) {
return true
}
}
return false
}
// HasEntries reports whether the profile contains a managed block or legacy lines.
func HasEntries(profilePath string) bool {
data, err := os.ReadFile(profilePath)
if err != nil {
return false
}
_, removed, err := clean(string(data), profilePath)
return removed || err != nil
}
// Uninstall removes legacy hook lines and complete installer-managed blocks.
// Missing profiles are a no-op; malformed blocks leave the file unchanged.
func Uninstall(profilePath string) (removed bool, err error) {
data, err := os.ReadFile(profilePath)
if os.IsNotExist(err) {
return false, nil
}
if err != nil {
return false, fmt.Errorf("reading profile: %w", err)
}
cleaned, removed, err := clean(string(data), profilePath)
if err != nil || !removed {
return false, err
}
return true, writeProfile(profilePath, cleaned)
}
// clean strips managed blocks and legacy lines from profile content.
func clean(data, profilePath string) (cleaned string, removed bool, err error) {
if data == "" {
return "", false, nil
}
var kept []string
inside := false
for _, line := range strings.Split(data, "\n") {
value := strings.TrimSpace(line)
switch value {
case BlockStart:
if inside {
return "", false, fmt.Errorf("nested netssh block in %s", profilePath)
}
inside = true
removed = true
continue
case BlockEnd:
if !inside {
return "", false, fmt.Errorf("unmatched netssh block in %s", profilePath)
}
inside = false
continue
}
if inside {
continue
}
if isLegacyLine(value) {
removed = true
continue
}
kept = append(kept, line)
}
if inside {
return "", false, fmt.Errorf("unclosed netssh block in %s", profilePath)
}
if !removed {
return data, false, nil
}
cleaned = strings.ReplaceAll(strings.Join(kept, "\n"), "\n\n\n", "\n\n")
// Drop the blank separator line Install puts in front of the block.
if strings.HasSuffix(cleaned, "\n\n") {
cleaned = strings.TrimRight(cleaned, "\n") + "\n"
}
return cleaned, true, nil
}
// writeProfile replaces the profile atomically, following dotfile symlinks
// and keeping the permissions of an existing file.
func writeProfile(profilePath, content string) error {
target, err := filepath.EvalSymlinks(profilePath)
if os.IsNotExist(err) {
target = profilePath
} else if err != nil {
return err
}
mode := os.FileMode(0o644)
if info, err := os.Stat(target); err == nil {
mode = info.Mode().Perm()
}
if err := storage.WriteFile(target, []byte(content), mode); err != nil {
return fmt.Errorf("writing profile: %w", err)
}
return nil
}
// ProfileCandidates lists every shell profile netssh or install.sh may have
// written to, in the same order as the installer.
func ProfileCandidates() []string {
home := os.Getenv("HOME")
zdot := zshDir()
paths := []string{
filepath.Join(home, ".bashrc"),
filepath.Join(home, ".bash_profile"),
filepath.Join(home, ".bash_login"),
filepath.Join(home, ".profile"),
filepath.Join(zdot, ".zshrc"),
filepath.Join(zdot, ".zprofile"),
filepath.Join(zdot, ".zshenv"),
}
if zdot != home {
paths = append(paths, filepath.Join(home, ".zshrc"), filepath.Join(home, ".zprofile"), filepath.Join(home, ".zshenv"))
}
return append(paths, filepath.Join(FishConfigDir(), "config.fish"))
}
+357
View File
@@ -0,0 +1,357 @@
package hook_test
import (
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/hook"
)
// --- ProfilePath ---
func TestProfilePath_Bash(t *testing.T) {
orig := os.Getenv("HOME")
os.Setenv("HOME", t.TempDir())
defer os.Setenv("HOME", orig)
p, err := hook.ProfilePath("bash")
if err != nil {
t.Fatalf("ProfilePath(bash): %v", err)
}
if !strings.HasSuffix(p, ".bashrc") {
t.Errorf("bash profile should end with .bashrc, got %q", p)
}
}
func TestProfilePath_Zsh(t *testing.T) {
orig := os.Getenv("HOME")
os.Setenv("HOME", t.TempDir())
defer os.Setenv("HOME", orig)
p, err := hook.ProfilePath("zsh")
if err != nil {
t.Fatalf("ProfilePath(zsh): %v", err)
}
if !strings.HasSuffix(p, ".zshrc") {
t.Errorf("zsh profile should end with .zshrc, got %q", p)
}
}
func TestProfilePath_Fish(t *testing.T) {
dir := t.TempDir()
orig := os.Getenv("XDG_CONFIG_HOME")
os.Setenv("XDG_CONFIG_HOME", dir)
defer os.Setenv("XDG_CONFIG_HOME", orig)
p, err := hook.ProfilePath("fish")
if err != nil {
t.Fatalf("ProfilePath(fish): %v", err)
}
if !strings.HasSuffix(p, "config.fish") {
t.Errorf("fish profile should end with config.fish, got %q", p)
}
}
func TestProfilePath_UnknownShell(t *testing.T) {
if _, err := hook.ProfilePath("ksh"); err == nil {
t.Error("unknown shell should return an error")
}
}
// --- IsInstalled ---
func TestIsInstalled_Present(t *testing.T) {
profile := writeProfile(t, hook.Line+"\n")
if !hook.IsInstalled(profile) {
t.Error("IsInstalled should return true when marker is present")
}
}
func TestIsInstalled_Absent(t *testing.T) {
profile := writeProfile(t, "export PATH=$PATH\n")
if hook.IsInstalled(profile) {
t.Error("IsInstalled should return false when marker is absent")
}
}
func TestIsInstalled_MissingFile(t *testing.T) {
if hook.IsInstalled("/nonexistent/path/.bashrc") {
t.Error("IsInstalled should return false for missing file")
}
}
// --- Install ---
func TestInstall_Fresh(t *testing.T) {
profile := filepath.Join(t.TempDir(), ".bashrc")
installed, err := hook.Install(profile, "bash")
if err != nil {
t.Fatalf("Install: %v", err)
}
if !installed {
t.Error("should report installed=true on fresh install")
}
if !hook.IsInstalled(profile) {
t.Error("profile should contain the hook line after Install")
}
}
func TestInstall_Idempotent(t *testing.T) {
profile := filepath.Join(t.TempDir(), ".bashrc")
hook.Install(profile, "bash")
installed, err := hook.Install(profile, "bash")
if err != nil {
t.Fatalf("second Install: %v", err)
}
if installed {
t.Error("second Install should report installed=false")
}
data, _ := os.ReadFile(profile)
if count := strings.Count(string(data), hook.Marker); count != 1 {
t.Errorf("hook line should appear exactly once, got %d", count)
}
}
func TestInstall_CreatesProfileAndParentDirs(t *testing.T) {
profile := filepath.Join(t.TempDir(), "nested", "dir", ".zshrc")
if _, err := hook.Install(profile, "bash"); err != nil {
t.Fatalf("Install should create missing directories: %v", err)
}
if _, err := os.Stat(profile); err != nil {
t.Error("profile file should have been created")
}
}
func TestInstall_PreservesExistingContent(t *testing.T) {
profile := writeProfile(t, "export PATH=$PATH:/usr/local/bin\n")
hook.Install(profile, "bash")
data, _ := os.ReadFile(profile)
content := string(data)
if !strings.Contains(content, "export PATH") {
t.Error("Install should not remove existing content")
}
if !strings.Contains(content, hook.Marker) {
t.Error("hook line should be appended")
}
}
func TestInstall_AppendedAtEnd(t *testing.T) {
profile := writeProfile(t, "existing line\n")
hook.Install(profile, "bash")
data, _ := os.ReadFile(profile)
lines := strings.Split(strings.TrimRight(string(data), "\n"), "\n")
last := lines[len(lines)-1]
if last != hook.BlockEnd {
t.Errorf("managed block should end the profile, got %q", last)
}
}
// --- Uninstall ---
func TestUninstall_Removes(t *testing.T) {
profile := writeProfile(t, "export PATH=$PATH\n"+hook.Line+"\nexport FOO=bar\n")
removed, err := hook.Uninstall(profile)
if err != nil {
t.Fatalf("Uninstall: %v", err)
}
if !removed {
t.Error("should report removed=true")
}
if hook.IsInstalled(profile) {
t.Error("hook line should have been removed")
}
}
func TestUninstall_PreservesOtherContent(t *testing.T) {
profile := writeProfile(t, "export FOO=bar\n"+hook.Line+"\nexport BAZ=qux\n")
hook.Uninstall(profile)
data, _ := os.ReadFile(profile)
content := string(data)
if !strings.Contains(content, "export FOO=bar") {
t.Error("content before hook should be preserved")
}
if !strings.Contains(content, "export BAZ=qux") {
t.Error("content after hook should be preserved")
}
}
func TestUninstall_NotPresent(t *testing.T) {
profile := writeProfile(t, "export PATH=$PATH\n")
removed, err := hook.Uninstall(profile)
if err != nil {
t.Fatalf("Uninstall: %v", err)
}
if removed {
t.Error("should report removed=false when hook was not present")
}
}
func TestUninstall_MissingFile(t *testing.T) {
removed, err := hook.Uninstall("/nonexistent/.bashrc")
if err != nil {
t.Errorf("Uninstall on missing file should not error: %v", err)
}
if removed {
t.Error("should report removed=false for missing file")
}
}
func TestUninstall_CollapsesExtraBlankLines(t *testing.T) {
// blank line before hook + hook + blank line after = three consecutive newlines after removal
profile := writeProfile(t, "line1\n\n"+hook.Line+"\n\nline2\n")
hook.Uninstall(profile)
data, _ := os.ReadFile(profile)
if strings.Contains(string(data), "\n\n\n") {
t.Error("three consecutive blank lines should be collapsed after uninstall")
}
}
// --- Roundtrip ---
func TestInstallUninstall_Roundtrip(t *testing.T) {
profile := writeProfile(t, "existing content\n")
hook.Install(profile, "bash")
if !hook.IsInstalled(profile) {
t.Fatal("should be installed after Install")
}
hook.Uninstall(profile)
if hook.IsInstalled(profile) {
t.Fatal("should not be installed after Uninstall")
}
data, _ := os.ReadFile(profile)
if !strings.Contains(string(data), "existing content") {
t.Error("original content should survive install+uninstall cycle")
}
}
// --- ReloadNote ---
func TestReloadNote_ContainsPath(t *testing.T) {
note := hook.ReloadNote("/home/user/.bashrc")
if !strings.Contains(note, "/home/user/.bashrc") {
t.Errorf("ReloadNote should contain the profile path, got %q", note)
}
}
// --- helpers ---
func writeProfile(t *testing.T, content string) string {
t.Helper()
f := filepath.Join(t.TempDir(), "profile")
if err := os.WriteFile(f, []byte(content), 0o644); err != nil {
t.Fatal(err)
}
return f
}
func TestManagedBlockInstallAndUninstall(t *testing.T) {
original := "export KEEP=yes\n# netssh shell-init documentation\necho 'netssh shell-init'\n"
profile := writeProfile(t, original+hook.BlockStart+"\nexport PATH='/custom/bin':\"$PATH\"\n'/custom/bin/netssh' shell-init\n[ ! -f '/custom/cache/netssh/aliases.sh' ] || . '/custom/cache/netssh/aliases.sh'\n"+hook.BlockEnd+"\n")
if installed, err := hook.Install(profile, "bash"); err != nil || installed {
t.Fatalf("duplicate install: %v, %v", installed, err)
}
if installed, err := hook.InstallAliasesSource(profile); err != nil || installed {
t.Fatalf("duplicate source: %v, %v", installed, err)
}
if removed, err := hook.Uninstall(profile); err != nil || !removed {
t.Fatalf("uninstall: %v, %v", removed, err)
}
data, _ := os.ReadFile(profile)
if string(data) != original {
t.Fatalf("unrelated content changed: %s", data)
}
}
func TestProfilePathRespectsZdotdir(t *testing.T) {
dir := t.TempDir()
t.Setenv("ZDOTDIR", dir)
path, err := hook.ProfilePath("zsh")
if err != nil || path != filepath.Join(dir, ".zshrc") {
t.Fatalf("zsh path: %s, %v", path, err)
}
}
func TestInstallReplacesLegacyEntriesWithBlock(t *testing.T) {
t.Setenv("XDG_CACHE_HOME", t.TempDir())
profile := writeProfile(t, "export KEEP=yes\nnetssh shell-init\nsource ~/.cache/netssh/aliases.sh 2>/dev/null\neval \"$(netssh alias)\"\nalias j='netssh'\necho 'netssh shell-init'\n")
installed, err := hook.Install(profile, "zsh")
if err != nil || !installed {
t.Fatalf("install: %v, %v", installed, err)
}
data, _ := os.ReadFile(profile)
content := string(data)
for _, gone := range []string{"\nnetssh shell-init\nsource", "eval ", "alias j="} {
if strings.Contains(content, gone) {
t.Fatalf("legacy entry %q kept:\n%s", gone, content)
}
}
for _, kept := range []string{"export KEEP=yes", "echo 'netssh shell-init'", hook.BlockStart, "compdef _netssh netssh", "fpath=("} {
if !strings.Contains(content, kept) {
t.Fatalf("missing %q:\n%s", kept, content)
}
}
if strings.Count(content, hook.BlockStart) != 1 {
t.Fatalf("duplicate blocks:\n%s", content)
}
if removed, err := hook.Uninstall(profile); err != nil || !removed {
t.Fatalf("uninstall: %v, %v", removed, err)
}
data, _ = os.ReadFile(profile)
if string(data) != "export KEEP=yes\necho 'netssh shell-init'\n" {
t.Fatalf("unexpected remainder: %q", data)
}
}
func TestBlockPerShell(t *testing.T) {
if b := hook.Block("fish"); strings.Contains(b, "aliases.sh") || strings.Contains(b, "compdef") {
t.Fatalf("fish block: %s", b)
}
if b := hook.Block("bash"); !strings.Contains(b, "aliases.sh") || strings.Contains(b, "compdef") {
t.Fatalf("bash block: %s", b)
}
}
func TestZshBlockRegistersCompletionAfterCompinit(t *testing.T) {
zsh, err := exec.LookPath("zsh")
if err != nil {
t.Skip("zsh unavailable")
}
home := t.TempDir()
t.Setenv("HOME", home)
t.Setenv("ZDOTDIR", home)
t.Setenv("XDG_CACHE_HOME", filepath.Join(home, "cache"))
if err := os.MkdirAll(hook.ZshFuncDir(), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(hook.ZshFuncDir(), "_netssh"), []byte(hook.ZshCompletionScript), 0o644); err != nil {
t.Fatal(err)
}
// compinit runs before the block, as with oh-my-zsh.
rc := "autoload -Uz compinit && compinit -u -d \"$HOME/.zcompdump\"\nnetssh() { :; }\n" + hook.Block("zsh")
if err := os.WriteFile(filepath.Join(home, ".zshrc"), []byte(rc), 0o644); err != nil {
t.Fatal(err)
}
out, err := exec.Command(zsh, "-i", "-c", `print -r -- $_comps[netssh]`).CombinedOutput()
if err != nil || !strings.Contains(string(out), "_netssh") {
t.Fatalf("completion not registered: %v\n%s", err, out)
}
}
+100
View File
@@ -0,0 +1,100 @@
package hook
import (
"fmt"
"os"
"path/filepath"
)
// ZshCompletionScript replaces Cobra's generated zsh completion. Cobra's script
// spawns a subshell per candidate and passes every host through _describe,
// which takes tens of seconds for thousands of hosts. This script splits the
// candidates with parameter expansion only: entries with a description
// (subcommands, flags) go through _describe, plain hostnames through compadd.
//
// The file works both from fpath (autoloaded as _netssh) and when sourced.
const ZshCompletionScript = `#compdef netssh
compdef _netssh netssh
# netssh zsh completion — generated by netssh, do not edit.
_netssh() {
local -a lines described plain
local out directive=0 entry ret=1
local -a nospace
out=$(netssh __complete "${(@)words[2,CURRENT]}" 2>/dev/null) || return 1
lines=("${(@f)out}")
if [[ ${lines[-1]} == :<-> ]]; then
directive=${lines[-1]#:}
lines[-1]=()
fi
# Directive 1: error.
(( directive & 1 )) && return 1
lines=(${lines:#_activeHelp_*})
lines=(${lines:#})
# Directive 2: no trailing space.
(( directive & 2 )) && nospace=(-S '')
# Directive 8: the lines are file extensions to filter by.
if (( directive & 8 )); then
local -a globs
for entry in $lines; do globs+=("*.${entry}"); done
_files -g "(${(j:|:)globs})"
return
fi
# Directive 16: complete directories only.
if (( directive & 16 )); then
_files -/
return
fi
described=(${(M)lines:#*$'\t'*})
plain=(${lines:#*$'\t'*})
if (( $#described )); then
local -a items
for entry in $described; do
items+=("${${entry%%$'\t'*}//:/\\:}:${entry#*$'\t'}")
done
_describe -t commands 'netssh command' items $nospace && ret=0
fi
if (( $#plain )); then
# netssh already filtered the hosts, also by the name after an instance
# prefix: "fsn1" offers "prod/fsn1-…". 'l:|=*' lets zsh accept text
# before the typed word instead of discarding these matches.
local -a group=(-J hosts)
# Directive 32: keep the order supplied by netssh.
(( directive & 32 )) && group=(-V hosts)
compadd $group -X '%Bhosts%b' -M 'l:|=*' $nospace -- $plain && ret=0
fi
# Directive 4: no file completion as a fallback.
if (( ! $#lines && ! (directive & 4) )); then
_files && ret=0
fi
return ret
}
if [ "$funcstack[1]" = "_netssh" ]; then
_netssh "$@"
fi
`
// ZshCompletionNote tells the user how zsh picks up a completion file in dir.
func ZshCompletionNote(dir string) string {
dump := filepath.Join(zshDir(), ".zcompdump")
return fmt.Sprintf(`zsh loads it from fpath. The netssh block in your .zshrc adds %s
(netssh hook install). Otherwise add this before compinit:
fpath=(%s $fpath)
Then refresh the completion cache: rm -f %s* && exec zsh`, dir, dir, dump)
}
func zshDir() string {
if dir := os.Getenv("ZDOTDIR"); dir != "" {
return dir
}
return os.Getenv("HOME")
}
// ZshFuncDir is the user directory netssh installs zsh completion files into.
func ZshFuncDir() string {
return filepath.Join(os.Getenv("HOME"), ".zfunc")
}