fix: stabilize mac rc gate tests

Author: julianknutsen

cmd/gc/cmd_citystatus_test.go

@@ -488,7 +488,10 @@ func TestControllerStatusForCityPrefersRegisteredSupervisorState(t *testing.T) {
 		t.Fatalf("register city: %v", err)
 	}
 
-	sockPath := filepath.Join(cityPath, ".gc", "controller.sock")
+	sockPath := controllerSocketPath(cityPath)
+	if err := os.MkdirAll(filepath.Dir(sockPath), 0o755); err != nil {
+		t.Fatal(err)
+	}
 	lis, err := net.Listen("unix", sockPath)
 	if err != nil {
 		t.Fatal(err)
@@ -540,7 +543,10 @@ func TestControllerStatusForCityFallsBackToStandaloneWhenRegisteredSupervisorDow
 		t.Fatalf("register city: %v", err)
 	}
 
-	sockPath := filepath.Join(cityPath, ".gc", "controller.sock")
+	sockPath := controllerSocketPath(cityPath)
+	if err := os.MkdirAll(filepath.Dir(sockPath), 0o755); err != nil {
+		t.Fatal(err)
+	}
 	lis, err := net.Listen("unix", sockPath)
 	if err != nil {
 		t.Fatal(err)
@@ -627,7 +633,10 @@ func TestControllerStatusForCityFallsBackToStandaloneWhenSupervisorVanishesDurin
 		t.Fatalf("register city: %v", err)
 	}
 
-	sockPath := filepath.Join(cityPath, ".gc", "controller.sock")
+	sockPath := controllerSocketPath(cityPath)
+	if err := os.MkdirAll(filepath.Dir(sockPath), 0o755); err != nil {
+		t.Fatal(err)
+	}
 	lis, err := net.Listen("unix", sockPath)
 	if err != nil {
 		t.Fatal(err)

cmd/gc/cmd_register_test.go

@@ -43,8 +43,9 @@ func TestDoRegister(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	// Registry.Register resolves symlinks (e.g. /var → /private/var on macOS).
-	resolvedCityPath, _ := filepath.EvalSymlinks(cityPath)
+	// Registry.Register stores the same canonical comparison form used by
+	// runtime path comparisons.
+	resolvedCityPath := canonicalTestPath(cityPath)
 	if len(entries) != 1 || entries[0].Path != resolvedCityPath {
 		t.Errorf("expected 1 entry at %s, got %v", resolvedCityPath, entries)
 	}

cmd/gc/cmd_supervisor_city_test.go

@@ -329,9 +329,9 @@ func TestRegisterCityWithSupervisorWaitsForConfiguredStartupTimeout(t *testing.T
 	if err != nil {
 		t.Fatal(err)
 	}
-	// Registry.Register resolves symlinks (e.g. /var → /private/var on macOS),
-	// so compare against the resolved path.
-	resolvedCityPath, _ := filepath.EvalSymlinks(cityPath)
+	// Registry.Register stores the same canonical comparison form used by
+	// runtime path comparisons.
+	resolvedCityPath := canonicalTestPath(cityPath)
 	if len(entries) != 1 || entries[0].Path != resolvedCityPath {
 		t.Fatalf("expected retained registry entry for %s, got %v", resolvedCityPath, entries)
 	}
@@ -792,9 +792,9 @@ func TestUnregisterCityFromSupervisorRestoresRegistrationOnReloadFailure(t *test
 	if err != nil {
 		t.Fatal(err)
 	}
-	// Registry.Register resolves symlinks (e.g. /var → /private/var on macOS),
-	// so compare against the resolved path.
-	resolvedCityPath, _ := filepath.EvalSymlinks(cityPath)
+	// Registry.Register stores the same canonical comparison form used by
+	// runtime path comparisons.
+	resolvedCityPath := canonicalTestPath(cityPath)
 	if len(entries) != 1 || entries[0].Path != resolvedCityPath {
 		t.Fatalf("expected restored registry entry for %s, got %v", resolvedCityPath, entries)
 	}
@@ -1028,7 +1028,7 @@ func TestUnregisterCityFromSupervisorRestoresRegistrationWhenControllerStopWaitF
 	if err != nil {
 		t.Fatal(err)
 	}
-	resolvedCityPath, _ := filepath.EvalSymlinks(cityPath)
+	resolvedCityPath := canonicalTestPath(cityPath)
 	if len(entries) != 1 || entries[0].Path != resolvedCityPath {
 		t.Fatalf("expected restored registry entry for %s, got %v", resolvedCityPath, entries)
 	}

cmd/gc/dolt_process_inspection.go

@@ -156,19 +156,41 @@ func cwdFromPlainLsofOutput(output string) (string, bool) {
 
 func deletedDataInodeTargetsFromFormattedLsofOutput(output string) []string {
 	var targets []string
-	for _, line := range strings.Split(output, "\n") {
-		if !strings.HasPrefix(line, "n") {
-			continue
+	var currentName string
+	currentDeleted := false
+	flush := func() {
+		if currentName != "" && currentDeleted {
+			targets = append(targets, currentName)
 		}
-		target := strings.TrimSpace(strings.TrimPrefix(line, "n"))
-		if !strings.Contains(target, " (deleted)") {
+		currentName = ""
+		currentDeleted = false
+	}
+
+	for _, line := range strings.Split(output, "\n") {
+		if line == "" {
 			continue
 		}
-		target = strings.TrimSuffix(target, " (deleted)")
-		if target != "" {
-			targets = append(targets, target)
+		switch line[0] {
+		case 'f':
+			flush()
+		case 'l':
+			links := strings.TrimSpace(strings.TrimPrefix(line, "l"))
+			if links == "0" {
+				currentDeleted = true
+			}
+		case 'n':
+			if currentName != "" {
+				flush()
+			}
+			target := strings.TrimSpace(strings.TrimPrefix(line, "n"))
+			if strings.Contains(target, " (deleted)") {
+				currentDeleted = true
+				target = strings.TrimSuffix(target, " (deleted)")
+			}
+			currentName = target
 		}
 	}
+	flush()
 	return targets
 }
 
@@ -272,7 +294,7 @@ func deletedDataInodeTargetsFromLsof(pid int) []string {
 }
 
 func deletedDataInodeTargetsFromFormattedLsof(pid int) []string {
-	out, err := lsofOutput(2*time.Second, "-p", strconv.Itoa(pid), "+L1", "-Fn")
+	out, err := lsofOutput(2*time.Second, "-p", strconv.Itoa(pid), "+L1", "-Fnl")
 	if err != nil {
 		return nil
 	}

cmd/gc/dolt_process_inspection_test.go

@@ -122,3 +122,13 @@ func TestDeletedDataInodeTargetsFromFormattedLsofIgnoresLiveNameRecords(t *testi
 		t.Fatalf("deletedDataInodeTargetsFromFormattedLsofOutput returned live targets: %#v", targets)
 	}
 }
+
+func TestDeletedDataInodeTargetsFromFormattedLsofUsesZeroLinkCount(t *testing.T) {
+	targets := deletedDataInodeTargetsFromFormattedLsofOutput("p123\nf4\nn/private/tmp/gc-city/.beads/dolt/held.db\nl0\n")
+	if len(targets) != 1 {
+		t.Fatalf("deletedDataInodeTargetsFromFormattedLsofOutput returned %d targets, want 1: %#v", len(targets), targets)
+	}
+	if !samePath(targets[0], "/tmp/gc-city/.beads/dolt/held.db") {
+		t.Fatalf("target = %q, want held.db", targets[0])
+	}
+}

internal/pidutil/pidutil.go

@@ -4,6 +4,7 @@ package pidutil
 import (
 	"errors"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -22,11 +23,20 @@ func Alive(pid int) bool {
 	statPath := filepath.Join("/proc", strconv.Itoa(pid), "stat")
 	data, err := os.ReadFile(statPath)
 	if err != nil {
-		return true
+		return !psReportsZombie(pid)
 	}
 	fields := strings.Fields(string(data))
 	if len(fields) >= 3 && fields[2] == "Z" {
 		return false
 	}
 	return true
 }
+
+func psReportsZombie(pid int) bool {
+	out, err := exec.Command("ps", "-o", "stat=", "-p", strconv.Itoa(pid)).Output()
+	if err != nil {
+		return false
+	}
+	state := strings.TrimSpace(string(out))
+	return strings.HasPrefix(state, "Z")
+}

internal/supervisor/registry_test.go

@@ -41,9 +41,9 @@ func TestRegistryRegisterAndList(t *testing.T) {
 	if len(entries) != 1 {
 		t.Fatalf("expected 1 entry, got %d", len(entries))
 	}
-	// Register canonicalizes via filepath.EvalSymlinks; resolve expected
-	// path so the comparison holds on macOS (/var → /private/var).
-	wantCity, _ := filepath.EvalSymlinks(cityPath)
+	// Register stores the same canonical comparison form used by runtime
+	// path comparisons.
+	wantCity := testutil.CanonicalPath(cityPath)
 	if entries[0].Path != wantCity {
 		t.Errorf("expected path %s, got %s", wantCity, entries[0].Path)
 	}
@@ -168,9 +168,9 @@ func TestRegistryMultipleCities(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	// Register canonicalizes via filepath.EvalSymlinks; resolve expected
-	// path so the comparison holds on macOS (/var → /private/var).
-	wantPath2, _ := filepath.EvalSymlinks(path2)
+	// Register stores the same canonical comparison form used by runtime
+	// path comparisons.
+	wantPath2 := testutil.CanonicalPath(path2)
 	if len(entries) != 1 || entries[0].Path != wantPath2 {
 		t.Errorf("expected only city-b, got %v", entries)
 	}

internal/worker/workertest/phase2_fake_worker_test.go

@@ -33,7 +33,7 @@ var (
 
 const (
 	fakeStartupGateTimeout         = 2 * time.Second
-	fakeStartupLaunchBound         = 500 * time.Millisecond
+	fakeStartupLaunchBound         = 750 * time.Millisecond
 	fakeStartupPostControlOverhead = 250 * time.Millisecond
 	fakeInteractionSignalBound     = 2 * time.Second
 )