7b2d41cda8
Some checks failed
CI Docker Mining Proof / Linux agent hashrate proof (push) Has been cancelled
117 lines
3.3 KiB
Go
117 lines
3.3 KiB
Go
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)
|
|
}
|
|
}
|