gongzhiyong
70663f47ee
Add separate Runtime mode selection for ordinary sub and swarm flows, including Swarm-specific create payload shaping and Azure VM env wiring. Document the ordinary sub artifact callback gap, swarm runtime findings, PayPal billing boundaries, deployment migration requirements, and desktop/API progress. Constraint: Keep ordinary sub and HeiCode-Swarm Runtime deployments separate Confidence: high Scope-risk: moderate Tests: go test ./...
312 lines
15 KiB
Go
312 lines
15 KiB
Go
package router
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gin-contrib/sessions"
|
|
"github.com/gin-contrib/sessions/cookie"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/glebarez/sqlite"
|
|
"github.com/heicode/manager/common"
|
|
"github.com/heicode/manager/model"
|
|
"github.com/stretchr/testify/require"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
func setupAgnetRuntimeHTTPSmokeDB(t *testing.T) *gorm.DB {
|
|
t.Helper()
|
|
common.UsingSQLite = true
|
|
common.UsingMySQL = false
|
|
common.UsingPostgreSQL = false
|
|
common.RedisEnabled = false
|
|
|
|
dsn := fmt.Sprintf("file:%s?mode=memory&cache=shared", strings.ReplaceAll(t.Name(), "/", "_"))
|
|
db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{})
|
|
require.NoError(t, err)
|
|
model.DB = db
|
|
model.LOG_DB = db
|
|
require.NoError(t, db.AutoMigrate(
|
|
&model.User{},
|
|
&model.AgnetDeployment{},
|
|
&model.AgnetAuditEvent{},
|
|
))
|
|
adminToken := "runtime-smoke-admin-token"
|
|
require.NoError(t, db.Create(&model.User{
|
|
Id: 101,
|
|
Username: "runtime-smoke-admin",
|
|
Password: "not-used",
|
|
Role: common.RoleAdminUser,
|
|
Status: common.UserStatusEnabled,
|
|
DisplayName: "Runtime Smoke Admin",
|
|
AccessToken: &adminToken,
|
|
Group: "default",
|
|
}).Error)
|
|
t.Cleanup(func() {
|
|
if model.DB == db {
|
|
model.DB = nil
|
|
}
|
|
if model.LOG_DB == db {
|
|
model.LOG_DB = nil
|
|
}
|
|
sqlDB, err := db.DB()
|
|
if err == nil {
|
|
_ = sqlDB.Close()
|
|
}
|
|
})
|
|
return db
|
|
}
|
|
|
|
func startAgnetRuntimeManagerSmokeServer(t *testing.T) string {
|
|
t.Helper()
|
|
gin.SetMode(gin.TestMode)
|
|
engine := gin.New()
|
|
engine.Use(sessions.Sessions("runtime-smoke", cookie.NewStore([]byte("runtime-smoke-secret"))))
|
|
SetApiRouter(engine)
|
|
listener, err := net.Listen("tcp", "127.0.0.1:0")
|
|
require.NoError(t, err)
|
|
server := &http.Server{Handler: engine}
|
|
go func() {
|
|
_ = server.Serve(listener)
|
|
}()
|
|
t.Cleanup(func() {
|
|
_ = server.Close()
|
|
})
|
|
return "http://" + listener.Addr().String()
|
|
}
|
|
|
|
func agnetRuntimeAdminRequest(t *testing.T, method string, url string, body string) *http.Response {
|
|
t.Helper()
|
|
req, err := http.NewRequest(method, url, bytes.NewBufferString(body))
|
|
require.NoError(t, err)
|
|
req.Header.Set("Authorization", "Bearer runtime-smoke-admin-token")
|
|
req.Header.Set("New-Api-User", "101")
|
|
if body != "" {
|
|
req.Header.Set("Content-Type", "application/json")
|
|
}
|
|
resp, err := (&http.Client{Timeout: 5 * time.Second}).Do(req)
|
|
require.NoError(t, err)
|
|
return resp
|
|
}
|
|
|
|
func readAgnetRuntimeSmokeBody(t *testing.T, resp *http.Response) string {
|
|
t.Helper()
|
|
defer resp.Body.Close()
|
|
body, err := io.ReadAll(resp.Body)
|
|
require.NoError(t, err)
|
|
return string(body)
|
|
}
|
|
|
|
func TestAgnetRuntimeRealHTTPHealthAndShadowCreateSmoke(t *testing.T) {
|
|
db := setupAgnetRuntimeHTTPSmokeDB(t)
|
|
runtimeCreateCalled := false
|
|
runtime := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/agnet/health":
|
|
require.Equal(t, "Bearer runtime-service-token", r.Header.Get("Authorization"))
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"success":true,"data":{"status":"healthy"}}`))
|
|
case r.Method == http.MethodPost && r.URL.Path == "/api/agnet/deployments":
|
|
runtimeCreateCalled = true
|
|
require.Equal(t, "Bearer runtime-service-token", r.Header.Get("Authorization"))
|
|
require.Equal(t, "corr-http-smoke", r.Header.Get("X-Correlation-ID"))
|
|
body, err := io.ReadAll(r.Body)
|
|
require.NoError(t, err)
|
|
require.Contains(t, string(body), `"sub_mode":"agile"`)
|
|
require.Contains(t, string(body), `"agile_context"`)
|
|
require.Contains(t, string(body), `"checkpoint":"ready_for_test"`)
|
|
require.Contains(t, string(body), `"manager_deployment_id"`)
|
|
require.Contains(t, string(body), `"signing_secret_ref":"azkv://heicode-kv.vault.azure.net/secrets/callback-signing"`)
|
|
require.Contains(t, string(body), `"subscribed_events"`)
|
|
var runtimeBody map[string]any
|
|
require.NoError(t, common.Unmarshal(body, &runtimeBody))
|
|
agents := runtimeBody["agents"].([]any)
|
|
require.Equal(t, "builder", agents[0].(map[string]any)["role"])
|
|
grants := runtimeBody["resource_grants"].([]any)
|
|
require.NotEmpty(t, grants)
|
|
require.NotEmpty(t, grants[0].(map[string]any)["ref"])
|
|
metadata := runtimeBody["metadata"].(map[string]any)
|
|
require.NotEmpty(t, metadata["manager_deployment_id"])
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"success":true,"data":{"deployment_id":"runtime-http-dep","swarm_id":"runtime-http-swarm","runtime_status":"accepted"}}`))
|
|
default:
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
defer runtime.Close()
|
|
|
|
t.Setenv("AGNET_RUNTIME_ENABLED", "true")
|
|
t.Setenv("AGNET_RUNTIME_ASYNC", "false")
|
|
t.Setenv("AGNET_RUNTIME_BASE_URL", runtime.URL)
|
|
t.Setenv("AGNET_RUNTIME_SERVICE_TOKEN", "runtime-service-token")
|
|
t.Setenv("AGNET_RUNTIME_CALLBACK_SIGNING_SECRET_REF", "azkv://heicode-kv.vault.azure.net/secrets/callback-signing")
|
|
|
|
managerURL := startAgnetRuntimeManagerSmokeServer(t)
|
|
|
|
healthResp := agnetRuntimeAdminRequest(t, http.MethodGet, managerURL+"/api/agnet/runtime/health", "")
|
|
healthBody := readAgnetRuntimeSmokeBody(t, healthResp)
|
|
require.Equal(t, http.StatusOK, healthResp.StatusCode)
|
|
require.Contains(t, healthBody, `"success":true`)
|
|
require.Contains(t, healthBody, `"status":"healthy"`)
|
|
|
|
schemaResp, err := http.Get(managerURL + "/api/agnet/callbacks/swarm-events/schema")
|
|
require.NoError(t, err)
|
|
schemaBody := readAgnetRuntimeSmokeBody(t, schemaResp)
|
|
require.Equal(t, http.StatusOK, schemaResp.StatusCode)
|
|
require.Contains(t, schemaBody, `"event_type":"task.claimed"`)
|
|
require.Contains(t, schemaBody, `"event_type":"approval.requested"`)
|
|
var schemaEnvelope map[string]any
|
|
require.NoError(t, common.Unmarshal([]byte(schemaBody), &schemaEnvelope))
|
|
schemaData := schemaEnvelope["data"].(map[string]any)
|
|
schemaSecurity := schemaData["security"].(map[string]any)
|
|
require.Equal(t, "azkv://<vault>/secrets/<name>", schemaSecurity["secret_ref_scheme"])
|
|
|
|
createBody := `{
|
|
"orchestration_plan":{
|
|
"intent_id":"intent-http-smoke",
|
|
"template_hint":"heicode-task",
|
|
"objective":"real HTTP runtime smoke",
|
|
"sub_mode":"agile",
|
|
"risk_level":"low",
|
|
"budget":{"max_tokens":10000,"max_cost_usd":1,"max_duration_sec":600},
|
|
"user_context":{"user_id":"101","channel_id":"default"},
|
|
"billing_context":{"provider":"newapi","newapi_user_ref":"newapi-http-smoke"},
|
|
"agile_context":{"iteration":"2026-05-27~2026-05-28","stage":"development","checkpoint":"ready_for_test","acceptance_criteria":["接口返回成功"],"next_action":"submit_test_result","requires_user_approval":false},
|
|
"agent_runtime":{"platform":"agnet","agents":[{"role":"builder","model_ref":"model-http-smoke","instance_count":1}]},
|
|
"agents":[{"role_template":"builder","goal":"smoke","default_model_id":"model-http-smoke","resource_grants":[{"grant_id":"grant-http-git","resource_id":"git-http","resource_type":"git","user_id":"101","binding_scope":"https://example.invalid/heicode/smoke.git#main","target_role":"builder","target_agent_ref":"agent-builder-1","permission_scope":["repo:read"],"metadata":{"repo_url":"https://example.invalid/heicode/smoke.git"},"secret_ref":"azkv://heicode-kv.vault.azure.net/secrets/http-smoke-git","status":"active"}]}],
|
|
"constraints":{"allowed_model_ids":["model-http-smoke"]},
|
|
"metadata":{"correlation_id":"corr-http-smoke"}
|
|
}
|
|
}`
|
|
createResp := agnetRuntimeAdminRequest(t, http.MethodPost, managerURL+"/api/agnet/deployments", createBody)
|
|
responseBody := readAgnetRuntimeSmokeBody(t, createResp)
|
|
require.Equal(t, http.StatusOK, createResp.StatusCode)
|
|
require.Contains(t, responseBody, `"success":true`)
|
|
require.Contains(t, responseBody, `"runtime_deployment_id":"runtime-http-dep"`)
|
|
require.Contains(t, responseBody, `"runtime_swarm_id":"runtime-http-swarm"`)
|
|
require.True(t, runtimeCreateCalled)
|
|
|
|
var stored model.AgnetDeployment
|
|
require.NoError(t, db.Where("runtime_swarm_id = ?", "runtime-http-swarm").First(&stored).Error)
|
|
require.Equal(t, "accepted", stored.RuntimeState)
|
|
|
|
logsResp := agnetRuntimeAdminRequest(t, http.MethodGet, managerURL+"/api/agnet/deployments/"+stored.DeploymentID+"/logs", "")
|
|
logsBody := readAgnetRuntimeSmokeBody(t, logsResp)
|
|
require.Equal(t, http.StatusOK, logsResp.StatusCode)
|
|
require.Contains(t, logsBody, `"data_source":"manager_control_plane"`)
|
|
require.Contains(t, logsBody, `"runtime_source":"not_connected"`)
|
|
|
|
metricsResp := agnetRuntimeAdminRequest(t, http.MethodGet, managerURL+"/api/agnet/deployments/"+stored.DeploymentID+"/metrics", "")
|
|
metricsBody := readAgnetRuntimeSmokeBody(t, metricsResp)
|
|
require.Equal(t, http.StatusOK, metricsResp.StatusCode)
|
|
require.Contains(t, metricsBody, `"data_source":"manager_control_plane"`)
|
|
require.Contains(t, metricsBody, `"platform_estimated":true`)
|
|
}
|
|
|
|
func TestSwarmRuntimeHTTPCreateUsesSwarmConfigAndPayload(t *testing.T) {
|
|
db := setupAgnetRuntimeHTTPSmokeDB(t)
|
|
swarmCreateCalled := false
|
|
swarmStopCalled := false
|
|
swarm := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/agnet/health":
|
|
require.Equal(t, "Bearer swarm-runtime-token", r.Header.Get("Authorization"))
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"success":true,"data":{"status":"healthy","service":"heicode-swarm-runtime"}}`))
|
|
case r.Method == http.MethodPost && r.URL.Path == "/api/swarms":
|
|
swarmCreateCalled = true
|
|
require.Equal(t, "Bearer swarm-runtime-token", r.Header.Get("Authorization"))
|
|
require.Equal(t, "corr-swarm-smoke", r.Header.Get("X-Correlation-ID"))
|
|
body, err := io.ReadAll(r.Body)
|
|
require.NoError(t, err)
|
|
require.Contains(t, string(body), `"runtime_mode":"swarm"`)
|
|
require.Contains(t, string(body), `"manager_deployment_id"`)
|
|
var runtimeBody map[string]any
|
|
require.NoError(t, common.Unmarshal(body, &runtimeBody))
|
|
plan := runtimeBody["orchestration_plan"].(map[string]any)
|
|
agents := plan["agents"].([]any)
|
|
require.Len(t, agents, 3)
|
|
require.Equal(t, "planner", agents[0].(map[string]any)["role"])
|
|
require.Equal(t, "builder", agents[1].(map[string]any)["role"])
|
|
require.Equal(t, "reviewer", agents[2].(map[string]any)["role"])
|
|
require.NotContains(t, agents[0].(map[string]any), "role_template")
|
|
metadata := runtimeBody["metadata"].(map[string]any)
|
|
require.Equal(t, "swarm", metadata["runtime_mode"])
|
|
require.Equal(t, "api_swarms_adapter", metadata["source"])
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"success":true,"data":{"deployment_id":"swarm-runtime-dep","swarm_id":"swarm-runtime-id","status":"running"}}`))
|
|
case r.Method == http.MethodPost && r.URL.Path == "/api/swarms/swarm-runtime-id/stop":
|
|
swarmStopCalled = true
|
|
require.Equal(t, "Bearer swarm-runtime-token", r.Header.Get("Authorization"))
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"success":true,"data":{"deployment_id":"swarm-runtime-dep","swarm_id":"swarm-runtime-id","status":"stopped"}}`))
|
|
default:
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
defer swarm.Close()
|
|
|
|
t.Setenv("AGNET_RUNTIME_ENABLED", "false")
|
|
t.Setenv("SWARM_RUNTIME_ENABLED", "true")
|
|
t.Setenv("SWARM_RUNTIME_ASYNC", "false")
|
|
t.Setenv("SWARM_RUNTIME_BASE_URL", swarm.URL)
|
|
t.Setenv("SWARM_RUNTIME_SERVICE_TOKEN", "swarm-runtime-token")
|
|
|
|
managerURL := startAgnetRuntimeManagerSmokeServer(t)
|
|
|
|
healthResp := agnetRuntimeAdminRequest(t, http.MethodGet, managerURL+"/api/agnet/runtime/health?mode=swarm", "")
|
|
healthBody := readAgnetRuntimeSmokeBody(t, healthResp)
|
|
require.Equal(t, http.StatusOK, healthResp.StatusCode)
|
|
require.Contains(t, healthBody, `"mode":"swarm"`)
|
|
require.Contains(t, healthBody, `"status":"healthy"`)
|
|
require.Contains(t, healthBody, `"heicode-swarm-runtime"`)
|
|
|
|
createBody := `{
|
|
"orchestration_plan":{
|
|
"intent_id":"intent-swarm-smoke",
|
|
"template_hint":"heicode-swarm",
|
|
"objective":"swarm runtime smoke",
|
|
"sub_mode":"agile",
|
|
"risk_level":"low",
|
|
"budget":{"max_tokens":10000,"max_cost_usd":1,"max_duration_sec":600},
|
|
"user_context":{"user_id":"101","channel_id":"default"},
|
|
"billing_context":{"provider":"newapi","newapi_user_ref":"newapi-swarm-smoke"},
|
|
"agile_context":{"iteration":"2026-05-29","stage":"testing","checkpoint":"runtime_accepted","acceptance_criteria":["Runtime creates a swarm run"],"next_action":"submit_test_result","requires_user_approval":false},
|
|
"agent_runtime":{"platform":"agnet","agents":[{"role":"planner","model_ref":"model-swarm","instance_count":1},{"role":"builder","model_ref":"model-swarm","instance_count":1},{"role":"reviewer","model_ref":"model-swarm","instance_count":1}]},
|
|
"agents":[
|
|
{"role_template":"planner","goal":"plan the swarm task","default_model_id":"model-swarm","resource_grants":[{"grant_id":"grant-swarm-plan","resource_id":"doc-swarm","resource_type":"project_doc","user_id":"101","binding_scope":"task-swarm-smoke","target_role":"planner","target_agent_ref":"agent-planner-1","permission_scope":["doc:read"],"metadata":{"resource_ref":"task-swarm-smoke"},"status":"active"}]},
|
|
{"role_template":"builder","goal":"build the swarm output","default_model_id":"model-swarm","resource_grants":[{"grant_id":"grant-swarm-build","resource_id":"git-swarm","resource_type":"git","user_id":"101","binding_scope":"task-swarm-smoke","target_role":"builder","target_agent_ref":"agent-builder-1","permission_scope":["repo:read"],"metadata":{"repo_url":"https://example.invalid/heicode/swarm.git"},"secret_ref":"azkv://heicode-kv.vault.azure.net/secrets/swarm-git","status":"active"}]},
|
|
{"role_template":"reviewer","goal":"verify the swarm output","default_model_id":"model-swarm","resource_grants":[{"grant_id":"grant-swarm-review","resource_id":"doc-swarm","resource_type":"project_doc","user_id":"101","binding_scope":"task-swarm-smoke","target_role":"reviewer","target_agent_ref":"agent-reviewer-1","permission_scope":["doc:read"],"metadata":{"resource_ref":"task-swarm-smoke"},"status":"active"}]}
|
|
],
|
|
"constraints":{"allowed_model_ids":["model-swarm"]},
|
|
"metadata":{"correlation_id":"corr-swarm-smoke"}
|
|
}
|
|
}`
|
|
createResp := agnetRuntimeAdminRequest(t, http.MethodPost, managerURL+"/api/swarms", createBody)
|
|
responseBody := readAgnetRuntimeSmokeBody(t, createResp)
|
|
require.Equal(t, http.StatusOK, createResp.StatusCode)
|
|
require.Contains(t, responseBody, `"success":true`)
|
|
require.Contains(t, responseBody, `"runtime_deployment_id":"swarm-runtime-dep"`)
|
|
require.Contains(t, responseBody, `"runtime_swarm_id":"swarm-runtime-id"`)
|
|
require.True(t, swarmCreateCalled)
|
|
|
|
var stored model.AgnetDeployment
|
|
require.NoError(t, db.Where("runtime_swarm_id = ?", "swarm-runtime-id").First(&stored).Error)
|
|
require.Equal(t, "agile", stored.SubMode)
|
|
require.Contains(t, stored.PlanJSON, `"runtime_mode":"swarm"`)
|
|
|
|
stopResp := agnetRuntimeAdminRequest(t, http.MethodPost, managerURL+"/api/agnet/user/deployments/"+stored.DeploymentID+"/stop", `{"reason":"smoke done"}`)
|
|
stopBody := readAgnetRuntimeSmokeBody(t, stopResp)
|
|
require.Equal(t, http.StatusOK, stopResp.StatusCode)
|
|
require.Contains(t, stopBody, `"success":true`)
|
|
require.Contains(t, stopBody, `"runtime_state":"stopped"`)
|
|
require.True(t, swarmStopCalled)
|
|
}
|