test: raise overall coverage from 71.7% to 90.1%

Add comprehensive test suites across all packages to bring statement
coverage above 90%. The only production code change is making
RunCommand use connectionFunc (consistent with the existing worker
stub pattern) and adding a runCommandFunc variable in shell for
testing runAsync without SSH.

Coverage results:
  cmd/          86.7% → 97.7%
  internal/jobs  78.0% → 94.1%
  internal/shell 77.6% → 98.0%
  internal/sshConn 54.4% → 71.1%
  overall        71.7% → 90.1%

New tests cover: RunCommand via mock SSH server (net.Pipe),
getValue/getAllValues/expandPath/hostKeyCallback config helpers,
worker session and control-byte error paths, ProxyWriter \r\n
stripping, history edge cases, statusLines/formatJob/formatHostStatus
branches, model.Update paths for :async/:status/:list/CommandRun with
no connected hosts, output_buffer zero capacity, runAsync via direct
stub and teatest, parseGroupSpecs YAML branches, parseHostSpec IPv6,
initConfig, and sentinel edge cases.

Author: ncode

cmd/hosts_test.go

@@ -281,3 +281,134 @@ func TestValidatePort(t *testing.T) {
 		t.Fatalf("expected out of range error")
 	}
 }
+
+func TestParseGroupSpecsMapInterfaceInterface(t *testing.T) {
+	raw := map[interface{}]interface{}{
+		"hosts": []interface{}{"host1"},
+	}
+	specs, err := parseGroupSpecs(raw, "alt")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	want := []HostSpec{
+		{Host: "host1", Port: defaultPort},
+	}
+	if !reflect.DeepEqual(specs, want) {
+		t.Fatalf("unexpected specs: %+v", specs)
+	}
+}
+
+func TestParseGroupSpecsInvalidKeyType(t *testing.T) {
+	raw := map[interface{}]interface{}{
+		42: "val",
+	}
+	_, err := parseGroupSpecs(raw, "badkey")
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+	if !strings.Contains(err.Error(), "invalid key type") {
+		t.Fatalf("expected invalid key type error, got %v", err)
+	}
+}
+
+func TestParseGroupSpecsEmptyHostsList(t *testing.T) {
+	raw := map[string]interface{}{
+		"hosts": []interface{}{},
+	}
+	specs, err := parseGroupSpecs(raw, "empty")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if specs != nil {
+		t.Fatalf("expected nil, got %+v", specs)
+	}
+}
+
+func TestParseGroupSpecsNonStringHostEntry(t *testing.T) {
+	raw := map[string]interface{}{
+		"hosts": []interface{}{42},
+	}
+	_, err := parseGroupSpecs(raw, "numhost")
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+	if !strings.Contains(err.Error(), "must be a string") {
+		t.Fatalf("expected 'must be a string' error, got %v", err)
+	}
+}
+
+func TestParseGroupSpecsHostsNotAList(t *testing.T) {
+	raw := map[string]interface{}{
+		"hosts": "not-a-list",
+	}
+	_, err := parseGroupSpecs(raw, "badlist")
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+	if !strings.Contains(err.Error(), "hosts must be a list") {
+		t.Fatalf("expected 'hosts must be a list' error, got %v", err)
+	}
+}
+
+func TestParseGroupSpecsNilReturnsNil(t *testing.T) {
+	specs, err := parseGroupSpecs(nil, "nothing")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if specs != nil {
+		t.Fatalf("expected nil, got %+v", specs)
+	}
+}
+
+func TestParseHostSpecUserAtEmptyHost(t *testing.T) {
+	_, err := parseHostSpec("user@")
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+	if !strings.Contains(err.Error(), "invalid user@host") {
+		t.Fatalf("expected 'invalid user@host' error, got %v", err)
+	}
+}
+
+func TestParseHostSpecIPv6WithPort(t *testing.T) {
+	got, err := parseHostSpec("[::1]:22")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	want := HostSpec{Host: "::1", Port: 22, PortSet: true}
+	if got != want {
+		t.Fatalf("expected %+v, got %+v", want, got)
+	}
+}
+
+func TestParseHostSpecIPv6NoBrackets(t *testing.T) {
+	got, err := parseHostSpec("2001:db8::1")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	want := HostSpec{Host: "2001:db8::1", Port: defaultPort}
+	if got != want {
+		t.Fatalf("expected %+v, got %+v", want, got)
+	}
+}
+
+func TestParseHostSpecIPv6BracketBadPort(t *testing.T) {
+	_, err := parseHostSpec("[::1]:bad")
+	if err == nil {
+		t.Fatal("expected error for bad port in bracketed IPv6")
+	}
+}
+
+func TestParseHostSpecIPv6BracketBadFormat(t *testing.T) {
+	_, err := parseHostSpec("[::1")
+	if err == nil {
+		t.Fatal("expected error for malformed bracketed IPv6")
+	}
+}
+
+func TestParseHostSpecColonEmptyHost(t *testing.T) {
+	_, err := parseHostSpec(":22")
+	if err == nil {
+		t.Fatal("expected error for empty host with port")
+	}
+}

cmd/root_test.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"errors"
 	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 
@@ -322,3 +323,50 @@ func TestExecuteAppliesGlobalUserToHostAndJumpSpecs(t *testing.T) {
 		t.Fatalf("expected 2 resolve calls, got %d", call)
 	}
 }
+
+func TestInitConfigWithNonExistentFile(t *testing.T) {
+	prevCfgFile := cfgFile
+	t.Cleanup(func() {
+		cfgFile = prevCfgFile
+		viper.Reset()
+	})
+
+	cfgFile = "/tmp/pretty-test-nonexistent-config-file.yaml"
+	viper.Reset()
+
+	// Should not panic even though the file doesn't exist.
+	initConfig()
+
+	// ReadInConfig silently fails, so viper should have no config file used.
+	if used := viper.ConfigFileUsed(); used != "" {
+		// When the file doesn't exist, ConfigFileUsed may still return the
+		// path that was set, but ReadInConfig should have returned an error
+		// (handled silently). Just verify no panic occurred.
+	}
+}
+
+func TestInitConfigWithExistingFile(t *testing.T) {
+	prevCfgFile := cfgFile
+	t.Cleanup(func() {
+		cfgFile = prevCfgFile
+		viper.Reset()
+	})
+
+	dir := t.TempDir()
+	configPath := filepath.Join(dir, "test-pretty.yaml")
+	if err := os.WriteFile(configPath, []byte("username: testuser\nhistory_file: /tmp/test.history\n"), 0644); err != nil {
+		t.Fatalf("unexpected write error: %v", err)
+	}
+
+	viper.Reset()
+	cfgFile = configPath
+
+	initConfig()
+
+	if got := viper.GetString("username"); got != "testuser" {
+		t.Fatalf("expected username 'testuser', got %q", got)
+	}
+	if got := viper.GetString("history_file"); got != "/tmp/test.history" {
+		t.Fatalf("expected history_file '/tmp/test.history', got %q", got)
+	}
+}