fix TestTryKillOne to be platform-agnostic

Author: bobsira

cmd/minikube/cmd/delete.go

@@ -22,10 +22,8 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"runtime"
 	"strconv"
 	"strings"
-	"syscall"
 	"time"
 
 	"github.com/docker/machine/libmachine/mcnerror"
@@ -676,22 +674,9 @@ func trySigKillProcess(pid int) error {
 	}
 
 	klog.Infof("Killing pid %d ...", pid)
-	// On non-Windows try to send SIGUP first (graceful), fallback to kill if signaling fails.
-	// Use numeric syscall.Signal(1) (SIGUP) to avoid referencing platform-specific constant names.
-	if runtime.GOOS != "windows" {
-		if err := proc.Signal(syscall.Signal(1)); err != nil {
-			klog.Infof("SIGUP failed with %v - falling back to kill...", err)
-			if err := proc.Kill(); err != nil {
-				klog.Infof("Kill failed with %v - removing probably stale pid...", err)
-				return errors.Wrapf(err, "removing likely stale unkillable pid: %d", pid)
-			}
-		}
-	} else {
-		// On Windows, Signal is not meaningful, so we just kill the process
-		if err := proc.Kill(); err != nil {
-			klog.Infof("Kill failed with %v - removing probably stale pid...", err)
-			return errors.Wrapf(err, "removing likely stale unkillable pid: %d", pid)
-		}
+	if err := proc.Kill(); err != nil {
+		klog.Infof("Kill failed with %v - removing probably stale pid...", err)
+		return errors.Wrapf(err, "removing likely stale unkillable pid: %d", pid)
 	}
 
 	return nil

cmd/minikube/cmd/delete_test.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"runtime"
 	"testing"
 
 	"github.com/docker/machine/libmachine"
@@ -32,6 +31,7 @@ import (
 	cmdcfg "k8s.io/minikube/cmd/minikube/cmd/config"
 	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/localpath"
+	"k8s.io/minikube/pkg/minikube/process"
 )
 
 // exclude returns a list of strings, minus the excluded ones
@@ -242,7 +242,7 @@ func main() {
 	done := make(chan struct{})
 	defer close(ch)
 
-	signal.Notify(ch, syscall.SIGHUP)
+	signal.Notify(ch, syscall.SIGTERM)
 	defer signal.Stop(ch)
 
 	go func() {
@@ -263,7 +263,7 @@ func main() {
 	processToKill := exec.Command("go", "run", tmpfile)
 	err := processToKill.Start()
 	if err != nil {
-		t.Fatalf("while execing child process: %v\n", err)
+		t.Fatalf("while executing child process: %v\n", err)
 	}
 	pid := processToKill.Process.Pid
 
@@ -278,16 +278,11 @@ func main() {
 
 	// waiting for process to exit
 	waitErr := processToKill.Wait()
-	if runtime.GOOS == "windows" {
-		// Windows Wait commonly returns a non-nil error (exit status).
-		// Expect a non-nil Wait error on Windows; fail if we got nil.
-		if waitErr == nil {
-			t.Fatalf("expected non-nil Wait error on windows, got nil")
-		}
-	} else {
-		// On POSIX we signal SIGHUP — child should exit cleanly.
-		if waitErr != nil {
-			t.Fatalf("unable to kill process: %v\n", waitErr)
-		}
+	exists, err := process.ExistsPID(pid)
+	if err != nil {
+		t.Fatalf("error checking process existence for pid %d: %v", pid, err)
+	}
+	if exists {
+		t.Fatalf("process %d still exists after trySigKillProcess; waitErr=%v", pid, waitErr)
 	}
 }

pkg/minikube/process/process.go

@@ -73,6 +73,20 @@ func Exists(pid int, executable string) (bool, error) {
 	return entry.Executable() == executable, nil
 }
 
+// ExistsPID reports whether a process with the given pid exists.
+// This is a PID-only check (no executable name matching).
+func ExistsPID(pid int) (bool, error) {
+	if pid <= 0 {
+		return false, nil
+	}
+
+	entry, err := ps.FindProcess(pid)
+	if err != nil {
+		return true, err
+	}
+	return entry != nil, nil
+}
+
 // Terminate a process with pid and matching name. Returns os.ErrProcessDone if
 // the process does not exist, or nil if termination was requested. Caller need
 // to wait until the process disappears.