Files
synapse/types/types_test.go
2026-06-27 22:17:15 +08:00

513 lines
12 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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
}