327 lines
8.7 KiB
Go
327 lines
8.7 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 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 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)
|
|
}
|
|
}
|