package worker import ( "encoding/json" "os" "path/filepath" "strings" "testing" "droboticflow/internal/domain" ) func TestBuildNodeEnvInjectsPlatformMongoEnvForMongoNode(t *testing.T) { t.Setenv("MONGO_URI", "mongodb://platform-mongo:27017") t.Setenv("MONGO_DB", "droboticflow") run := &domain.RunRecord{ ID: "run-1", ParentRunID: "run-parent", WorkflowID: "workflow-1", Trigger: domain.RunTriggerScheduled, PreviousRunAt: "2026-04-21T10:00:00Z", CurrentRunAt: "2026-04-21T11:30:00Z", } workflow := &domain.WorkflowRecord{ ID: "workflow-1", Hyperparams: []domain.HyperParam{{Key: "GLOBAL_ENV", Value: "from-workflow"}}, } node := domain.WorkflowNode{ ID: "node-1", Type: "operator", Data: domain.WorkflowNodeData{ Label: "MongoDB 写入", Category: "DATA", Description: "write docs", Hyperparams: []domain.HyperParam{ {Key: "MONGO_COLLECTION", Value: "qualityReports"}, {Key: "PARENT_RUN_ID", Value: "user-value-must-not-win"}, }, }, } workspace := nodeWorkspace{ RunRoot: "/tmp/workspace/system/runs/run-1", Root: "/tmp/workspace/system/runs/run-1/nodes/node-1", OutputDir: "/tmp/workspace/system/runs/run-1/nodes/node-1/outputs", InputArtifactsPath: "/tmp/workspace/system/runs/run-1/nodes/node-1/input-artifacts.json", ResultPath: "/tmp/workspace/system/runs/run-1/nodes/node-1/result.json", StageManifestPath: "/tmp/workspace/system/runs/run-1/nodes/node-1/stage-manifest.json", } env, err := buildNodeEnv(run, workflow, node, nil, workspace, &domain.SettingsRecord{}) if err != nil { t.Fatalf("buildNodeEnv returned error: %v", err) } if env["PLATFORM_MONGO_URI"] != "mongodb://platform-mongo:27017" { t.Fatalf("expected PLATFORM_MONGO_URI to be injected, got %q", env["PLATFORM_MONGO_URI"]) } if env["PLATFORM_MONGO_DB"] != "droboticflow" { t.Fatalf("expected PLATFORM_MONGO_DB to be injected, got %q", env["PLATFORM_MONGO_DB"]) } if _, ok := env["BUSINESS_MONGO_URI"]; ok { t.Fatalf("did not expect BUSINESS_MONGO_URI to be injected") } if _, ok := env["BUSINESS_MONGO_DB"]; ok { t.Fatalf("did not expect BUSINESS_MONGO_DB to be injected") } if env["MONGO_COLLECTION"] != "qualityReports" { t.Fatalf("expected node hyperparam preserved, got %q", env["MONGO_COLLECTION"]) } if env["GLOBAL_ENV"] != "from-workflow" { t.Fatalf("expected workflow hyperparam injected, got %q", env["GLOBAL_ENV"]) } if env["INPUT_ARTIFACTS_PATH"] != workspace.InputArtifactsPath { t.Fatalf("expected INPUT_ARTIFACTS_PATH to be populated, got %q", env["INPUT_ARTIFACTS_PATH"]) } if env["RESULT_OUTPUT_PATH"] != workspace.ResultPath { t.Fatalf("expected RESULT_OUTPUT_PATH to be populated, got %q", env["RESULT_OUTPUT_PATH"]) } if env["STAGE_MANIFEST_PATH"] != workspace.StageManifestPath { t.Fatalf("expected STAGE_MANIFEST_PATH to be populated, got %q", env["STAGE_MANIFEST_PATH"]) } if env["WORKSPACE_ROOT"] != workspace.RunRoot { t.Fatalf("expected WORKSPACE_ROOT to point at run root, got %q", env["WORKSPACE_ROOT"]) } if env["PARENT_RUN_ID"] != "run-parent" { t.Fatalf("expected protected parent run id, got %q", env["PARENT_RUN_ID"]) } if env["PARENT_RUN_WORKSPACE_ROOT"] != "/tmp/workspace/system/runs/run-parent" { t.Fatalf("expected parent run workspace root, got %q", env["PARENT_RUN_WORKSPACE_ROOT"]) } if env["PARENT_NODE_OUTPUT_DIR"] != "/tmp/workspace/system/runs/run-parent/nodes/node-1/outputs" { t.Fatalf("expected parent node output directory, got %q", env["PARENT_NODE_OUTPUT_DIR"]) } expectedPrevious := "2026-04-21T18:00:00+08:00" if env["WORKFLOW_PREVIOUS_RUN_TIMESTAMP"] != expectedPrevious { t.Fatalf("expected previous run timestamp env, got %q", env["WORKFLOW_PREVIOUS_RUN_TIMESTAMP"]) } expectedCurrent := "2026-04-21T19:30:00+08:00" if env["WORKFLOW_CURRENT_RUN_TIMESTAMP"] != expectedCurrent { t.Fatalf("expected current run timestamp env, got %q", env["WORKFLOW_CURRENT_RUN_TIMESTAMP"]) } } func TestBuildNodeEnvPartitionsCredentialsAndRedactsNodeDataJSON(t *testing.T) { run := &domain.RunRecord{ID: "run-secret", WorkflowID: "workflow-secret"} node := domain.WorkflowNode{ ID: "node-secret", Type: "operator", Data: domain.WorkflowNodeData{ Label: "BOS 输入", Hyperparams: []domain.HyperParam{ {Key: "BOS_ENDPOINT", Value: "https://bj.bcebos.com"}, {Key: "BOS_ACCESS_KEY_ID", Value: "sensitive-ak"}, {Key: "BOS_SECRET_ACCESS_KEY", Value: "sensitive-sk"}, }, }, } root := t.TempDir() workspace := nodeWorkspace{ RunRoot: root, Root: filepath.Join(root, "node"), OutputDir: filepath.Join(root, "node", "outputs"), InputArtifactsPath: filepath.Join(root, "node", "input-artifacts.json"), InputBindingsPath: filepath.Join(root, "node", "input-bindings.json"), ResultPath: filepath.Join(root, "node", "result.json"), StageManifestPath: filepath.Join(root, "node", "stage-manifest.json"), } env, err := buildNodeEnv(run, nil, node, nil, workspace, &domain.SettingsRecord{}) if err != nil { t.Fatalf("build node environment: %v", err) } if strings.Contains(env["NODE_DATA_JSON"], "sensitive-ak") || strings.Contains(env["NODE_DATA_JSON"], "sensitive-sk") { t.Fatalf("NODE_DATA_JSON must not embed credentials: %s", env["NODE_DATA_JSON"]) } public, sensitive := partitionSensitiveNodeEnv(env) if _, exists := public["BOS_ACCESS_KEY_ID"]; exists { t.Fatalf("access key leaked into public Job environment: %#v", public) } if _, exists := public["BOS_SECRET_ACCESS_KEY"]; exists { t.Fatalf("secret key leaked into public Job environment: %#v", public) } if sensitive["BOS_ACCESS_KEY_ID"] != "sensitive-ak" || sensitive["BOS_SECRET_ACCESS_KEY"] != "sensitive-sk" { t.Fatalf("credentials were not partitioned into the Secret payload: %#v", sensitive) } if public["BOS_ENDPOINT"] != "https://bj.bcebos.com" { t.Fatalf("non-sensitive endpoint must remain in the Job environment: %#v", public) } } func TestRuntimeContractLongRunning(t *testing.T) { if runtimeContractLongRunning(nil) { t.Fatalf("nil runtime contract should not be long-running") } if runtimeContractLongRunning(map[string]any{"longRunning": false}) { t.Fatalf("false runtime contract should not be long-running") } if !runtimeContractLongRunning(map[string]any{"longRunning": true}) { t.Fatalf("true runtime contract should be long-running") } if runtimeContractLongRunning(map[string]any{"longRunning": "true"}) { t.Fatalf("non-boolean runtime contract should not be long-running") } } func TestBuildNodeEnvWritesInputArtifactsManifest(t *testing.T) { run := &domain.RunRecord{ ID: "run-1", WorkflowID: "workflow-1", Trigger: domain.RunTriggerManual, CurrentRunAt: "2026-04-21T11:30:00Z", } workflow := &domain.WorkflowRecord{ ID: "workflow-1", Hyperparams: []domain.HyperParam{{Key: "GLOBAL_ENV", Value: "workflow-default"}}, } node := domain.WorkflowNode{ ID: "node-1", Type: "operator", Data: domain.WorkflowNodeData{ Label: "数据过滤", Category: "DATA", Description: "filter docs", Hyperparams: []domain.HyperParam{{Key: "GLOBAL_ENV", Value: "node-override"}}, }, } root := t.TempDir() workspace := nodeWorkspace{ RunRoot: filepath.Join(root, "system", "runs", "run-1"), Root: filepath.Join(root, "system", "runs", "run-1", "nodes", "node-1"), OutputDir: filepath.Join(root, "system", "runs", "run-1", "nodes", "node-1", "outputs"), InputArtifactsPath: filepath.Join(root, "system", "runs", "run-1", "nodes", "node-1", "input-artifacts.json"), ResultPath: filepath.Join(root, "system", "runs", "run-1", "nodes", "node-1", "result.json"), StageManifestPath: filepath.Join(root, "system", "runs", "run-1", "nodes", "node-1", "stage-manifest.json"), } inputs := []domain.ExecutionArtifact{{ID: "artifact-1", Name: "manifest.json", Type: domain.PortTypeJSON, Path: "bos://bucket/demo.json"}} env, err := buildNodeEnv(run, workflow, node, inputs, workspace, &domain.SettingsRecord{}) if err != nil { t.Fatalf("buildNodeEnv returned error: %v", err) } payload, err := os.ReadFile(workspace.InputArtifactsPath) if err != nil { t.Fatalf("read input manifest: %v", err) } var decoded []domain.ExecutionArtifact if err := json.Unmarshal(payload, &decoded); err != nil { t.Fatalf("decode input manifest: %v", err) } if len(decoded) != 1 || decoded[0].ID != "artifact-1" { t.Fatalf("unexpected input manifest payload: %#v", decoded) } if env["INPUT_ARTIFACTS_JSON"] == "" { t.Fatalf("expected small input manifest to remain inline for convenience") } if _, ok := env["WORKFLOW_PREVIOUS_RUN_TIMESTAMP"]; ok { t.Fatalf("expected manual run to omit previous run timestamp env, got %q", env["WORKFLOW_PREVIOUS_RUN_TIMESTAMP"]) } if _, ok := env["WORKFLOW_CURRENT_RUN_TIMESTAMP"]; ok { t.Fatalf("expected manual run to omit current run timestamp env, got %q", env["WORKFLOW_CURRENT_RUN_TIMESTAMP"]) } if env["GLOBAL_ENV"] != "node-override" { t.Fatalf("expected node hyperparams to override workflow-level env, got %q", env["GLOBAL_ENV"]) } } func TestGatherInputLineagePreservesWorkflowEdgeHandles(t *testing.T) { workflow := domain.WorkflowRecord{ Edges: []domain.WorkflowEdge{ {ID: "edge-frames", Source: "source", SourceHandle: "frames", Target: "sink", TargetHandle: "video-input"}, {ID: "edge-summary", Source: "source", SourceHandle: "summary", Target: "sink", TargetHandle: "metadata-input"}, }, } executionMap := map[string]domain.NodeExecutionRecord{ "source": { NodeID: "source", Artifacts: []domain.ExecutionArtifact{ {ID: "artifact-frames", NodeID: "source", PortID: "frames", PortName: "frames", Name: "frames.json", Type: domain.PortTypeJSON}, {ID: "artifact-summary", NodeID: "source", PortID: "summary", PortName: "summary", Name: "summary.json", Type: domain.PortTypeJSON}, }, }, } lineage := gatherInputLineage(workflow, executionMap, "sink") if len(lineage) != 2 { t.Fatalf("expected 2 input lineage records, got %#v", lineage) } if lineage[0].WorkflowEdgeID != "edge-frames" || lineage[0].SourceHandle != "frames" || lineage[0].TargetHandle != "video-input" || lineage[0].Artifact.ID != "artifact-frames" { t.Fatalf("unexpected first lineage record: %#v", lineage[0]) } if lineage[1].WorkflowEdgeID != "edge-summary" || lineage[1].SourceHandle != "summary" || lineage[1].TargetHandle != "metadata-input" || lineage[1].Artifact.ID != "artifact-summary" { t.Fatalf("unexpected second lineage record: %#v", lineage[1]) } artifacts := inputArtifactsFromLineage(lineage) if len(artifacts) != 2 || artifacts[0].ID != "artifact-frames" || artifacts[1].ID != "artifact-summary" { t.Fatalf("unexpected artifacts from lineage: %#v", artifacts) } } func TestBuildNodeEnvDoesNotAllowHyperparamsToOverrideRunTimestampEnv(t *testing.T) { run := &domain.RunRecord{ ID: "run-2", WorkflowID: "workflow-2", Trigger: domain.RunTriggerScheduled, PreviousRunAt: "2026-04-21T10:00:00Z", CurrentRunAt: "2026-04-21T11:30:00Z", } workflow := &domain.WorkflowRecord{ ID: "workflow-2", Hyperparams: []domain.HyperParam{ {Key: "WORKFLOW_PREVIOUS_RUN_TIMESTAMP", Value: "workflow-999"}, {Key: "WORKFLOW_CURRENT_RUN_TIMESTAMP", Value: "workflow-888"}, }, } node := domain.WorkflowNode{ ID: "node-2", Type: "operator", Data: domain.WorkflowNodeData{ Label: "Shell 命令执行", Category: "FLOW", Description: "exec", Hyperparams: []domain.HyperParam{ {Key: "WORKFLOW_PREVIOUS_RUN_TIMESTAMP", Value: "999"}, {Key: "WORKFLOW_CURRENT_RUN_TIMESTAMP", Value: "888"}, }, }, } workspace := nodeWorkspace{ RunRoot: "/tmp/workspace/system/runs/run-2", Root: "/tmp/workspace/system/runs/run-2/nodes/node-2", OutputDir: "/tmp/workspace/system/runs/run-2/nodes/node-2/outputs", InputArtifactsPath: "/tmp/workspace/system/runs/run-2/nodes/node-2/input-artifacts.json", ResultPath: "/tmp/workspace/system/runs/run-2/nodes/node-2/result.json", StageManifestPath: "/tmp/workspace/system/runs/run-2/nodes/node-2/stage-manifest.json", } env, err := buildNodeEnv(run, workflow, node, nil, workspace, &domain.SettingsRecord{}) if err != nil { t.Fatalf("buildNodeEnv returned error: %v", err) } if env["WORKFLOW_PREVIOUS_RUN_TIMESTAMP"] != "2026-04-21T18:00:00+08:00" { t.Fatalf("expected protected previous timestamp env, got %q", env["WORKFLOW_PREVIOUS_RUN_TIMESTAMP"]) } if env["WORKFLOW_CURRENT_RUN_TIMESTAMP"] != "2026-04-21T19:30:00+08:00" { t.Fatalf("expected protected current timestamp env, got %q", env["WORKFLOW_CURRENT_RUN_TIMESTAMP"]) } } func TestBuildNodeEnvInjectsProtectedOperatorCommandPolicy(t *testing.T) { t.Setenv("OPERATOR_ALLOW_SHELL_COMMANDS", "false") t.Setenv("OPERATOR_COMMAND_ALLOWLIST_REGEX", `^python3?\s`) t.Setenv("OPERATOR_COMMAND_DENYLIST_REGEX", `(^|\s)rm\s+-rf`) run := &domain.RunRecord{ ID: "run-3", WorkflowID: "workflow-3", Trigger: domain.RunTriggerManual, } workflow := &domain.WorkflowRecord{ ID: "workflow-3", Hyperparams: []domain.HyperParam{ {Key: "OPERATOR_ALLOW_SHELL_COMMANDS", Value: "true"}, {Key: "OPERATOR_COMMAND_ALLOWLIST_REGEX", Value: ".*"}, }, } node := domain.WorkflowNode{ ID: "node-3", Type: "operator", Data: domain.WorkflowNodeData{ Label: "Shell 命令执行", Category: "FLOW", Hyperparams: []domain.HyperParam{ {Key: "OPERATOR_COMMAND_DENYLIST_REGEX", Value: ""}, }, }, } workspace := nodeWorkspace{ RunRoot: "/tmp/workspace/system/runs/run-3", Root: "/tmp/workspace/system/runs/run-3/nodes/node-3", OutputDir: "/tmp/workspace/system/runs/run-3/nodes/node-3/outputs", InputArtifactsPath: "/tmp/workspace/system/runs/run-3/nodes/node-3/input-artifacts.json", ResultPath: "/tmp/workspace/system/runs/run-3/nodes/node-3/result.json", StageManifestPath: "/tmp/workspace/system/runs/run-3/nodes/node-3/stage-manifest.json", } env, err := buildNodeEnv(run, workflow, node, nil, workspace, &domain.SettingsRecord{}) if err != nil { t.Fatalf("buildNodeEnv returned error: %v", err) } if env["OPERATOR_ALLOW_SHELL_COMMANDS"] != "false" { t.Fatalf("expected platform shell command flag to win, got %q", env["OPERATOR_ALLOW_SHELL_COMMANDS"]) } if env["OPERATOR_COMMAND_ALLOWLIST_REGEX"] != `^python3?\s` { t.Fatalf("expected platform allowlist to win, got %q", env["OPERATOR_COMMAND_ALLOWLIST_REGEX"]) } if env["OPERATOR_COMMAND_DENYLIST_REGEX"] != `(^|\s)rm\s+-rf` { t.Fatalf("expected platform denylist to win, got %q", env["OPERATOR_COMMAND_DENYLIST_REGEX"]) } } func TestParseExecutionOutputReadsResultFilePayload(t *testing.T) { resultPath := filepath.Join(t.TempDir(), "result.json") payload := executionResult{ Logs: []domain.LogEntryRecord{{Level: "INFO", Message: "done", Operator: "测试节点"}}, Artifacts: []domain.ExecutionArtifact{{ID: "artifact-1", Name: "report.json"}}, } data, err := json.Marshal(payload) if err != nil { t.Fatalf("marshal payload: %v", err) } if err := os.WriteFile(resultPath, data, 0o644); err != nil { t.Fatalf("write payload: %v", err) } parsed, err := parseExecutionOutput("some log\n"+resultPathPrefix+resultPath+"\n", "测试节点") if err != nil { t.Fatalf("parseExecutionOutput returned error: %v", err) } if len(parsed.Artifacts) != 1 || parsed.Artifacts[0].ID != "artifact-1" { t.Fatalf("unexpected parsed artifacts: %#v", parsed.Artifacts) } } func TestParseExecutionOutputAcceptsNumericArtifactSize(t *testing.T) { parsed, err := parseExecutionOutput(`DROBOTICFLOW_RESULT={"artifacts":[{"id":"artifact-size","name":"training_report","type":"file","size":1852,"path":"/workspace/report.json"}]}`, "训练") if err != nil { t.Fatalf("parseExecutionOutput returned error: %v", err) } if len(parsed.Artifacts) != 1 { t.Fatalf("expected one artifact, got %#v", parsed.Artifacts) } artifact := parsed.Artifacts[0] if artifact.SizeBytes != 1852 || artifact.Size != "1.8 KB" { t.Fatalf("unexpected numeric artifact size: %#v", artifact) } } func TestLoadStageManifestDataRefs(t *testing.T) { stageManifestPath := filepath.Join(t.TempDir(), "stage-manifest.json") payload := map[string]any{ "dataRefs": []map[string]any{ { "artifactId": "artifact-1", "artifactName": "dataset-index.json", "kind": "dataset", "datasetType": "x-platform-index", "manifestPath": "/workspace/run/stage/manifest.json", "payloadPath": "/workspace/run/stage/payload.json", "partitionDir": "/workspace/run/stage/partitions", "partitionCount": 3, "itemCount": 12, }, }, } data, err := json.Marshal(payload) if err != nil { t.Fatalf("marshal payload: %v", err) } if err := os.WriteFile(stageManifestPath, data, 0o644); err != nil { t.Fatalf("write stage manifest: %v", err) } dataRefs, err := loadStageManifestDataRefs(stageManifestPath) if err != nil { t.Fatalf("loadStageManifestDataRefs returned error: %v", err) } if len(dataRefs) != 1 || dataRefs[0].DatasetType != "x-platform-index" { t.Fatalf("unexpected data refs: %#v", dataRefs) } } func TestApplyNodeOverridesToNode(t *testing.T) { node := domain.WorkflowNode{ ID: "test-node", Type: "operator", Data: domain.WorkflowNodeData{ Label: "Original Operator", Image: "registry.example.com/base:v1", Hyperparams: []domain.HyperParam{ {Key: "threshold", Value: "0.5"}, {Key: "batch_size", Value: "16"}, }, ContainerCommand: []string{"python", "main.py"}, ContainerArgs: []string{"--mode", "normal"}, }, } override := domain.NodeOverride{ Hyperparams: []domain.HyperParam{ {Key: "threshold", Value: "0.9"}, {Key: "learning_rate", Value: "0.001"}, }, Image: "registry.example.com/custom:v2", ContainerCommand: []string{"python", "debug.py"}, ContainerArgs: []string{"--debug", "--verbose"}, } overridden := applyNodeOverridesToNode(node, override) if overridden.Data.Image != "registry.example.com/custom:v2" { t.Fatalf("expected overridden image, got %s", overridden.Data.Image) } if len(overridden.Data.ContainerCommand) != 2 || overridden.Data.ContainerCommand[1] != "debug.py" { t.Fatalf("expected overridden command, got %#v", overridden.Data.ContainerCommand) } if len(overridden.Data.ContainerArgs) != 2 || overridden.Data.ContainerArgs[0] != "--debug" { t.Fatalf("expected overridden args, got %#v", overridden.Data.ContainerArgs) } hpMap := make(map[string]string) for _, hp := range overridden.Data.Hyperparams { hpMap[hp.Key] = hp.Value } if hpMap["threshold"] != "0.9" { t.Fatalf("expected threshold=0.9, got %s", hpMap["threshold"]) } if hpMap["batch_size"] != "16" { t.Fatalf("expected batch_size=16, got %s", hpMap["batch_size"]) } if hpMap["learning_rate"] != "0.001" { t.Fatalf("expected learning_rate=0.001, got %s", hpMap["learning_rate"]) } // Verify original node was NOT modified (zero mutation invariant) if node.Data.Image != "registry.example.com/base:v1" { t.Fatalf("original node image was corrupted") } if len(node.Data.Hyperparams) != 2 || node.Data.Hyperparams[0].Value != "0.5" { t.Fatalf("original node hyperparams were corrupted") } } func TestGatherNodeInputsWithNodeOverrides(t *testing.T) { workflow := domain.WorkflowRecord{ ID: "wf-1", Nodes: []domain.WorkflowNode{ {ID: "node-1", Data: domain.WorkflowNodeData{Label: "Node 1"}}, }, } run := &domain.RunRecord{ ID: "run-dbg-1", NodeOverrides: map[string]domain.NodeOverride{ "node-1": { Inputs: map[string]domain.ArtifactPayload{ "in_port": { Mode: domain.ArtifactTransferModeInline, Type: domain.PortTypeJSON, Inline: map[string]any{"debug_key": "debug_val"}, }, }, }, }, } artifacts, lineage, bindings := gatherNodeInputs(workflow, run, map[string]domain.NodeExecutionRecord{}, "node-1") _ = lineage if len(bindings) != 1 { t.Fatalf("expected 1 binding, got %d", len(bindings)) } if bindings[0].TargetPortID != "in_port" { t.Fatalf("expected target port in_port, got %s", bindings[0].TargetPortID) } if len(artifacts) != 1 { t.Fatalf("expected 1 artifact, got %d", len(artifacts)) } if artifacts[0].PortID != "in_port" { t.Fatalf("expected port in_port, got %s", artifacts[0].PortID) } } func TestRerunAllowedNodeSetSingleNodeDebug(t *testing.T) { wf := domain.WorkflowRecord{ ID: "wf-dag", Nodes: []domain.WorkflowNode{ {ID: "node-A"}, {ID: "node-B"}, {ID: "node-C"}, }, Edges: []domain.WorkflowEdge{ {ID: "e1", Source: "node-A", Target: "node-B"}, {ID: "e2", Source: "node-B", Target: "node-C"}, }, } debugRun := &domain.RunRecord{ ID: "run-single-node", Trigger: domain.RunTriggerManual, Mode: domain.RunModeDebug, DebugTarget: &domain.DebugExecutionTarget{ TargetNodeID: "node-B", SingleNode: true, }, } allowed := rerunAllowedNodeSet(wf, debugRun) if len(allowed) != 1 { t.Fatalf("expected allowed set of size 1, got %d", len(allowed)) } if _, ok := allowed["node-B"]; !ok { t.Fatalf("expected node-B to be allowed") } if _, ok := allowed["node-A"]; ok { t.Fatalf("did not expect node-A in single-node debug allowed set") } if _, ok := allowed["node-C"]; ok { t.Fatalf("did not expect node-C in single-node debug allowed set") } }