Files
dygou_go/internal/remote/remote_test.go
T
yml 9c83be798d feat: 优化代理准备并完善远端部署
- 增加严格代理、两分钟预取、白名单去重与分组状态展示\n- 增加远端注册令牌和安全地址校验\n- 增加 Docker Compose、Caddy 示例与控制中心部署文档
2026-11-21 20:59:35 +08:00

394 lines
10 KiB
Go

package remote
import (
"bytes"
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"testing"
"time"
"douyu_go/internal/types"
)
func TestLoadOrCreateMachineIDSharedByInstances(t *testing.T) {
root := t.TempDir()
defaultDir := root
instanceDir := filepath.Join(root, "instances", "instance-2")
if err := os.MkdirAll(instanceDir, 0o700); err != nil {
t.Fatal(err)
}
first, err := LoadOrCreateMachineID(defaultDir)
if err != nil {
t.Fatal(err)
}
second, err := LoadOrCreateMachineID(instanceDir)
if err != nil {
t.Fatal(err)
}
if first != second {
t.Fatalf("machine id differs: %q != %q", first, second)
}
}
func TestValidateServerURLRequiresControlCenterRoot(t *testing.T) {
for _, raw := range []string{
"https://control.example.com/#admin=secret",
"https://control.example.com/control",
"https://control.example.com/?token=secret",
"https://user:pass@control.example.com",
} {
if err := ValidateServerURL(raw); err == nil {
t.Fatalf("ValidateServerURL(%q) should fail", raw)
}
}
for _, raw := range []string{
"https://control.example.com",
"https://control.example.com/",
"http://127.0.0.1:18080",
"wss://control.example.com",
} {
if err := ValidateServerURL(raw); err != nil {
t.Fatalf("ValidateServerURL(%q): %v", raw, err)
}
}
}
func TestEventSpoolPersistsOffset(t *testing.T) {
dir := t.TempDir()
spool, err := NewEventSpool(dir)
if err != nil {
t.Fatal(err)
}
event := LogEvent{MachineID: "m", InstanceID: "i", StreamID: "s", Sequence: 1, Message: "hello"}
if !spool.Enqueue(event) {
t.Fatal("event was not queued")
}
events, next, err := readSpoolEventually(spool, 1)
if err != nil {
t.Fatal(err)
}
if len(events) != 1 || events[0].Message != "hello" {
t.Fatalf("events = %#v", events)
}
spool.Ack(next)
if err := spool.Close(); err != nil {
t.Fatal(err)
}
reopened, err := NewEventSpool(dir)
if err != nil {
t.Fatal(err)
}
defer reopened.Close()
events, _, err = reopened.ReadPending(10)
if err != nil {
t.Fatal(err)
}
if len(events) != 0 {
t.Fatalf("acknowledged events replayed: %#v", events)
}
}
func TestAgentServerRoundTripAndCommand(t *testing.T) {
server, err := NewServer(ServerOptions{
DataDir: t.TempDir(),
AgentToken: "agent-token",
OperatorToken: "operator-token",
})
if err != nil {
t.Fatal(err)
}
defer server.Close()
httpServer := httptest.NewServer(server.Handler())
defer httpServer.Close()
stopped := make(chan struct{}, 1)
agent, err := NewAgent(AgentOptions{
DataDir: t.TempDir(),
ServerURL: httpServer.URL,
Token: "agent-token",
MachineID: "machine-1",
MachineName: "PC-01",
InstanceID: "实例 2",
Instance: "实例 2",
Version: "test",
Snapshot: func() Snapshot {
return Snapshot{ActivityID: "peace", Results: map[string]string{"a": "成功|test"}}
},
Stop: func() error {
select {
case stopped <- struct{}{}:
default:
}
return nil
},
})
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
agent.Start(ctx)
defer agent.Close()
agent.SetState("running")
agent.Observe(types.LogEntry{Time: time.Now().Format("2006-01-02 15:04:05.000"), Level: "info", Category: "抢购", Account: "a", Message: "开始抢购"})
waitUntil(t, 5*time.Second, func() bool {
return len(server.hub.Dashboard().Instances) == 1
})
waitUntil(t, 5*time.Second, func() bool {
return len(server.hub.EventsSince(0, 10)) == 1
})
body := bytes.NewBufferString(`{"machineId":"machine-1","instanceId":"实例 2","type":"stop"}`)
request, err := http.NewRequest(http.MethodPost, httpServer.URL+"/api/command", body)
if err != nil {
t.Fatal(err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("X-Control-Token", "operator-token")
response, err := http.DefaultClient.Do(request)
if err != nil {
t.Fatal(err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
t.Fatalf("command status = %d", response.StatusCode)
}
select {
case <-stopped:
case <-time.After(5 * time.Second):
t.Fatal("stop command was not delivered")
}
agent.SetState("idle")
waitUntil(t, 5*time.Second, func() bool {
runs := server.hub.Dashboard().Runs
return len(runs) == 1 && !runs[0].Running
})
}
func TestDashboardRequiresOperatorToken(t *testing.T) {
server, err := NewServer(ServerOptions{DataDir: t.TempDir(), AgentToken: "a", OperatorToken: "operator"})
if err != nil {
t.Fatal(err)
}
defer server.Close()
httpServer := httptest.NewServer(server.Handler())
defer httpServer.Close()
response, err := http.Get(httpServer.URL + "/api/dashboard")
if err != nil {
t.Fatal(err)
}
response.Body.Close()
if response.StatusCode != http.StatusUnauthorized {
t.Fatalf("status = %d, want 401", response.StatusCode)
}
}
func TestAgentAutoEnrollsWithoutManualToken(t *testing.T) {
server, err := NewServer(ServerOptions{
DataDir: t.TempDir(),
OperatorToken: "operator-token",
EnrollWindow: time.Minute,
})
if err != nil {
t.Fatal(err)
}
defer server.Close()
httpServer := httptest.NewServer(server.Handler())
defer httpServer.Close()
dataDir := t.TempDir()
agent, err := NewAgent(AgentOptions{
DataDir: dataDir,
ServerURL: httpServer.URL,
MachineID: "machine-auto",
MachineName: "PC-AUTO",
InstanceID: "实例 3",
Instance: "实例 3",
Version: "test",
})
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
agent.Start(ctx)
defer agent.Close()
waitUntil(t, 5*time.Second, func() bool {
return len(server.hub.Dashboard().Instances) == 1
})
token, err := loadAgentCredential(dataDir, httpServer.URL, "machine-auto", "实例 3")
if err != nil {
t.Fatal(err)
}
if token == "" {
t.Fatal("auto enrollment did not save an instance token")
}
}
func TestAgentEnrollsWithConfiguredEnrollmentToken(t *testing.T) {
server, err := NewServer(ServerOptions{
DataDir: t.TempDir(),
OperatorToken: "operator-token",
EnrollToken: "enroll-secret",
})
if err != nil {
t.Fatal(err)
}
defer server.Close()
httpServer := httptest.NewServer(server.Handler())
defer httpServer.Close()
dataDir := t.TempDir()
agent, err := NewAgent(AgentOptions{
DataDir: dataDir,
ServerURL: httpServer.URL,
EnrollmentToken: "enroll-secret",
MachineID: "machine-secure",
MachineName: "PC-SECURE",
InstanceID: "实例 4",
Instance: "实例 4",
Version: "test",
})
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
agent.Start(ctx)
defer agent.Close()
waitUntil(t, 5*time.Second, func() bool {
instances := server.hub.Dashboard().Instances
return len(instances) == 1 && instances[0].Online
})
token, err := loadAgentCredential(dataDir, httpServer.URL, "machine-secure", "实例 4")
if err != nil {
t.Fatal(err)
}
if token == "" || token == "enroll-secret" {
t.Fatalf("unexpected issued instance token %q", token)
}
}
func TestHubAggregatesDynamicInstanceCount(t *testing.T) {
hub, err := NewHub(t.TempDir())
if err != nil {
t.Fatal(err)
}
defer hub.Close()
for _, id := range []string{"默认实例", "实例 2", "实例 3", "实例 5", "临时实例"} {
hub.ApplySnapshot(Snapshot{
MachineID: "machine-1",
MachineName: "PC-01",
InstanceID: id,
InstanceName: id,
State: "idle",
AccountCount: 10,
}, "127.0.0.1")
}
state := hub.Dashboard()
if len(state.Instances) != 5 {
t.Fatalf("instances = %d, want 5", len(state.Instances))
}
machines := make(map[string]struct{})
for _, instance := range state.Instances {
machines[instance.MachineID] = struct{}{}
}
if len(machines) != 1 {
t.Fatalf("machines = %d, want 1", len(machines))
}
}
func TestEventsCanBeFilteredByInstanceAndRun(t *testing.T) {
hub, err := NewHub(t.TempDir())
if err != nil {
t.Fatal(err)
}
defer hub.Close()
hub.AppendEvents([]LogEvent{
{MachineID: "m1", InstanceID: "i1", RunID: "r1", Message: "a"},
{MachineID: "m1", InstanceID: "i2", RunID: "r2", Message: "b"},
{MachineID: "m1", InstanceID: "i1", RunID: "r2", Message: "c"},
})
byInstance := hub.EventsSinceFiltered(0, 10, "m1", "i1", "")
if len(byInstance) != 2 {
t.Fatalf("by instance = %d, want 2", len(byInstance))
}
byRun := hub.EventsSinceFiltered(0, 10, "", "", "r2")
if len(byRun) != 2 {
t.Fatalf("by run = %d, want 2", len(byRun))
}
both := hub.EventsSinceFiltered(0, 10, "m1", "i1", "r2")
if len(both) != 1 || both[0].Message != "c" {
t.Fatalf("combined filter = %#v", both)
}
}
func TestExportEventsCSVAndJSON(t *testing.T) {
hub, err := NewHub(t.TempDir())
if err != nil {
t.Fatal(err)
}
defer hub.Close()
hub.AppendEvents([]LogEvent{
{MachineID: "m1", MachineName: "PC-1", InstanceID: "i1", InstanceName: "实例 1", RunID: "r1", Time: time.Now(), Category: "抢购", Level: "success", Account: "a", Message: "成功"},
{MachineID: "m2", MachineName: "PC-2", InstanceID: "i2", InstanceName: "实例 2", RunID: "r2", Time: time.Now(), Category: "抢购", Level: "warn", Account: "b", Message: "失败"},
})
var csvData bytes.Buffer
count, err := hub.ExportEvents(&csvData, "csv", EventExportFilter{MachineID: "m1"})
if err != nil {
t.Fatal(err)
}
if count != 1 || !bytes.Contains(csvData.Bytes(), []byte("machine_id")) || !bytes.Contains(csvData.Bytes(), []byte("PC-1")) {
t.Fatalf("csv export count=%d data=%s", count, csvData.String())
}
var jsonData bytes.Buffer
count, err = hub.ExportEvents(&jsonData, "json", EventExportFilter{Query: "失败"})
if err != nil {
t.Fatal(err)
}
if count != 1 || !bytes.Contains(jsonData.Bytes(), []byte(`"machineId":"m2"`)) {
t.Fatalf("json export count=%d data=%s", count, jsonData.String())
}
}
func readSpoolEventually(spool *EventSpool, want int) ([]LogEvent, int64, error) {
deadline := time.Now().Add(3 * time.Second)
for time.Now().Before(deadline) {
events, next, err := spool.ReadPending(10)
if err != nil || len(events) >= want {
return events, next, err
}
time.Sleep(20 * time.Millisecond)
}
return nil, 0, context.DeadlineExceeded
}
func waitUntil(t *testing.T, timeout time.Duration, condition func() bool) {
t.Helper()
deadline := time.Now().Add(timeout)
for time.Now().Before(deadline) {
if condition() {
return
}
time.Sleep(25 * time.Millisecond)
}
t.Fatal("condition was not met before timeout")
}
func TestEnvelopeJSON(t *testing.T) {
data, err := json.Marshal(Envelope{Type: MessageEvents, Events: []LogEvent{{Message: "x"}}})
if err != nil {
t.Fatal(err)
}
if !bytes.Contains(data, []byte(`"events"`)) {
t.Fatalf("json = %s", data)
}
}