513 lines
12 KiB
Go
513 lines
12 KiB
Go
package types
|
||
|
||
import (
|
||
"encoding/json"
|
||
"testing"
|
||
"time"
|
||
)
|
||
|
||
// =============================================================================
|
||
// 基础类型测试
|
||
// =============================================================================
|
||
|
||
func TestGenerateMessageID(t *testing.T) {
|
||
id := GenerateMessageID()
|
||
|
||
if id == "" {
|
||
t.Error("Message ID should not be empty")
|
||
}
|
||
|
||
// 验证格式(msg-前缀)
|
||
if !startsWith(id, "msg-") {
|
||
t.Errorf("Message ID should have msg- prefix: %s", id)
|
||
}
|
||
}
|
||
|
||
func TestGenerateTaskID(t *testing.T) {
|
||
id := GenerateTaskID()
|
||
|
||
if id == "" {
|
||
t.Error("Task ID should not be empty")
|
||
}
|
||
|
||
// 验证格式(task-前缀)
|
||
if !startsWith(id, "task-") {
|
||
t.Errorf("Task ID should have task- prefix: %s", id)
|
||
}
|
||
}
|
||
|
||
func TestNowTimestamp(t *testing.T) {
|
||
ts := NowTimestamp()
|
||
if ts == "" {
|
||
t.Error("Timestamp should not be empty")
|
||
}
|
||
|
||
// 验证可以解析为时间
|
||
parsed, err := ts.Time()
|
||
if err != nil {
|
||
t.Errorf("Failed to parse timestamp: %v", err)
|
||
}
|
||
|
||
// 验证时间接近当前时间
|
||
now := time.Now().UTC()
|
||
diff := now.Sub(parsed)
|
||
if diff > time.Minute || diff < -time.Minute {
|
||
t.Errorf("Timestamp difference too large: %v", diff)
|
||
}
|
||
}
|
||
|
||
func TestTimestampTime(t *testing.T) {
|
||
ts := Timestamp("2026-06-27T10:00:00Z")
|
||
parsed, err := ts.Time()
|
||
if err != nil {
|
||
t.Errorf("Failed to parse timestamp: %v", err)
|
||
}
|
||
|
||
expected := time.Date(2026, 6, 27, 10, 0, 0, 0, time.UTC)
|
||
if !parsed.Equal(expected) {
|
||
t.Errorf("Parsed time mismatch: got %v, want %v", parsed, expected)
|
||
}
|
||
}
|
||
|
||
// =============================================================================
|
||
// AgentEndpoint 测试
|
||
// =============================================================================
|
||
|
||
func TestAgentEndpointJSON(t *testing.T) {
|
||
ep := AgentEndpoint{
|
||
AgentID: "agent-001",
|
||
AgentName: "TestAgent",
|
||
SystemID: "system-001",
|
||
Endpoint: "http://localhost:8080",
|
||
Version: "1.0.0",
|
||
}
|
||
|
||
// 序列化
|
||
data, err := json.Marshal(ep)
|
||
if err != nil {
|
||
t.Errorf("Failed to marshal AgentEndpoint: %v", err)
|
||
}
|
||
|
||
// 反序列化
|
||
var parsed AgentEndpoint
|
||
if err := json.Unmarshal(data, &parsed); err != nil {
|
||
t.Errorf("Failed to unmarshal AgentEndpoint: %v", err)
|
||
}
|
||
|
||
if parsed.AgentID != ep.AgentID {
|
||
t.Errorf("AgentID mismatch: got %s, want %s", parsed.AgentID, ep.AgentID)
|
||
}
|
||
if parsed.Endpoint != ep.Endpoint {
|
||
t.Errorf("Endpoint mismatch: got %s, want %s", parsed.Endpoint, ep.Endpoint)
|
||
}
|
||
}
|
||
|
||
// =============================================================================
|
||
// UnifiedSynapseMessage 测试
|
||
// =============================================================================
|
||
|
||
func TestUnifiedSynapseMessageJSON(t *testing.T) {
|
||
receiver := &AgentEndpoint{
|
||
AgentID: "agent-002",
|
||
Endpoint: "http://localhost:8081",
|
||
}
|
||
|
||
msg := UnifiedSynapseMessage{
|
||
ID: GenerateMessageID(),
|
||
Version: "1.0.0",
|
||
Type: string(P2PTaskRequest),
|
||
Sender: AgentEndpoint{AgentID: "agent-001", Endpoint: "http://localhost:8080"},
|
||
Receiver: receiver,
|
||
Payload: json.RawMessage(`{"task": {"id": "task-001"}}`),
|
||
Timestamp: NowTimestamp(),
|
||
Priority: PriorityNormal,
|
||
}
|
||
|
||
// 序列化
|
||
data, err := json.Marshal(msg)
|
||
if err != nil {
|
||
t.Errorf("Failed to marshal message: %v", err)
|
||
}
|
||
|
||
// 反序列化
|
||
var parsed UnifiedSynapseMessage
|
||
if err := json.Unmarshal(data, &parsed); err != nil {
|
||
t.Errorf("Failed to unmarshal message: %v", err)
|
||
}
|
||
|
||
if parsed.ID != msg.ID {
|
||
t.Errorf("Message ID mismatch")
|
||
}
|
||
if parsed.Type != msg.Type {
|
||
t.Errorf("Message type mismatch: got %s, want %s", parsed.Type, msg.Type)
|
||
}
|
||
if parsed.Receiver.AgentID != receiver.AgentID {
|
||
t.Errorf("Receiver AgentID mismatch")
|
||
}
|
||
}
|
||
|
||
func TestUnifiedSynapseMessageGroupContext(t *testing.T) {
|
||
msg := UnifiedSynapseMessage{
|
||
ID: GenerateMessageID(),
|
||
Version: "1.0.0",
|
||
Type: string(GroupBroadcast),
|
||
Sender: AgentEndpoint{AgentID: "agent-001"},
|
||
GroupID: "group-001",
|
||
TargetType: "all",
|
||
Broadcast: true,
|
||
Payload: json.RawMessage(`{"message": "hello"}`),
|
||
Timestamp: NowTimestamp(),
|
||
}
|
||
|
||
data, err := json.Marshal(msg)
|
||
if err != nil {
|
||
t.Errorf("Failed to marshal group message: %v", err)
|
||
}
|
||
|
||
var parsed UnifiedSynapseMessage
|
||
if err := json.Unmarshal(data, &parsed); err != nil {
|
||
t.Errorf("Failed to unmarshal group message: %v", err)
|
||
}
|
||
|
||
if parsed.GroupID != "group-001" {
|
||
t.Errorf("GroupID mismatch: got %s, want group-001", parsed.GroupID)
|
||
}
|
||
if !parsed.Broadcast {
|
||
t.Error("Broadcast should be true")
|
||
}
|
||
}
|
||
|
||
// =============================================================================
|
||
// P2P Payload 测试
|
||
// =============================================================================
|
||
|
||
func TestTaskRequestPayloadJSON(t *testing.T) {
|
||
payload := TaskRequestPayload{}
|
||
payload.Task.ID = "task-001"
|
||
payload.Task.Type = "text_generation"
|
||
payload.Task.Priority = PriorityNormal
|
||
payload.Task.Payload = map[string]interface{}{
|
||
"prompt": "写一首诗",
|
||
}
|
||
|
||
data, err := json.Marshal(payload)
|
||
if err != nil {
|
||
t.Errorf("Failed to marshal TaskRequestPayload: %v", err)
|
||
}
|
||
|
||
var parsed TaskRequestPayload
|
||
if err := json.Unmarshal(data, &parsed); err != nil {
|
||
t.Errorf("Failed to unmarshal TaskRequestPayload: %v", err)
|
||
}
|
||
|
||
if parsed.Task.ID != "task-001" {
|
||
t.Errorf("Task ID mismatch")
|
||
}
|
||
if parsed.Task.Type != "text_generation" {
|
||
t.Errorf("Task type mismatch")
|
||
}
|
||
}
|
||
|
||
func TestTaskConfirmPayloadJSON(t *testing.T) {
|
||
payload := TaskConfirmPayload{
|
||
TaskID: "task-001",
|
||
Confirmed: true,
|
||
EstimatedDuration: 60,
|
||
ExpectedCompletion: NowTimestamp(),
|
||
CapabilitiesUsed: []string{"text_gen"},
|
||
}
|
||
|
||
data, err := json.Marshal(payload)
|
||
if err != nil {
|
||
t.Errorf("Failed to marshal TaskConfirmPayload: %v", err)
|
||
}
|
||
|
||
var parsed TaskConfirmPayload
|
||
if err := json.Unmarshal(data, &parsed); err != nil {
|
||
t.Errorf("Failed to unmarshal TaskConfirmPayload: %v", err)
|
||
}
|
||
|
||
if parsed.TaskID != "task-001" {
|
||
t.Errorf("TaskID mismatch")
|
||
}
|
||
if !payload.Confirmed {
|
||
t.Error("Confirmed should be true")
|
||
}
|
||
}
|
||
|
||
func TestTaskStatusUpdatePayloadJSON(t *testing.T) {
|
||
payload := TaskStatusUpdatePayload{
|
||
TaskID: "task-001",
|
||
Status: "executing",
|
||
Progress: 50,
|
||
Message: "Processing...",
|
||
}
|
||
|
||
data, err := json.Marshal(payload)
|
||
if err != nil {
|
||
t.Errorf("Failed to marshal TaskStatusUpdatePayload: %v", err)
|
||
}
|
||
|
||
var parsed TaskStatusUpdatePayload
|
||
if err := json.Unmarshal(data, &parsed); err != nil {
|
||
t.Errorf("Failed to unmarshal TaskStatusUpdatePayload: %v", err)
|
||
}
|
||
|
||
if parsed.Progress != 50 {
|
||
t.Errorf("Progress mismatch: got %d, want 50", parsed.Progress)
|
||
}
|
||
}
|
||
|
||
// =============================================================================
|
||
// Group Payload 测试
|
||
// =============================================================================
|
||
|
||
func TestGroupCreatePayloadJSON(t *testing.T) {
|
||
payload := GroupCreatePayload{}
|
||
payload.Group.Name = "TestGroup"
|
||
payload.Group.Topology = GroupTopologyStar
|
||
payload.Group.Config = GroupConfig{
|
||
AllowSelfLeave: true,
|
||
ConsensusRequired: false,
|
||
ConsensusThreshold: 0.5,
|
||
}
|
||
|
||
data, err := json.Marshal(payload)
|
||
if err != nil {
|
||
t.Errorf("Failed to marshal GroupCreatePayload: %v", err)
|
||
}
|
||
|
||
var parsed GroupCreatePayload
|
||
if err := json.Unmarshal(data, &parsed); err != nil {
|
||
t.Errorf("Failed to unmarshal GroupCreatePayload: %v", err)
|
||
}
|
||
|
||
if parsed.Group.Name != "TestGroup" {
|
||
t.Errorf("Group name mismatch")
|
||
}
|
||
if parsed.Group.Topology != GroupTopologyStar {
|
||
t.Errorf("Topology mismatch")
|
||
}
|
||
}
|
||
|
||
func TestGroupTaskSplitPayloadJSON(t *testing.T) {
|
||
payload := GroupTaskSplitPayload{}
|
||
payload.OriginalTask.ID = "task-001"
|
||
payload.OriginalTask.Type = "video_generation"
|
||
payload.Subtasks = []Subtask{
|
||
{
|
||
ID: "sub-001",
|
||
Description: "Generate scene 1",
|
||
AssignedTo: "agent-002",
|
||
Priority: 1,
|
||
},
|
||
{
|
||
ID: "sub-002",
|
||
Description: "Generate scene 2",
|
||
AssignedTo: "agent-003",
|
||
Priority: 2,
|
||
},
|
||
}
|
||
payload.MergeStrategy = MergeMajority
|
||
|
||
data, err := json.Marshal(payload)
|
||
if err != nil {
|
||
t.Errorf("Failed to marshal GroupTaskSplitPayload: %v", err)
|
||
}
|
||
|
||
var parsed GroupTaskSplitPayload
|
||
if err := json.Unmarshal(data, &parsed); err != nil {
|
||
t.Errorf("Failed to unmarshal GroupTaskSplitPayload: %v", err)
|
||
}
|
||
|
||
if len(parsed.Subtasks) != 2 {
|
||
t.Errorf("Subtasks count mismatch: got %d, want 2", len(parsed.Subtasks))
|
||
}
|
||
if parsed.MergeStrategy != MergeMajority {
|
||
t.Errorf("MergeStrategy mismatch")
|
||
}
|
||
}
|
||
|
||
func TestGroupVotePayloadJSON(t *testing.T) {
|
||
payload := GroupVotePayload{
|
||
VoteID: "vote-001",
|
||
Question: "Which approach is better?",
|
||
Options: []string{"Option A", "Option B", "Option C"},
|
||
Voters: []string{"agent-001", "agent-002", "agent-003"},
|
||
Threshold: 0.5,
|
||
Status: "open",
|
||
}
|
||
|
||
data, err := json.Marshal(payload)
|
||
if err != nil {
|
||
t.Errorf("Failed to marshal GroupVotePayload: %v", err)
|
||
}
|
||
|
||
var parsed GroupVotePayload
|
||
if err := json.Unmarshal(data, &parsed); err != nil {
|
||
t.Errorf("Failed to unmarshal GroupVotePayload: %v", err)
|
||
}
|
||
|
||
if len(parsed.Options) != 3 {
|
||
t.Errorf("Options count mismatch")
|
||
}
|
||
}
|
||
|
||
// =============================================================================
|
||
// 错误码测试
|
||
// =============================================================================
|
||
|
||
func TestSynapseErrorCategory(t *testing.T) {
|
||
tests := []struct {
|
||
code SynapseErrorCode
|
||
expected string
|
||
}{
|
||
{ErrSystemError, "SYSTEM_ERROR"},
|
||
{ErrTaskNotFound, "TASK_ERROR"},
|
||
{ErrRequiredFieldMissing, "INFO_ERROR"},
|
||
{ErrUnsupportedTaskType, "CAPABILITY_ERROR"},
|
||
{ErrAuthFailed, "SECURITY_ERROR"},
|
||
{ErrEndpointUnreachable, "COMMUNICATION_ERROR"},
|
||
{ErrGroupNotFound, "GROUP_ERROR"},
|
||
{ErrHumanTimeout, "HIL_ERROR"},
|
||
{ErrInvalidParams, "VALIDATION_ERROR"},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
if got := tt.code.Category(); got != tt.expected {
|
||
t.Errorf("Category for %d: got %s, want %s", tt.code, got, tt.expected)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestNewSynapseError(t *testing.T) {
|
||
err := NewSynapseError(ErrTaskNotFound, "Task not found", map[string]string{"task_id": "task-001"})
|
||
|
||
if err.Code != ErrTaskNotFound {
|
||
t.Errorf("Error code mismatch")
|
||
}
|
||
if err.Message != "Task not found" {
|
||
t.Errorf("Error message mismatch")
|
||
}
|
||
if err.Category != "TASK_ERROR" {
|
||
t.Errorf("Error category mismatch")
|
||
}
|
||
}
|
||
|
||
func TestSynapseErrorToMap(t *testing.T) {
|
||
err := NewSynapseError(ErrTaskNotFound, "Task not found", nil)
|
||
m := err.ToMap()
|
||
|
||
if m["code"] != ErrTaskNotFound {
|
||
t.Errorf("Map code mismatch")
|
||
}
|
||
if m["category"] != "TASK_ERROR" {
|
||
t.Errorf("Map category mismatch")
|
||
}
|
||
if m["message"] != "Task not found" {
|
||
t.Errorf("Map message mismatch")
|
||
}
|
||
}
|
||
|
||
// =============================================================================
|
||
// 状态机测试
|
||
// =============================================================================
|
||
|
||
func TestP2PTaskStatusValues(t *testing.T) {
|
||
statuses := []P2PTaskStatus{
|
||
P2PStatusIdle,
|
||
P2PStatusPending,
|
||
P2PStatusConfirmed,
|
||
P2PStatusExecuting,
|
||
P2PStatusCompleted,
|
||
P2PStatusFailed,
|
||
P2PStatusCancelled,
|
||
}
|
||
|
||
for _, s := range statuses {
|
||
if s == "" {
|
||
t.Error("Status should not be empty")
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestGroupStatusValues(t *testing.T) {
|
||
statuses := []GroupStatus{
|
||
GroupStatusCreating,
|
||
GroupStatusActive,
|
||
GroupStatusFrozen,
|
||
GroupStatusDisbanded,
|
||
}
|
||
|
||
for _, s := range statuses {
|
||
if s == "" {
|
||
t.Error("Status should not be empty")
|
||
}
|
||
}
|
||
}
|
||
|
||
// =============================================================================
|
||
// 消息类型测试
|
||
// =============================================================================
|
||
|
||
func TestP2PMessageTypes(t *testing.T) {
|
||
types := []P2PMessageType{
|
||
P2PTaskRequest,
|
||
P2PTaskConfirm,
|
||
P2PTaskReject,
|
||
P2PTaskNeedInfo,
|
||
P2PTaskInfoProvided,
|
||
P2PTaskStatusUpdate,
|
||
P2PTaskComplete,
|
||
P2PTaskFailed,
|
||
P2PTaskCancel,
|
||
P2PTaskAck,
|
||
P2PAck,
|
||
P2PNack,
|
||
P2PHeartbeat,
|
||
P2PCapabilityQuery,
|
||
P2PCapabilityResponse,
|
||
P2PTaskNeedHuman,
|
||
P2PHumanDecision,
|
||
}
|
||
|
||
for _, mt := range types {
|
||
if mt == "" {
|
||
t.Error("Message type should not be empty")
|
||
}
|
||
// 验证前缀
|
||
if !startsWith(string(mt), "p2p:") {
|
||
t.Errorf("P2P message type should have p2p: prefix: %s", mt)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestGroupMessageTypes(t *testing.T) {
|
||
groupTypes := []GroupMessageType{
|
||
GroupCreate,
|
||
GroupDisband,
|
||
GroupJoin,
|
||
GroupLeave,
|
||
GroupBroadcast,
|
||
GroupTaskSplit,
|
||
GroupTaskAssign,
|
||
GroupTaskMerge,
|
||
GroupVote,
|
||
GroupVoteSubmit,
|
||
}
|
||
|
||
for _, mt := range groupTypes {
|
||
if mt == "" {
|
||
t.Error("Message type should not be empty")
|
||
}
|
||
// 验证前缀
|
||
if !startsWith(string(mt), "group:") {
|
||
t.Errorf("Group message type should have group: prefix: %s", mt)
|
||
}
|
||
}
|
||
}
|
||
|
||
func startsWith(s, prefix string) bool {
|
||
return len(s) >= len(prefix) && s[:len(prefix)] == prefix
|
||
}
|