feba06e008
Persist build extra_files for Build Manager history, print dashboard login on every start, add libp2p for Mesh P2P forge, defer WebSocket until login, and split devrun.bat from LAUNCH.bat with USB deck auto-detection.
249 lines
6.8 KiB
Go
249 lines
6.8 KiB
Go
package miner
|
|
|
|
import (
|
|
"encoding/json"
|
|
"testing"
|
|
|
|
"crypto-miner-agent/config"
|
|
)
|
|
|
|
func TestBuildStratumEndpointsPrimaryOnly(t *testing.T) {
|
|
cfg := config.RuntimeConfig{BuiltinConfig: config.BuiltinConfig{
|
|
PoolHost: "pool.example.com",
|
|
PoolPort: 3333,
|
|
PoolTLS: true,
|
|
PoolPass: "secret",
|
|
}}
|
|
eps := buildStratumEndpoints(cfg)
|
|
if len(eps) != 1 {
|
|
t.Fatalf("expected 1 endpoint, got %d", len(eps))
|
|
}
|
|
if eps[0].Host != "pool.example.com" || eps[0].Port != 3333 || !eps[0].TLS || eps[0].Pass != "secret" {
|
|
t.Fatalf("primary endpoint mismatch: %+v", eps[0])
|
|
}
|
|
}
|
|
|
|
func TestBuildStratumEndpointsSkipsInvalidBackups(t *testing.T) {
|
|
cfg := config.RuntimeConfig{BuiltinConfig: config.BuiltinConfig{
|
|
PoolHost: "primary.pool",
|
|
PoolPort: 4444,
|
|
BackupPools: []config.BackupPool{
|
|
{Host: "", Port: 5555},
|
|
{Host: "backup.pool", Port: 0},
|
|
{Host: "good.backup", Port: 6666, TLS: true, Pass: "bp"},
|
|
},
|
|
}}
|
|
eps := buildStratumEndpoints(cfg)
|
|
if len(eps) != 2 {
|
|
t.Fatalf("expected primary + 1 valid backup, got %d", len(eps))
|
|
}
|
|
if eps[1].Host != "good.backup" || eps[1].Port != 6666 || !eps[1].TLS || eps[1].Pass != "bp" {
|
|
t.Fatalf("backup endpoint mismatch: %+v", eps[1])
|
|
}
|
|
}
|
|
|
|
func TestMustMarshal(t *testing.T) {
|
|
raw := mustMarshal(map[string]string{"login": "wallet", "pass": "x"})
|
|
var m map[string]string
|
|
if err := json.Unmarshal(raw, &m); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if m["login"] != "wallet" || m["pass"] != "x" {
|
|
t.Fatalf("unexpected map: %v", m)
|
|
}
|
|
}
|
|
|
|
func TestStratumMsgLoginRoundTrip(t *testing.T) {
|
|
params := mustMarshal(map[string]interface{}{
|
|
"login": "4AbC...wallet",
|
|
"pass": "x",
|
|
"rigid": "worker-1",
|
|
"agent": "AetherForge/1.0.0",
|
|
})
|
|
msg := stratumMsg{
|
|
ID: 1,
|
|
JSONRPC: "2.0",
|
|
Method: "login",
|
|
Params: params,
|
|
}
|
|
b, err := json.Marshal(msg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var decoded stratumMsg
|
|
if err := json.Unmarshal(b, &decoded); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if decoded.Method != "login" || decoded.JSONRPC != "2.0" {
|
|
t.Fatalf("decoded msg: %+v", decoded)
|
|
}
|
|
var p map[string]interface{}
|
|
if err := json.Unmarshal(decoded.Params, &p); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if p["login"] != "4AbC...wallet" || p["pass"] != "x" {
|
|
t.Fatalf("params: %v", p)
|
|
}
|
|
}
|
|
|
|
func TestStratumJobUnmarshal(t *testing.T) {
|
|
raw := `{"blob":"aabb","job_id":"j1","target":"ffff","seed_hash":"ccdd","height":12345}`
|
|
var sj stratumJob
|
|
if err := json.Unmarshal([]byte(raw), &sj); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if sj.Blob != "aabb" || sj.JobID != "j1" || sj.Target != "ffff" || sj.SeedHash != "ccdd" || sj.Height != 12345 {
|
|
t.Fatalf("job mismatch: %+v", sj)
|
|
}
|
|
}
|
|
|
|
func TestLoginResultUnmarshal(t *testing.T) {
|
|
raw := `{"id":"sess-1","status":"OK","job":{"blob":"deadbeef","job_id":"42","target":"ffffffff","seed_hash":"seed","height":1}}`
|
|
var lr loginResult
|
|
if err := json.Unmarshal([]byte(raw), &lr); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if lr.ID != "sess-1" || lr.Status != "OK" || lr.Job == nil || lr.Job.JobID != "42" {
|
|
t.Fatalf("login result mismatch: %+v", lr)
|
|
}
|
|
}
|
|
|
|
func TestSubmitParamsMarshal(t *testing.T) {
|
|
b, err := json.Marshal(submitParams{
|
|
ID: "sess-1",
|
|
JobID: "42",
|
|
Nonce: "01020304",
|
|
Hash: "abc123",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var m map[string]string
|
|
if err := json.Unmarshal(b, &m); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if m["id"] != "sess-1" || m["job_id"] != "42" || m["nonce"] != "01020304" || m["result"] != "abc123" {
|
|
t.Fatalf("submit params field names: %v", m)
|
|
}
|
|
}
|
|
|
|
func TestStratumMsgJobNotification(t *testing.T) {
|
|
params, _ := json.Marshal(stratumJob{
|
|
Blob: "blobhex", JobID: "99", Target: "targethex", SeedHash: "seedhex", Height: 100,
|
|
})
|
|
line := mustMarshal(stratumMsg{Method: "job", Params: params})
|
|
var msg stratumMsg
|
|
if err := json.Unmarshal(line, &msg); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if msg.Method != "job" {
|
|
t.Fatalf("method=%q", msg.Method)
|
|
}
|
|
var sj stratumJob
|
|
if err := json.Unmarshal(msg.Params, &sj); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if sj.JobID != "99" || sj.Blob != "blobhex" {
|
|
t.Fatalf("job notification: %+v", sj)
|
|
}
|
|
}
|
|
|
|
func TestBuildStratumEndpointsMultipleBackups(t *testing.T) {
|
|
cfg := config.RuntimeConfig{BuiltinConfig: config.BuiltinConfig{
|
|
PoolHost: "primary.pool",
|
|
PoolPort: 3333,
|
|
BackupPools: []config.BackupPool{
|
|
{Host: "backup1.pool", Port: 4444, Pass: "a"},
|
|
{Host: "backup2.pool", Port: 5555, TLS: true},
|
|
},
|
|
}}
|
|
eps := buildStratumEndpoints(cfg)
|
|
if len(eps) != 3 {
|
|
t.Fatalf("expected primary + 2 backups, got %d", len(eps))
|
|
}
|
|
if eps[2].Host != "backup2.pool" || eps[2].Port != 5555 || !eps[2].TLS {
|
|
t.Fatalf("third endpoint mismatch: %+v", eps[2])
|
|
}
|
|
}
|
|
|
|
func TestStratumLoginErrorResponse(t *testing.T) {
|
|
line := `{"id":1,"jsonrpc":"2.0","error":{"code":-1,"message":"invalid wallet"}}`
|
|
var loginResp stratumMsg
|
|
if err := json.Unmarshal([]byte(line), &loginResp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if loginResp.Error == nil {
|
|
t.Fatal("expected login error field")
|
|
}
|
|
if loginResp.Result != nil {
|
|
t.Fatal("error response should not carry a result")
|
|
}
|
|
}
|
|
|
|
func TestStratumKeepaliveMsgRoundTrip(t *testing.T) {
|
|
params := mustMarshal(map[string]string{"id": "sess-abc"})
|
|
msg := stratumMsg{ID: 3, JSONRPC: "2.0", Method: "keepalived", Params: params}
|
|
b, err := json.Marshal(msg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var decoded stratumMsg
|
|
if err := json.Unmarshal(b, &decoded); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if decoded.Method != "keepalived" || decoded.JSONRPC != "2.0" {
|
|
t.Fatalf("keepalive msg: %+v", decoded)
|
|
}
|
|
var p map[string]string
|
|
if err := json.Unmarshal(decoded.Params, &p); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if p["id"] != "sess-abc" {
|
|
t.Fatalf("keepalive params: %v", p)
|
|
}
|
|
}
|
|
|
|
func TestStratumSubmitRequestRoundTrip(t *testing.T) {
|
|
params, err := json.Marshal(submitParams{
|
|
ID: "sess-1", JobID: "42", Nonce: "04030201", Hash: "deadbeef",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
msg := stratumMsg{ID: 4, JSONRPC: "2.0", Method: "submit", Params: params}
|
|
b, err := json.Marshal(msg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var decoded stratumMsg
|
|
if err := json.Unmarshal(b, &decoded); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if decoded.Method != "submit" {
|
|
t.Fatalf("method=%q", decoded.Method)
|
|
}
|
|
var sp submitParams
|
|
if err := json.Unmarshal(decoded.Params, &sp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if sp.ID != "sess-1" || sp.JobID != "42" || sp.Nonce != "04030201" || sp.Hash != "deadbeef" {
|
|
t.Fatalf("submit params: %+v", sp)
|
|
}
|
|
}
|
|
|
|
func TestStratumJobParamsInvalidJSON(t *testing.T) {
|
|
msg := stratumMsg{Method: "job", Params: json.RawMessage(`{"blob":`)}
|
|
var sj stratumJob
|
|
if err := json.Unmarshal(msg.Params, &sj); err == nil {
|
|
t.Fatal("malformed job params should fail unmarshal")
|
|
}
|
|
}
|
|
|
|
func TestStratumLineInvalidJSONIgnored(t *testing.T) {
|
|
line := "not-json\n"
|
|
var msg stratumMsg
|
|
if err := json.Unmarshal([]byte(line), &msg); err == nil {
|
|
t.Fatal("invalid stratum line should not parse as msg")
|
|
}
|
|
}
|