cover failure paths, CLI, and builders; remove dead code

Author: atterpac

engine/errorpaths_test.go

@@ -0,0 +1,57 @@
+package engine
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestNewEngineFromTOMLErrors(t *testing.T) {
+	t.Run("missing file", func(t *testing.T) {
+		if _, err := NewEngineFromTOML(filepath.Join(t.TempDir(), "nope.toml")); err == nil {
+			t.Fatal("expected error for missing TOML file")
+		}
+	})
+	t.Run("malformed", func(t *testing.T) {
+		path := filepath.Join(t.TempDir(), "bad.toml")
+		if err := os.WriteFile(path, []byte("[unterminated"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := NewEngineFromTOML(path); err == nil {
+			t.Fatal("expected error for malformed TOML")
+		}
+	})
+}
+
+func TestNewEngineFromYAMLErrors(t *testing.T) {
+	t.Run("missing file", func(t *testing.T) {
+		if _, err := NewEngineFromYAML(filepath.Join(t.TempDir(), "nope.yaml")); err == nil {
+			t.Fatal("expected error for missing YAML file")
+		}
+	})
+	t.Run("malformed", func(t *testing.T) {
+		path := filepath.Join(t.TempDir(), "bad.yaml")
+		if err := os.WriteFile(path, []byte("a: b: c"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := NewEngineFromYAML(path); err == nil {
+			t.Fatal("expected error for malformed YAML")
+		}
+	})
+}
+
+func TestNewEngineFromConfigRequiresRootPath(t *testing.T) {
+	if _, err := NewEngineFromConfig(Config{ExecStruct: []Execute{{Cmd: "x", Type: Primary}}}); err == nil {
+		t.Fatal("expected error when RootPath is empty")
+	}
+}
+
+func TestStringToConfigInvalid(t *testing.T) {
+	e := &Engine{}
+	if err := e.StringtoConfigTOML("= 1"); err == nil {
+		t.Error("expected error for invalid TOML string")
+	}
+	if err := e.StringtoConfigYAML("a: b: c"); err == nil {
+		t.Error("expected error for invalid YAML string")
+	}
+}

engine/logger_test.go

@@ -63,6 +63,27 @@ func TestDisableEnableLogs(t *testing.T) {
 	}
 }
 
+// TestSwitchHandlerWithAttrsAndGroup ensures the level/enabled switch is
+// preserved through derived handlers created by With and WithGroup.
+func TestSwitchHandlerWithAttrsAndGroup(t *testing.T) {
+	var buf bytes.Buffer
+	d := newCapture("info", &buf)
+
+	derived := d.logger.With("component", "engine").WithGroup("scope")
+	derived.Info("ready", "id", 1)
+	if !strings.Contains(buf.String(), "component=engine") || !strings.Contains(buf.String(), "scope.id=1") {
+		t.Errorf("attrs/group not propagated: %q", buf.String())
+	}
+
+	// The shared enabled switch must still gate derived handlers.
+	buf.Reset()
+	d.Disable()
+	derived.Error("suppressed")
+	if buf.Len() != 0 {
+		t.Errorf("derived handler ignored Disable: %q", buf.String())
+	}
+}
+
 func TestMuteLevelDisablesOutput(t *testing.T) {
 	var buf bytes.Buffer
 	d := newCapture("mute", &buf)
@@ -78,4 +99,12 @@ func TestMuteLevelDisablesOutput(t *testing.T) {
 	if !strings.Contains(buf.String(), "recovered") {
 		t.Errorf("output not restored after leaving mute: %q", buf.String())
 	}
+
+	// SetLevel("mute") at runtime must also disable output.
+	buf.Reset()
+	d.SetLevel("mute")
+	d.logger.Error("muted-again")
+	if buf.Len() != 0 {
+		t.Errorf("SetLevel(\"mute\") did not disable output: %q", buf.String())
+	}
 }

process/process_test.go

@@ -5,6 +5,7 @@ package process
 import (
 	"context"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"syscall"
 	"testing"
@@ -124,6 +125,29 @@ func TestShellFeaturesAreSupported(t *testing.T) {
 	}
 }
 
+func TestKillProcessTreeNilSafe(t *testing.T) {
+	if err := killProcessTree(nil); err != nil {
+		t.Errorf("killProcessTree(nil) = %v, want nil", err)
+	}
+	if err := killProcessTree(&exec.Cmd{}); err != nil {
+		t.Errorf("killProcessTree on unstarted cmd = %v, want nil", err)
+	}
+}
+
+func TestSetRootDirectoryDefaultsToCwd(t *testing.T) {
+	pm := NewProcessManager()
+	if err := pm.SetRootDirectory(""); err != nil {
+		t.Fatalf("SetRootDirectory(\"\"): %v", err)
+	}
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if pm.RootDir != wd {
+		t.Errorf("RootDir = %q, want cwd %q", pm.RootDir, wd)
+	}
+}
+
 func TestStartWithNoProcessesErrors(t *testing.T) {
 	pm := NewProcessManager()
 	if err := pm.Start(context.Background()); err == nil {