Skip to content

Agent Mesh

add tests

Antonio Ojea31aa50368394
diff --git a/tests/e2e/sam.bats b/tests/e2e/sam.bats
index 733505c7..404cb9dc 100644
--- a/tests/e2e/sam.bats
+++ b/tests/e2e/sam.bats
@@ -1,9 +1,14 @@
#!/usr/bin/env bats
setup() {
- export SAM_BINARY="${SAM_BINARY:-./bin/sam-agent}"
- if [[ ! -x "$SAM_BINARY" ]]; then
- skip "sam binary not found at $SAM_BINARY"
+ export SAM_NODE_BINARY="${SAM_NODE_BINARY:-./bin/sam-node}"
+ export SAM_HUB_BINARY="${SAM_HUB_BINARY:-./bin/sam-hub}"
+
+ if [[ ! -x "$SAM_NODE_BINARY" ]]; then
+ skip "sam-node binary not found at $SAM_NODE_BINARY"
+ fi
+ if [[ ! -x "$SAM_HUB_BINARY" ]]; then
+ skip "sam-hub binary not found at $SAM_HUB_BINARY"
fi
export TEST_TMPDIR
@@ -17,152 +22,32 @@ teardown() {
rm -rf "$TEST_TMPDIR"
}
-@test "sam up --help returns success" {
- run "$SAM_BINARY" up --help
- [[ "$status" -eq 0 ]]
- [[ "$output" == *"Run the SAM node"* ]] || [[ "$output" == *"run-for"* ]]
-}
-
-@test "sam publish --help returns success" {
- run "$SAM_BINARY" publish --help
- [[ "$status" -eq 0 ]]
- [[ "$output" == *"--skill"* ]]
-}
-
-@test "sam identity --help lists subcommands" {
- run "$SAM_BINARY" identity --help
- [[ "$status" -eq 0 ]]
- [[ "$output" == *"login"* ]] || [[ "$output" == *"whoami"* ]]
-}
-
-@test "sam call --help shows capability option" {
- run "$SAM_BINARY" call --help
- [[ "$status" -eq 0 ]]
- [[ "$output" == *"--capability"* ]] || [[ "$output" == *"call"* ]]
-}
-
-@test "sam mesh get agents --help returns success" {
- run "$SAM_BINARY" mesh get agents --help
+@test "sam-node --help returns success" {
+ run "$SAM_NODE_BINARY" --help
[[ "$status" -eq 0 ]]
+ [[ "$output" == *"Sovereign Agent Mesh Node"* ]]
}
-@test "sam inspect biscuit parses and explains a token" {
- token="alice;allow_skill=risk-audit,weather-bot"
- run "$SAM_BINARY" inspect biscuit "$token"
+@test "sam-node login --help returns success" {
+ run "$SAM_NODE_BINARY" login --help
[[ "$status" -eq 0 ]]
- [[ "$output" == *"alice"* ]]
- [[ "$output" == *"risk-audit"* ]]
- [[ "$output" == *"weather-bot"* ]]
+ [[ "$output" == *"Establish sovereign identity with the Hub"* ]]
}
-@test "sam inspect biscuit outputs JSON when token has multiple skills" {
- token="bob;allow_skill=chat,email"
- run "$SAM_BINARY" inspect biscuit "$token"
+@test "sam-node run without identity prints guidance" {
+ run "$SAM_NODE_BINARY" run
[[ "$status" -eq 0 ]]
- [[ "$output" == *"bob"* ]]
- [[ "$output" == *"chat"* ]]
- [[ "$output" == *"email"* ]]
+ [[ "$output" == *"No identity found"* ]]
}
-@test "sam publish --dry-run=client outputs card structure" {
- run "$SAM_BINARY" publish --skill weather-bot --mcp-port 9999 --dry-run=client
+@test "sam-node login stores identity from stdin" {
+ run bash -c "printf 'sample-token\n' | '$SAM_NODE_BINARY' login"
[[ "$status" -eq 0 ]]
- [[ "$output" == *'"peer_id"'* ]]
- [[ "$output" == *'"weather-bot"'* ]]
+ [[ "$output" == *"Success! Identity stored"* ]]
}
-@test "sam call --dry-run=client validates request without network" {
- run "$SAM_BINARY" call test-peer --message "hello" --dry-run=client
+@test "sam-hub --help returns success" {
+ run "$SAM_HUB_BINARY" --help
[[ "$status" -eq 0 ]]
- [[ "$output" == *'"target"'* ]] || [[ "$output" == *'"capability"'* ]]
-}
-
-@test "sam inspect card decodes JSON agent card" {
- card_json='{"peer_id":"test-peer","alg":"libp2p-ed25519","signature":"test","agent_card":{"name":"test"},"issued_at":"2026-01-01T00:00:00Z"}'
- run "$SAM_BINARY" inspect card "$card_json"
- [[ "$status" -eq 0 ]]
- [[ "$output" == *"test-peer"* ]] || [[ "$output" == *"Peer ID"* ]]
-}
-
-@test "sam proxy --help returns success" {
- run "$SAM_BINARY" proxy --help
- [[ "$status" -eq 0 ]]
- [[ "$output" == *"X-SAM-Target"* ]] || [[ "$output" == *"--port"* ]]
-}
-
-@test "sam proxy rejects requests without local identity login" {
- proxy_port=18080
- proxy_log="$TEST_TMPDIR/proxy.log"
-
- "$SAM_BINARY" proxy --port "$proxy_port" --listen /ip4/127.0.0.1/udp/4212/quic-v1 --run-for 10s >"$proxy_log" 2>&1 &
- proxy_pid=$!
-
- status_code="000"
- for _ in {1..40}; do
- status_code="$(curl -s -o "$TEST_TMPDIR/proxy_body.txt" -w "%{http_code}" -H "X-SAM-Target: 12D3KooWJ5x6k6U4k6M8QfR5fE3iZ7W2V2QX2c9Lr4R8D8vH" "http://127.0.0.1:${proxy_port}/health" || true)"
- if [[ "$status_code" != "000" ]]; then
- break
- fi
- sleep 0.1
- done
-
- kill "$proxy_pid" >/dev/null 2>&1 || true
- wait "$proxy_pid" >/dev/null 2>&1 || true
-
- [[ "$status_code" == "401" ]]
- run cat "$TEST_TMPDIR/proxy_body.txt"
- [[ "$output" == *"unauthorized"* ]]
-}
-
-@test "sam proxy /.sam/search discovers writer skill" {
- node_a_log="$TEST_TMPDIR/node-a.log"
- node_b_log="$TEST_TMPDIR/node-b.log"
- proxy_port=18081
- node_a_listen="/ip4/127.0.0.1/udp/4313/quic-v1"
- node_b_listen="/ip4/127.0.0.1/udp/4314/quic-v1"
-
- "$SAM_BINARY" proxy --port "$proxy_port" --listen "$node_b_listen" --dht-mode server --run-for 20s >"$node_b_log" 2>&1 &
- node_b_pid=$!
-
- node_b_peer=""
- for _ in {1..100}; do
- node_b_peer="$(grep -o 'peer_id=[^ ]*' "$node_b_log" | head -n1 | cut -d= -f2)"
- if [[ -n "$node_b_peer" ]]; then
- break
- fi
- sleep 0.1
- done
- [[ -n "$node_b_peer" ]]
-
- node_a_peer=""
- "$SAM_BINARY" publish --skill writer --mcp-port 19099 --listen "$node_a_listen" --bootstrap "/ip4/127.0.0.1/udp/4314/quic-v1/p2p/${node_b_peer}" --dht-mode server --run-for 20s >"$node_a_log" 2>&1 &
- node_a_pid=$!
-
- for _ in {1..120}; do
- node_a_peer="$(grep -o 'peer_id=[^ ]*' "$node_a_log" | head -n1 | cut -d= -f2)"
- if [[ -n "$node_a_peer" ]]; then
- break
- fi
- sleep 0.1
- done
- [[ -n "$node_a_peer" ]]
-
- search_status="000"
- for _ in {1..120}; do
- search_status="$(curl -s -o "$TEST_TMPDIR/search_body.json" -w "%{http_code}" "http://127.0.0.1:${proxy_port}/.sam/search?skill=writer" || true)"
- if [[ "$search_status" == "200" ]] && grep -q "$node_a_peer" "$TEST_TMPDIR/search_body.json"; then
- break
- fi
- sleep 0.2
- done
-
- kill "$node_b_pid" >/dev/null 2>&1 || true
- wait "$node_b_pid" >/dev/null 2>&1 || true
- kill "$node_a_pid" >/dev/null 2>&1 || true
- wait "$node_a_pid" >/dev/null 2>&1 || true
-
- [[ "$search_status" == "200" ]]
- run cat "$TEST_TMPDIR/search_body.json"
- [[ "$output" == *"$node_a_peer"* ]]
- [[ "$output" == *'"signature"'* ]]
+ [[ "$output" == *"Sovereign Agent Mesh - Multi-Transport Hub"* ]]
}
diff --git a/tests/e2e/watch.bats b/tests/e2e/watch.bats
index 99744e5d..7da8bf10 100644
--- a/tests/e2e/watch.bats
+++ b/tests/e2e/watch.bats
@@ -1,9 +1,9 @@
#!/usr/bin/env bats
setup() {
- export SAM_BINARY="${SAM_BINARY:-./bin/sam-agent}"
- if [[ ! -x "$SAM_BINARY" ]]; then
- skip "sam binary not found at $SAM_BINARY"
+ export SAM_NODE_BINARY="${SAM_NODE_BINARY:-./bin/sam-node}"
+ if [[ ! -x "$SAM_NODE_BINARY" ]]; then
+ skip "sam-node binary not found at $SAM_NODE_BINARY"
fi
export TEST_TMPDIR
@@ -17,51 +17,45 @@ teardown() {
rm -rf "$TEST_TMPDIR"
}
-@test "sam mesh get agents --watch updates when a new agent is published" {
- watcher_log="$TEST_TMPDIR/mesh-watch.log"
- publisher_log="$TEST_TMPDIR/mesh-publisher.log"
- watcher_listen="/ip4/127.0.0.1/udp/4320/quic-v1"
- publisher_listen="/ip4/127.0.0.1/udp/4321/quic-v1"
+@test "sam-node run with token reaches online state" {
+ log_file="$TEST_TMPDIR/run.log"
+ "$SAM_NODE_BINARY" run --token test-token --listen /ip4/127.0.0.1/udp/0/quic-v1 --listen /ip4/127.0.0.1/tcp/0 >"$log_file" 2>&1 &
+ pid=$!
- "$SAM_BINARY" mesh get agents --watch -o json --listen "$watcher_listen" --dht-mode server --run-for 20s >"$watcher_log" 2>&1 &
- watcher_pid=$!
-
- watcher_peer=""
- for _ in {1..100}; do
- watcher_peer="$(grep -o 'peer_id=[^ ]*' "$watcher_log" | head -n1 | cut -d= -f2)"
- if [[ -n "$watcher_peer" ]]; then
+ online=""
+ for _ in {1..40}; do
+ if grep -q "SAM Node Online" "$log_file"; then
+ online="yes"
break
fi
sleep 0.1
done
- [[ -n "$watcher_peer" ]]
- "$SAM_BINARY" publish --skill writer --mcp-port 19100 --listen "$publisher_listen" --bootstrap "/ip4/127.0.0.1/udp/4320/quic-v1/p2p/${watcher_peer}" --dht-mode server --run-for 8s >"$publisher_log" 2>&1 &
- publisher_pid=$!
+ kill "$pid" >/dev/null 2>&1 || true
+ wait "$pid" >/dev/null 2>&1 || true
- publisher_peer=""
- for _ in {1..100}; do
- publisher_peer="$(grep -o 'peer_id=[^ ]*' "$publisher_log" | head -n1 | cut -d= -f2)"
- if [[ -n "$publisher_peer" ]]; then
- break
- fi
- sleep 0.1
- done
- [[ -n "$publisher_peer" ]]
+ [[ "$online" == "yes" ]]
+}
+
+@test "sam-node login enables run without --token" {
+ run bash -c "printf 'persisted-token\n' | '$SAM_NODE_BINARY' login"
+ [[ "$status" -eq 0 ]]
+
+ log_file="$TEST_TMPDIR/run-stored.log"
+ "$SAM_NODE_BINARY" run --listen /ip4/127.0.0.1/udp/0/quic-v1 --listen /ip4/127.0.0.1/tcp/0 >"$log_file" 2>&1 &
+ pid=$!
- found=""
- for _ in {1..120}; do
- if grep -q "\"peer_id\":\"$publisher_peer\"" "$watcher_log" && grep -q 'writer' "$watcher_log"; then
- found="yes"
+ online=""
+ for _ in {1..40}; do
+ if grep -q "SAM Node Online" "$log_file"; then
+ online="yes"
break
fi
- sleep 0.2
+ sleep 0.1
done
- kill "$publisher_pid" >/dev/null 2>&1 || true
- wait "$publisher_pid" >/dev/null 2>&1 || true
- kill "$watcher_pid" >/dev/null 2>&1 || true
- wait "$watcher_pid" >/dev/null 2>&1 || true
+ kill "$pid" >/dev/null 2>&1 || true
+ wait "$pid" >/dev/null 2>&1 || true
- [[ "$found" == "yes" ]]
-}
\ No newline at end of file
+ [[ "$online" == "yes" ]]
+}
diff --git a/tests/integration/call_test.go b/tests/integration/call_test.go
index c3ff13d7..1660d747 100644
--- a/tests/integration/call_test.go
+++ b/tests/integration/call_test.go
@@ -15,527 +15,19 @@
package integration_test
import (
- "bytes"
- "context"
- "encoding/json"
- "fmt"
- "os"
- "os/exec"
- "path/filepath"
- "strconv"
"strings"
- "syscall"
"testing"
"time"
-
- "github.com/libp2p/go-libp2p/core/peer"
- "github.com/modelcontextprotocol/go-sdk/jsonrpc"
- "github.com/modelcontextprotocol/go-sdk/mcp"
- "github.com/multiformats/go-multiaddr"
- "go.etcd.io/bbolt"
-
- internaldb "sam/internal/db"
- "sam/internal/testutils"
- "sam/pkg/economy"
- "sam/pkg/identity"
- samnet "sam/pkg/net"
- a2aprotocol "sam/pkg/protocol/a2a"
- protocol "sam/pkg/protocol/discovery"
- mcpprotocol "sam/pkg/protocol/mcp"
)
-const (
- callHelperEnv = "SAM_CALL_HELPER"
- callRoleEnv = "SAM_CALL_ROLE"
- callInfoEnv = "SAM_CALL_INFO_FILE"
- callRepDBEnv = "SAM_CALL_REPUTATION_DB"
- callProviderPIDEnv = "SAM_CALL_PROVIDER_PID"
- callRoleProvider = "provider"
- callRoleConsumer = "consumer"
- callCapability = "weather-bot"
- callRecordVersion = 1
-)
-
-type callPeerInfo struct {
- PeerID string `json:"peer_id"`
- Bootstrap string `json:"bootstrap"`
-}
-
-type callRoleProcess struct {
- cmd *exec.Cmd
- stdout bytes.Buffer
- stderr bytes.Buffer
-}
-
-func TestA2ACallIntegration(t *testing.T) {
- if os.Getenv(callHelperEnv) == "1" {
- if err := runCallRole(); err != nil {
- t.Fatalf("call helper failed: %v", err)
- }
- return
- }
-
- testutils.Run(t, func(t *testing.T) {
- runCallIntegration(t)
- })
-}
-
-func runCallIntegration(t *testing.T) {
- t.Helper()
-
- tmpDir := t.TempDir()
- infoFile := filepath.Join(tmpDir, "provider.json")
- repDB := filepath.Join(tmpDir, "reputation.db")
-
- provider := startCallRoleProcess(t, callRoleProvider, map[string]string{
- callInfoEnv: infoFile,
- })
- t.Cleanup(func() {
- if t.Failed() {
- t.Logf("provider stdout:\n%s\nprovider stderr:\n%s", provider.stdout.String(), provider.stderr.String())
- }
- })
- defer stopCallRoleProcess(provider)
-
- if err := waitForCallInfoFile(infoFile, 15*time.Second); err != nil {
- t.Fatalf("provider did not write info file in time: %v\nprovider stdout:\n%s\nprovider stderr:\n%s",
- err, provider.stdout.String(), provider.stderr.String())
- }
-
- consumer := startCallRoleProcess(t, callRoleConsumer, map[string]string{
- callInfoEnv: infoFile,
- callRepDBEnv: repDB,
- callProviderPIDEnv: strconv.Itoa(provider.cmd.Process.Pid),
- })
- t.Cleanup(func() {
- if t.Failed() {
- t.Logf("consumer stdout:\n%s\nconsumer stderr:\n%s", consumer.stdout.String(), consumer.stderr.String())
- }
- })
- defer stopCallRoleProcess(consumer)
-
- waitCallRoleExit(t, consumer, 30*time.Second)
- if consumer.cmd.ProcessState.ExitCode() != 0 {
- t.Fatalf("consumer process failed\nstdout:\n%s\nstderr:\n%s",
- consumer.stdout.String(), consumer.stderr.String())
- }
-
- db, err := bbolt.Open(repDB, 0o600, &bbolt.Options{Timeout: 2 * time.Second})
- if err != nil {
- t.Fatalf("opening reputation DB: %v", err)
- }
- defer func() { _ = db.Close() }()
-
- type reputationRecord struct {
- PeerID string `json:"peer_id"`
- OK bool `json:"ok"`
- LatencyMS int64 `json:"latency_ms,omitempty"`
- ErrorType string `json:"error_type,omitempty"`
- }
-
- codec := internaldb.JSONCodec{}
- successes := 0
- livenessFailures := 0
- err = db.View(func(tx *bbolt.Tx) error {
- bucket := tx.Bucket([]byte(internaldb.BucketReputation))
- if bucket == nil {
- return fmt.Errorf("missing reputation bucket")
- }
- return bucket.ForEach(func(_ []byte, value []byte) error {
- var rec reputationRecord
- if err := codec.Unmarshal(value, callRecordVersion, &rec, nil); err != nil {
- return err
- }
- if rec.OK {
- successes++
- }
- if !rec.OK && strings.EqualFold(rec.ErrorType, a2aprotocol.FailureTypeLiveness) {
- livenessFailures++
- }
- return nil
- })
- })
- if err != nil {
- t.Fatalf("reading reputation records: %v", err)
- }
- if successes == 0 {
- t.Fatalf("expected at least one success interaction")
- }
- if livenessFailures == 0 {
- t.Fatalf("expected at least one liveness failure interaction")
- }
-}
-
-func runCallRole() error {
- switch os.Getenv(callRoleEnv) {
- case callRoleProvider:
- return runCallProviderRole()
- case callRoleConsumer:
- return runCallConsumerRole()
- default:
- return fmt.Errorf("unknown call role %q", os.Getenv(callRoleEnv))
- }
-}
-
-func runCallProviderRole() error {
- ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
- defer cancel()
-
- node, err := newCallNode(0, nil)
- if err != nil {
- return err
- }
- if err := node.Start(ctx); err != nil {
- return fmt.Errorf("provider node start: %w", err)
- }
- providerPassport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{
- PeerID: node.PeerID().String(),
- FederationID: "default",
- Subject: "test-subject",
- })
- if err != nil {
- return fmt.Errorf("issuing provider passport biscuit: %w", err)
- }
- if err := identity.SetLocalPassport(node.Host(), "default", providerPassport); err != nil {
- return fmt.Errorf("setting provider local passport auth: %w", err)
- }
- // In a subprocess role, fire Stop asynchronously so the process can exit
- // promptly; the OS will clean up resources when the process terminates.
- defer func() {
- go func() { _ = node.Stop(context.Background()) }()
- }()
-
- // Register the A2A handler BEFORE writing the info file so the consumer
- // cannot connect and attempt Execute before the protocol is ready.
- a2aSvc, err := a2aprotocol.NewA2AService(node.Host(), delayedResponseConnector{delay: 1500 * time.Millisecond}, a2aprotocol.NopObserver{})
- if err != nil {
- return fmt.Errorf("provider A2A service setup: %w", err)
- }
- defer a2aSvc.Close()
-
- // Derive the bootstrap address from the actual listen addresses assigned
- // by the OS (we bound to port 0 to avoid fixed-port conflicts).
- // Filter to the first QUIC address to avoid picking up relay/circuit addrs.
- var quicAddr multiaddr.Multiaddr
- for _, a := range node.Host().Network().ListenAddresses() {
- s := a.String()
- if strings.Contains(s, "udp") && strings.Contains(s, "quic") {
- quicAddr = a
- break
- }
- }
- if quicAddr == nil {
- return fmt.Errorf("provider has no QUIC listen address after start; addrs: %v",
- node.Host().Network().ListenAddresses())
- }
- bootstrapAddr := quicAddr.String() + "/p2p/" + node.PeerID().String()
- if err := writeCallPeerInfo(os.Getenv(callInfoEnv), callPeerInfo{
- PeerID: node.PeerID().String(),
- Bootstrap: bootstrapAddr,
- }); err != nil {
- return err
- }
-
- priv := node.Host().Peerstore().PrivKey(node.PeerID())
- card, err := protocol.NewAgentCard(
- node.PeerID(),
- []string{callCapability},
- []mcpprotocol.Resource{{Name: "weather", Kind: "tool", Endpoint: "mcp://weather"}},
- priv,
- )
- if err != nil {
- return fmt.Errorf("provider card creation: %w", err)
- }
-
- pub, err := protocol.NewPublisher(node)
- if err != nil {
- return fmt.Errorf("provider publisher: %w", err)
- }
- if err := publishCallWithRetry(ctx, pub, card); err != nil {
- return fmt.Errorf("provider publish: %w", err)
- }
-
- discovery, err := protocol.NewDiscoveryService(node)
- if err != nil {
- return fmt.Errorf("provider discovery service: %w", err)
- }
- if err := discovery.RegisterLocalCard(card); err != nil {
- return fmt.Errorf("provider register card: %w", err)
- }
-
- <-ctx.Done()
- return nil
-}
-
-func runCallConsumerRole() error {
- ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
- defer cancel()
-
- providerPID, err := strconv.Atoi(os.Getenv(callProviderPIDEnv))
- if err != nil || providerPID <= 0 {
- return fmt.Errorf("invalid provider pid: %q", os.Getenv(callProviderPIDEnv))
- }
-
- info, err := waitCallPeerInfo(ctx, os.Getenv(callInfoEnv))
- if err != nil {
- return err
- }
- bootstrap, err := multiaddr.NewMultiaddr(info.Bootstrap)
- if err != nil {
- return fmt.Errorf("parsing bootstrap addr: %w", err)
- }
- providerID, err := peer.Decode(info.PeerID)
- if err != nil {
- return fmt.Errorf("decoding provider peer ID: %w", err)
- }
- providerAddrInfo, err := peer.AddrInfoFromP2pAddr(bootstrap)
- if err != nil {
- return fmt.Errorf("building provider addr info: %w", err)
- }
-
- node, err := newCallNode(0, []multiaddr.Multiaddr{bootstrap})
- if err != nil {
- return err
- }
- if err := node.Start(ctx); err != nil {
- return fmt.Errorf("consumer node start: %w", err)
- }
- passport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{
- PeerID: node.PeerID().String(),
- FederationID: "default",
- Subject: "test-subject",
- })
- if err != nil {
- return fmt.Errorf("issuing passport biscuit: %w", err)
- }
- if err := identity.SetLocalPassport(node.Host(), "default", passport); err != nil {
- return fmt.Errorf("setting local passport auth: %w", err)
- }
- // In a subprocess role, fire Stop asynchronously so the process can exit
- // promptly; the OS will clean up resources when the process terminates.
- defer func() {
- go func() { _ = node.Stop(context.Background()) }()
- }()
-
- if err := connectCallWithRetry(ctx, node, *providerAddrInfo); err != nil {
- return fmt.Errorf("connecting to provider bootstrap: %w", err)
- }
-
- // For call execution reliability in isolated namespaces, use the provider peer
- // directly after bootstrap connection instead of waiting for DHT convergence.
- target := peer.AddrInfo{ID: providerID, Addrs: node.Host().Peerstore().Addrs(providerID)}
-
- observer, err := a2aprotocol.NewBoltObserver(os.Getenv(callRepDBEnv))
- if err != nil {
- return fmt.Errorf("creating bolt observer: %w", err)
- }
- defer func() { _ = observer.Close() }()
-
- req := a2aprotocol.ExecuteRequest{
- Target: target,
- Capability: callCapability,
- Biscuit: "integration-biscuit",
- Payment: economy.Micropayment{
- Amount: 1,
- Asset: "sam-credit",
- Nonce: "nonce-success",
- Capability: callCapability,
- },
- Request: []byte(`{"jsonrpc":"2.0","id":"sam-call","method":"message","params":{"message":"weather"}}`),
- }
-
- if _, err := a2aprotocol.Execute(ctx, node.Host(), req, observer); err != nil {
- return fmt.Errorf("expected initial call success, got: %w", err)
- }
-
- go func() {
- time.Sleep(200 * time.Millisecond)
- _ = syscall.Kill(providerPID, syscall.SIGKILL)
- }()
-
- req.Payment.Nonce = "nonce-failure"
- failCtx, failCancel := context.WithTimeout(ctx, 5*time.Second)
- defer failCancel()
- if _, err := a2aprotocol.Execute(failCtx, node.Host(), req, observer); err == nil {
- return fmt.Errorf("expected second call to fail after provider kill")
- }
-
- return nil
-}
-
-func newCallNode(port int, bootstrap []multiaddr.Multiaddr) (samnet.Node, error) {
- listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/udp/%d/quic-v1", port))
- if err != nil {
- return nil, fmt.Errorf("building listen address: %w", err)
- }
- key, err := samnet.GenerateKey()
- if err != nil {
- return nil, fmt.Errorf("generating node key: %w", err)
- }
- return samnet.New(
- samnet.WithPrivateKey(key),
- samnet.WithListenAddrs(listen),
- samnet.WithBootstrapPeers(bootstrap...),
- samnet.WithDHTMode(samnet.DHTModeServer),
- )
-}
-
-func publishCallWithRetry(ctx context.Context, pub *protocol.Publisher, card *protocol.AgentCard) error {
- ticker := time.NewTicker(250 * time.Millisecond)
- defer ticker.Stop()
- var last error
- for {
- if err := pub.Publish(ctx, card); err == nil {
- return nil
- } else {
- last = err
- }
- select {
- case <-ctx.Done():
- return last
- case <-ticker.C:
- }
- }
-}
-
-func connectCallWithRetry(ctx context.Context, node samnet.Node, pi peer.AddrInfo) error {
- ticker := time.NewTicker(250 * time.Millisecond)
- defer ticker.Stop()
- var last error
- for {
- if err := node.Connect(ctx, pi); err == nil {
- return nil
- } else {
- last = err
- }
- select {
- case <-ctx.Done():
- return last
- case <-ticker.C:
- }
- }
-}
-
-func writeCallPeerInfo(path string, info callPeerInfo) error {
- if path == "" {
- return fmt.Errorf("%s is required", callInfoEnv)
- }
- if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
- return fmt.Errorf("creating info directory: %w", err)
- }
- data, err := json.Marshal(info)
+func TestSamNodeLoginHelp(t *testing.T) {
+ nodeBin := buildBinary(t, "./cmd/sam-node")
+ stdout, stderr, err := runCommand(t, repoRoot(t), 10*time.Second, nil, "", nodeBin, "login", "--help")
if err != nil {
- return fmt.Errorf("encoding peer info: %w", err)
- }
- return os.WriteFile(path, data, 0o600)
-}
-
-func waitCallPeerInfo(ctx context.Context, path string) (callPeerInfo, error) {
- ticker := time.NewTicker(200 * time.Millisecond)
- defer ticker.Stop()
- for {
- data, err := os.ReadFile(path)
- if err == nil {
- var info callPeerInfo
- if err := json.Unmarshal(data, &info); err == nil && info.PeerID != "" {
- return info, nil
- }
- }
- select {
- case <-ctx.Done():
- return callPeerInfo{}, fmt.Errorf("waiting for provider info file: %w", ctx.Err())
- case <-ticker.C:
- }
- }
-}
-
-func waitForCallInfoFile(path string, timeout time.Duration) error {
- ctx, cancel := context.WithTimeout(context.Background(), timeout)
- defer cancel()
- _, err := waitCallPeerInfo(ctx, path)
- return err
-}
-
-func startCallRoleProcess(t *testing.T, role string, env map[string]string) *callRoleProcess {
- t.Helper()
- p := &callRoleProcess{}
- cmd := exec.Command(os.Args[0], "-test.run=TestA2ACallIntegration$", "-test.v=true")
- cmd.Env = append(os.Environ(), callHelperEnv+"=1", callRoleEnv+"="+role)
- for k, v := range env {
- cmd.Env = append(cmd.Env, k+"="+v)
- }
- cmd.Stdout = &p.stdout
- cmd.Stderr = &p.stderr
- if err := cmd.Start(); err != nil {
- t.Fatalf("starting %s role process: %v", role, err)
- }
- p.cmd = cmd
- return p
-}
-
-func waitCallRoleExit(t *testing.T, p *callRoleProcess, timeout time.Duration) {
- t.Helper()
- done := make(chan error, 1)
- go func() {
- done <- p.cmd.Wait()
- }()
- select {
- case err := <-done:
- if err != nil {
- t.Fatalf("role process exited with error: %v", err)
- }
- case <-time.After(timeout):
- t.Logf("stdout:\n%s\nstderr:\n%s", p.stdout.String(), p.stderr.String())
- t.Fatalf("role process did not exit in %s", timeout)
+ t.Fatalf("sam-node login --help failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout, stderr)
}
-}
-
-func stopCallRoleProcess(p *callRoleProcess) {
- if p == nil || p.cmd == nil || p.cmd.Process == nil {
- return
- }
- _ = p.cmd.Process.Kill()
- _, _ = p.cmd.Process.Wait()
-}
-
-type delayedResponseConnector struct {
- delay time.Duration
-}
-
-func (c delayedResponseConnector) Open(context.Context) (mcp.Transport, error) {
- return delayedResponseTransport(c), nil
-}
-
-type delayedResponseTransport struct {
- delay time.Duration
-}
-
-func (t delayedResponseTransport) Connect(context.Context) (mcp.Connection, error) {
- msg, err := jsonrpc.DecodeMessage([]byte(`{"jsonrpc":"2.0","id":"sam-call","result":{"content":"sunny"}}`))
- if err != nil {
- return nil, err
+ out := stdout + stderr
+ if !strings.Contains(out, "Establish sovereign identity with the Hub") {
+ t.Fatalf("unexpected help output:\n%s", out)
}
- return &delayedResponseConn{delay: t.delay, response: msg}, nil
-}
-
-type delayedResponseConn struct {
- delay time.Duration
- response jsonrpc.Message
-}
-
-func (c *delayedResponseConn) Read(context.Context) (jsonrpc.Message, error) {
- time.Sleep(c.delay)
- return c.response, nil
-}
-
-func (c *delayedResponseConn) Write(context.Context, jsonrpc.Message) error {
- return nil
-}
-
-func (c *delayedResponseConn) Close() error {
- return nil
-}
-
-func (c *delayedResponseConn) SessionID() string {
- return "integration-session"
}
diff --git a/tests/integration/cuj_test.go b/tests/integration/cuj_test.go
index 20a43675..3a83d20f 100644
--- a/tests/integration/cuj_test.go
+++ b/tests/integration/cuj_test.go
@@ -15,276 +15,39 @@
package integration_test
import (
- "bufio"
"context"
- "fmt"
- "io"
+ "os"
+ "path/filepath"
"strings"
"testing"
"time"
-
- "github.com/libp2p/go-libp2p/core/network"
- "github.com/libp2p/go-libp2p/core/peer"
- coreprotocol "github.com/libp2p/go-libp2p/core/protocol"
- "github.com/multiformats/go-multiaddr"
-
- "sam/internal/testutils"
- "sam/pkg/identity"
- samnet "sam/pkg/net"
)
-// CUJ-1 Stealth Audit: peers in the same mesh namespace discover each other
-// through DHT capability discovery.
-func TestCUJ1StealthAuditMeshDiscovery(t *testing.T) {
- if !testutils.IsSupported() {
- t.Skip("user namespaces not available")
- }
- testutils.Run(t, runCUJ1StealthAuditMeshDiscovery)
-}
-
-func runCUJ1StealthAuditMeshDiscovery(t *testing.T) {
- t.Helper()
- ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
- defer cancel()
-
- seed := cujStartNode(t, cujNodeConfig{mode: samnet.DHTModeServer})
-
- publisher := cujStartNode(t, cujNodeConfig{bootstrap: cujBootstrapAddrs(t, seed), mode: samnet.DHTModeServer})
- discovererA := cujStartNode(t, cujNodeConfig{bootstrap: cujBootstrapAddrs(t, seed), mode: samnet.DHTModeServer})
- discovererB := cujStartNode(t, cujNodeConfig{bootstrap: cujBootstrapAddrs(t, seed), mode: samnet.DHTModeServer})
-
- const capability = "risk-audit"
- if err := publisher.Announce(ctx, capability); err != nil {
- t.Fatalf("publisher announce: %v", err)
- }
-
- foundA := cujWaitDiscover(ctx, discovererA, capability, publisher.PeerID().String())
- if !foundA {
- t.Fatalf("mesh discovery failed: discovererA could not discover publisher capability")
- }
-
- foundB := cujWaitDiscover(ctx, discovererB, capability, publisher.PeerID().String())
- if !foundB {
- t.Fatalf("mesh discovery failed: discovererB could not discover publisher capability")
- }
-}
-
-// CUJ-2 Hole-Punch: verify relay-assisted connectivity path and attempt to
-// observe a direct (non-circuit) connection after initial circuit dial.
-//
-// In restricted CI/network environments DCUtR may not complete; in that case
-// the test validates relay path and skips direct-connection assertion.
-func TestCUJ2HolePunchRelayAssisted(t *testing.T) {
- if !testutils.IsSupported() {
- t.Skip("user namespaces not available")
- }
- testutils.Run(t, runCUJ2HolePunchRelayAssisted)
-}
-
-func runCUJ2HolePunchRelayAssisted(t *testing.T) {
- t.Helper()
- ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
- defer cancel()
-
- relayNode := cujStartNode(t, cujNodeConfig{relayService: true, mode: samnet.DHTModeServer})
- bootstrap := cujBootstrapAddrs(t, relayNode)
-
- caller := cujStartNode(t, cujNodeConfig{bootstrap: bootstrap, mode: samnet.DHTModeServer})
- target := cujStartNode(t, cujNodeConfig{bootstrap: bootstrap, mode: samnet.DHTModeServer})
-
- const protoID coreprotocol.ID = "/sam/cuj/holepunch/1.0"
- target.Host().SetStreamHandler(protoID, func(s network.Stream) {
- defer func() { _ = s.Close() }()
- r := bufio.NewReader(s)
- line, _ := r.ReadString('\n')
- _, _ = io.WriteString(s, line)
- })
-
- circuitAddr, err := cujRelayCircuitAddr(relayNode, target)
- if err != nil {
- t.Fatalf("building circuit address: %v", err)
- }
- if err := caller.Connect(ctx, circuitAddr); err != nil {
- t.Fatalf("relay-assisted connect failed: %v", err)
- }
-
- stream, err := caller.Host().NewStream(ctx, target.PeerID(), protoID)
- if err != nil {
- t.Fatalf("opening stream over relay-assisted path failed: %v", err)
- }
- if _, err := io.WriteString(stream, "hello\n"); err != nil {
- _ = stream.Close()
- t.Fatalf("writing stream payload: %v", err)
- }
- resp, err := bufio.NewReader(stream).ReadString('\n')
- _ = stream.Close()
- if err != nil {
- t.Fatalf("reading stream response: %v", err)
- }
- if strings.TrimSpace(resp) != "hello" {
- t.Fatalf("unexpected stream response: %q", resp)
- }
-
- directSeen := cujWaitForDirectConn(ctx, caller, target)
- if !directSeen {
- t.Skip("relay path verified; no direct non-circuit connection observed (DCUtR environment-dependent)")
- }
-}
-
-type cujNodeConfig struct {
- bootstrap []multiaddr.Multiaddr
- relayService bool
- mode samnet.DHTMode
-}
-
-func cujStartNode(t *testing.T, cfg cujNodeConfig) samnet.Node {
- t.Helper()
- listen, err := multiaddr.NewMultiaddr("/ip4/127.0.0.1/udp/0/quic-v1")
- if err != nil {
- t.Fatalf("creating listen addr: %v", err)
- }
- key, err := samnet.GenerateKey()
- if err != nil {
- t.Fatalf("generating key: %v", err)
- }
- opts := []samnet.Option{
- samnet.WithPrivateKey(key),
- samnet.WithListenAddrs(listen),
- samnet.WithDHTMode(cfg.mode),
- }
- if len(cfg.bootstrap) > 0 {
- opts = append(opts, samnet.WithBootstrapPeers(cfg.bootstrap...))
- }
- if cfg.relayService {
- opts = append(opts, samnet.WithRelayService())
- }
- n, err := samnet.New(opts...)
- if err != nil {
- t.Fatalf("creating node: %v", err)
- }
-
- if err := n.Start(context.Background()); err != nil {
- t.Fatalf("starting node: %v", err)
- }
-
- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
- defer cancel()
- passport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{
- PeerID: n.PeerID().String(),
- FederationID: "default",
- Subject: n.PeerID().String(),
- })
- if err != nil {
- t.Fatalf("issuing test passport: %v", err)
- }
- if err := identity.SetLocalPassport(n.Host(), "default", passport); err != nil {
- t.Fatalf("setting test passport: %v", err)
- }
-
- for _, bootstrapAddr := range cfg.bootstrap {
- pi, err := peer.AddrInfoFromP2pAddr(bootstrapAddr)
- if err != nil {
- continue
- }
- _ = cujConnectWithRetry(ctx, n, *pi)
- }
-
- t.Cleanup(func() {
- go func() { _ = n.Stop(context.Background()) }()
- })
- return n
-}
-
-func cujBootstrapAddrs(t *testing.T, n samnet.Node) []multiaddr.Multiaddr {
- t.Helper()
- for _, a := range n.Addrs() {
- if !strings.Contains(a.String(), "quic") {
- continue
- }
- full, err := multiaddr.NewMultiaddr(fmt.Sprintf("%s/p2p/%s", a.String(), n.PeerID()))
- if err == nil {
- return []multiaddr.Multiaddr{full}
- }
- }
- t.Fatalf("no bootstrap QUIC address found for %s", n.PeerID())
- return nil
-}
-
-func cujConnectWithRetry(ctx context.Context, n samnet.Node, pi peer.AddrInfo) error {
- ticker := time.NewTicker(250 * time.Millisecond)
- defer ticker.Stop()
- var last error
- for {
- if err := n.Connect(ctx, pi); err == nil {
- return nil
- } else {
- last = err
- }
- select {
- case <-ctx.Done():
- if last != nil {
- return last
- }
- return ctx.Err()
- case <-ticker.C:
- }
- }
-}
-
-func cujWaitDiscover(ctx context.Context, n samnet.Node, capability, expectedPeerID string) bool {
- ticker := time.NewTicker(300 * time.Millisecond)
- defer ticker.Stop()
-
- for {
- discoveryCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
- ch, err := n.Discover(discoveryCtx, capability)
- if err == nil {
- for ai := range ch {
- if ai.ID.String() == expectedPeerID {
- cancel()
- return true
- }
- }
- }
- cancel()
-
- select {
- case <-ctx.Done():
- return false
- case <-ticker.C:
- }
- }
-}
-
-func cujRelayCircuitAddr(relayNode, target samnet.Node) (peer.AddrInfo, error) {
- for _, relayAddr := range relayNode.Addrs() {
- if !strings.Contains(relayAddr.String(), "quic") {
- continue
- }
- circuit := fmt.Sprintf("%s/p2p/%s/p2p-circuit/p2p/%s", relayAddr.String(), relayNode.PeerID(), target.PeerID())
- ma, err := multiaddr.NewMultiaddr(circuit)
- if err != nil {
- continue
- }
- return peer.AddrInfo{ID: target.PeerID(), Addrs: []multiaddr.Multiaddr{ma}}, nil
- }
- return peer.AddrInfo{}, fmt.Errorf("no relay QUIC address available")
-}
-
-func cujWaitForDirectConn(ctx context.Context, a, b samnet.Node) bool {
- ticker := time.NewTicker(400 * time.Millisecond)
- defer ticker.Stop()
- for {
- conns := a.Host().Network().ConnsToPeer(b.PeerID())
- for _, c := range conns {
- if !strings.Contains(c.RemoteMultiaddr().String(), "p2p-circuit") {
- return true
- }
- }
- select {
- case <-ctx.Done():
- return false
- case <-ticker.C:
- }
+func TestSamNodeRunWithManualTokenStarts(t *testing.T) {
+ nodeBin := buildBinary(t, "./cmd/sam-node")
+ tmpHome := t.TempDir()
+ env := append(os.Environ(),
+ "HOME="+tmpHome,
+ "XDG_CONFIG_HOME="+filepath.Join(tmpHome, ".config"),
+ )
+
+ stdout, stderr, err := runCommand(
+ t,
+ repoRoot(t),
+ 3*time.Second,
+ env,
+ "",
+ nodeBin,
+ "run",
+ "--token", "test-token",
+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",
+ "--listen", "/ip4/127.0.0.1/tcp/0",
+ )
+ if err != context.DeadlineExceeded {
+ t.Fatalf("expected run command to keep running until timeout, got: %v\nstdout:\n%s\nstderr:\n%s", err, stdout, stderr)
+ }
+ out := stdout + stderr
+ if !strings.Contains(out, "SAM Node Online") {
+ t.Fatalf("node did not reach online state:\n%s", out)
}
}
diff --git a/tests/integration/mesh_test.go b/tests/integration/mesh_test.go
index 8aa01d70..0fe329b4 100644
--- a/tests/integration/mesh_test.go
+++ b/tests/integration/mesh_test.go
@@ -14,718 +14,20 @@
package integration_test
-// TestMeshDiscovery is an end-to-end integration test for the SAM mesh:
-//
-// Agent 1 ("publisher") starts a DHT server node, signs an AgentCard with
-// the "agent.summarize" capability, publishes it to the DHT, and registers
-// an MCP bridge backed by a loopback echo connector.
-//
-// Agent 2 ("subscriber") starts an independent DHT server node, connects to
-// Agent 1 as its bootstrap peer, discovers the published card via DHT, opens
-// a QUIC stream through the MCP bridge, and verifies the echo round-trip.
-//
-// Each agent runs in its own isolated network namespace (CLONE_NEWNET +
-// CLONE_NEWUSER). The test parent creates a veth pair and configures it using
-// the vishvananda/netlink library — no external tools required.
-
import (
- "bufio"
- "context"
- "encoding/json"
- "errors"
- "fmt"
- "io"
- "net"
- "os"
- "os/exec"
- "path/filepath"
- "runtime"
- "strconv"
- "syscall"
+ "strings"
"testing"
"time"
-
- "github.com/libp2p/go-libp2p/core/peer"
- "github.com/modelcontextprotocol/go-sdk/mcp"
- "github.com/multiformats/go-multiaddr"
- "github.com/vishvananda/netlink"
- "github.com/vishvananda/netns"
-
- "sam/internal/testutils"
- "sam/pkg/economy"
- "sam/pkg/identity"
- samnet "sam/pkg/net"
- protocol "sam/pkg/protocol/discovery"
- mcpprotocol "sam/pkg/protocol/mcp"
)
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const (
- meshHelperEnv = "SAM_MESH_HELPER"
- meshRoleEnv = "SAM_MESH_ROLE"
- meshInfoEnv = "SAM_MESH_INFO_FILE"
- meshIPEnv = "SAM_MESH_IP"
- meshPortEnv = "SAM_MESH_PORT"
- meshPublisherRole = "publisher"
- meshSubscriberRole = "subscriber"
- meshPublisherIP = "10.200.0.1"
- meshSubscriberIP = "10.200.0.2"
- meshPublisherPort = 4201
- meshSubscriberPort = 4202
- meshCapability = "weather-bot"
-)
-
-type meshPeerInfo struct {
- PeerID string `json:"peer_id"`
- Bootstrap string `json:"bootstrap"`
-}
-
-// ---------------------------------------------------------------------------
-// Top-level test entry point
-// ---------------------------------------------------------------------------
-
-// TestMeshDiscovery is the public test function. When re-invoked as a helper
-// subprocess it dispatches to the appropriate agent role.
-func TestMeshDiscovery(t *testing.T) {
- if os.Getenv(meshHelperEnv) == "1" {
- if err := runMeshHelperRole(); err != nil {
- t.Fatalf("mesh helper failed: %v", err)
- }
- return
- }
-
- testutils.Run(t, func(t *testing.T) {
- runMeshDiscovery(t)
- }, syscall.CLONE_NEWNET)
-}
-
-// ---------------------------------------------------------------------------
-// Orchestrator (runs in the outer user+net namespace)
-// ---------------------------------------------------------------------------
-
-func runMeshDiscovery(t *testing.T) {
- t.Helper()
-
- tmpDir := t.TempDir()
- infoFile := filepath.Join(tmpDir, "publisher.json")
-
- publisher := startMeshRoleProcess(t, meshPublisherRole, infoFile, meshPublisherIP, meshPublisherPort)
- defer stopMeshRoleProcess(publisher)
-
- subscriber := startMeshRoleProcess(t, meshSubscriberRole, infoFile, meshSubscriberIP, meshSubscriberPort)
- defer stopMeshRoleProcess(subscriber)
-
- // Assign veth interfaces before unblocking either agent so that both have
- // network connectivity from the moment they start QUIC listeners.
- configureMeshVethPair(t, publisher.cmd.Process.Pid, subscriber.cmd.Process.Pid)
-
- if _, err := io.WriteString(publisher.stdin, "start\n"); err != nil {
- t.Fatalf("unblocking publisher: %v", err)
- }
- if _, err := io.WriteString(subscriber.stdin, "start\n"); err != nil {
- t.Fatalf("unblocking subscriber: %v", err)
- }
-
- // Wait for publisher to be ready before checking subscriber exit.
- if err := waitForMeshInfoFile(infoFile, 15*time.Second); err != nil {
- t.Fatalf("publisher did not write info file in time: %v\npublisher stdout:\n%s\npublisher stderr:\n%s",
- err, publisher.stdout.String(), publisher.stderr.String())
- }
-
- waitMeshRoleExit(t, subscriber, 35*time.Second)
- if subscriber.cmd.ProcessState.ExitCode() != 0 {
- t.Fatalf("subscriber process failed\nstdout:\n%s\nstderr:\n%s",
- subscriber.stdout.String(), subscriber.stderr.String())
- }
-}
-
-// ---------------------------------------------------------------------------
-// Subprocess helper dispatcher
-// ---------------------------------------------------------------------------
-
-func runMeshHelperRole() error {
- // The orchestrator sends a single "start\n" line after configuring the
- // network so that both agents have IP connectivity before they open ports.
- reader := bufio.NewReader(os.Stdin)
- if _, err := reader.ReadString('\n'); err != nil {
- return fmt.Errorf("waiting for mesh start signal: %w", err)
- }
-
- switch os.Getenv(meshRoleEnv) {
- case meshPublisherRole:
- return runMeshPublisher()
- case meshSubscriberRole:
- return runMeshSubscriber()
- default:
- return fmt.Errorf("unknown mesh role %q", os.Getenv(meshRoleEnv))
- }
-}
-
-// ---------------------------------------------------------------------------
-// Agent 1 — Publisher
-// ---------------------------------------------------------------------------
-
-func runMeshPublisher() error {
- ctx, cancel := context.WithTimeout(context.Background(), 35*time.Second)
- defer cancel()
-
- port, err := parseMeshPort()
- if err != nil {
- return err
- }
-
- node, err := newMeshNode(port, samnet.DHTModeServer, nil)
- if err != nil {
- return err
- }
- if err := node.Start(ctx); err != nil {
- return fmt.Errorf("publisher node start: %w", err)
- }
- if err := meshConfigureNodePassport(ctx, node, "publisher"); err != nil {
- return fmt.Errorf("publisher passport setup: %w", err)
- }
- defer func() { _ = node.Stop(context.Background()) }()
-
- // Write the peer info before publishing so the subscriber can start
- // connecting as soon as the DHT bootstrap is ready.
- bootstrapAddr := fmt.Sprintf("/ip4/%s/udp/%d/quic-v1/p2p/%s",
- os.Getenv(meshIPEnv), port, node.PeerID())
- info := meshPeerInfo{PeerID: node.PeerID().String(), Bootstrap: bootstrapAddr}
- if err := writeMeshPeerInfo(os.Getenv(meshInfoEnv), info); err != nil {
- return err
- }
-
- priv := node.Host().Peerstore().PrivKey(node.PeerID())
- card, err := protocol.NewAgentCard(
- node.PeerID(),
- []string{meshCapability},
- []mcpprotocol.Resource{{Name: "summarizer", Kind: "tool", Endpoint: "mcp://summarizer"}},
- priv,
- )
- if err != nil {
- return fmt.Errorf("publisher card creation: %w", err)
- }
-
- pub, err := protocol.NewPublisher(node)
+func TestSamHubHelp(t *testing.T) {
+ hubBin := buildBinary(t, "./cmd/sam-hub")
+ stdout, stderr, err := runCommand(t, repoRoot(t), 10*time.Second, nil, "", hubBin, "--help")
if err != nil {
- return fmt.Errorf("publisher: %w", err)
+ t.Fatalf("sam-hub --help failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout, stderr)
}
- if err := meshPublishWithRetry(ctx, pub, card); err != nil {
- return fmt.Errorf("publisher publish: %w", err)
+ out := stdout + stderr
+ if !strings.Contains(out, "Sovereign Agent Mesh - Multi-Transport Hub") {
+ t.Fatalf("unexpected help output:\n%s", out)
}
-
- discovery, err := protocol.NewDiscoveryService(node)
- if err != nil {
- return fmt.Errorf("publisher discovery service: %w", err)
- }
- if err := discovery.RegisterLocalCard(card); err != nil {
- return fmt.Errorf("publisher register card: %w", err)
- }
-
- // meshAllowVerifier accepts any token so the subscriber test needs no real Biscuit token.
- if _, err := mcpprotocol.NewMCPBridge(node.Host(), meshAllowVerifier{}, meshEchoConnector{}); err != nil {
- return fmt.Errorf("publisher bridge setup: %w", err)
- }
-
- // Stay online until the context is cancelled (subscriber completed or timeout).
- <-ctx.Done()
- return nil
-}
-
-// ---------------------------------------------------------------------------
-// Agent 2 — Subscriber
-// ---------------------------------------------------------------------------
-
-func runMeshSubscriber() error {
- ctx, cancel := context.WithTimeout(context.Background(), 25*time.Second)
- defer cancel()
-
- port, err := parseMeshPort()
- if err != nil {
- return err
- }
-
- info, err := waitMeshPeerInfo(ctx, os.Getenv(meshInfoEnv))
- if err != nil {
- return err
- }
-
- bootstrap, err := multiaddr.NewMultiaddr(info.Bootstrap)
- if err != nil {
- return fmt.Errorf("parsing bootstrap addr: %w", err)
- }
- publisherID, err := peer.Decode(info.PeerID)
- if err != nil {
- return fmt.Errorf("decoding publisher peer ID: %w", err)
- }
- publisherAddrInfo, err := peer.AddrInfoFromP2pAddr(bootstrap)
- if err != nil {
- return fmt.Errorf("building publisher addr info: %w", err)
- }
-
- // Both peers must run as DHT servers in an isolated two-node mesh so that
- // DHT records are visible to each other without external routing tables.
- node, err := newMeshNode(port, samnet.DHTModeServer, []multiaddr.Multiaddr{bootstrap})
- if err != nil {
- return err
- }
- if err := node.Start(ctx); err != nil {
- return fmt.Errorf("subscriber node start: %w", err)
- }
- if err := meshConfigureNodePassport(ctx, node, "subscriber"); err != nil {
- return fmt.Errorf("subscriber passport setup: %w", err)
- }
- defer func() { _ = node.Stop(context.Background()) }()
-
- if err := meshConnectWithRetry(ctx, node, *publisherAddrInfo); err != nil {
- return fmt.Errorf("connecting to publisher bootstrap: %w", err)
- }
-
- discovery, err := protocol.NewDiscoveryService(node)
- if err != nil {
- return fmt.Errorf("subscriber discovery service: %w", err)
- }
-
- // 1. Discover the published capability via DHT and connect.
- peerIDs, err := meshDiscoverAndConnectWithRetry(ctx, discovery, meshCapability)
- if err != nil {
- return fmt.Errorf("subscriber DHT discovery failed: %w", err)
- }
- if len(peerIDs) == 0 {
- return fmt.Errorf("expected at least one peer for capability %q, got none", meshCapability)
- }
-
- // 2. Verify the discovered AgentCard contains the expected capability and a
- // valid signature from the publisher's peer key.
- cards, err := meshDiscoverCardsWithRetry(ctx, discovery, meshCapability)
- if err != nil {
- return fmt.Errorf("subscriber card discovery failed: %w", err)
- }
- if len(cards) == 0 {
- return fmt.Errorf("expected at least one AgentCard for capability %q", meshCapability)
- }
- validated := false
- for _, card := range cards {
- if card.PeerID != publisherID.String() {
- continue
- }
- if err := card.Verify(); err != nil {
- return fmt.Errorf("publisher card signature verification failed: %w", err)
- }
- validated = true
- break
- }
- if !validated {
- return fmt.Errorf("publisher card not found in discovered results")
- }
-
- // 3. Open a QUIC/MCP bridge stream to the publisher and do an echo round-trip.
- bridge, err := mcpprotocol.NewMCPBridge(node.Host(), meshAllowVerifier{}, meshEchoConnector{})
- if err != nil {
- return fmt.Errorf("subscriber bridge setup: %w", err)
- }
- if err := meshEchoRoundTrip(ctx, bridge, publisherID); err != nil {
- return fmt.Errorf("MCP echo round-trip failed: %w", err)
- }
-
- return nil
-}
-
-// ---------------------------------------------------------------------------
-// Round-trip helper
-// ---------------------------------------------------------------------------
-
-func meshEchoRoundTrip(ctx context.Context, bridge *mcpprotocol.MCPBridge, target peer.ID) error {
- stream, err := bridge.Open(ctx, target, mcpprotocol.BridgeOpenRequest{
- BiscuitToken: "mesh-token",
- Amount: 1,
- Asset: "sam-credit",
- Nonce: "mesh-nonce",
- Capability: meshCapability,
- })
- if err != nil {
- return fmt.Errorf("opening bridge stream: %w", err)
- }
- defer func() { _ = stream.Close() }()
-
- payload := []byte("{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"ping\"}\n")
- if _, err := stream.Write(payload); err != nil {
- return fmt.Errorf("writing payload: %w", err)
- }
-
- received := make([]byte, len(payload))
- if _, err := io.ReadFull(stream, received); err != nil {
- return fmt.Errorf("reading echo response: %w", err)
- }
- if string(received) != string(payload) {
- return fmt.Errorf("echo mismatch: want %q, got %q", string(payload), string(received))
- }
- return nil
-}
-
-func meshConfigureNodePassport(ctx context.Context, node samnet.Node, subject string) error {
- passport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{
- PeerID: node.PeerID().String(),
- FederationID: "default",
- Subject: subject,
- })
- if err != nil {
- return err
- }
- return identity.SetLocalPassport(node.Host(), "default", passport)
-}
-
-// ---------------------------------------------------------------------------
-// Retry helpers (mesh-specific, same pattern as p2p_test.go)
-// ---------------------------------------------------------------------------
-
-func meshPublishWithRetry(ctx context.Context, pub *protocol.Publisher, card *protocol.AgentCard) error {
- ticker := time.NewTicker(250 * time.Millisecond)
- defer ticker.Stop()
- var last error
- for {
- if err := pub.Publish(ctx, card); err == nil {
- return nil
- } else {
- last = err
- }
- select {
- case <-ctx.Done():
- if last != nil { //nolint:staticcheck // last is assigned only on error in the loop
- return fmt.Errorf("publish did not converge: %w", last)
- }
- return ctx.Err()
- case <-ticker.C:
- }
- }
-}
-
-func meshConnectWithRetry(ctx context.Context, node samnet.Node, pi peer.AddrInfo) error {
- ticker := time.NewTicker(250 * time.Millisecond)
- defer ticker.Stop()
- var last error
- for {
- if err := node.Connect(ctx, pi); err == nil {
- return nil
- } else {
- last = err
- }
- select {
- case <-ctx.Done():
- if last != nil { //nolint:staticcheck // last is assigned only on error in the loop
- return last
- }
- return ctx.Err()
- case <-ticker.C:
- }
- }
-}
-
-func meshDiscoverAndConnectWithRetry(ctx context.Context, svc *protocol.DiscoveryService, cap string) ([]peer.ID, error) {
- ticker := time.NewTicker(300 * time.Millisecond)
- defer ticker.Stop()
- var last error
- for {
- ids, err := svc.DiscoverAndConnect(ctx, cap)
- if len(ids) > 0 {
- return ids, nil
- }
- if err != nil {
- last = err
- }
- select {
- case <-ctx.Done():
- if last != nil {
- return nil, fmt.Errorf("no peers for capability %q: %w", cap, last)
- }
- return nil, fmt.Errorf("no peers for capability %q: %w", cap, ctx.Err())
- case <-ticker.C:
- }
- }
-}
-
-func meshDiscoverCardsWithRetry(ctx context.Context, svc *protocol.DiscoveryService, cap string) ([]*protocol.AgentCard, error) {
- ticker := time.NewTicker(300 * time.Millisecond)
- defer ticker.Stop()
- var last error
- for {
- cards, err := svc.Discover(ctx, cap)
- if err == nil && len(cards) > 0 {
- return cards, nil
- }
- if err != nil {
- last = err
- }
- select {
- case <-ctx.Done():
- if last != nil {
- return nil, fmt.Errorf("card discovery for %q: %w", cap, last)
- }
- return nil, fmt.Errorf("no cards for capability %q: %w", cap, ctx.Err())
- case <-ticker.C:
- }
- }
-}
-
-// ---------------------------------------------------------------------------
-// Node factory
-// ---------------------------------------------------------------------------
-
-func newMeshNode(port int, mode samnet.DHTMode, bootstrap []multiaddr.Multiaddr) (samnet.Node, error) {
- listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/0.0.0.0/udp/%d/quic-v1", port))
- if err != nil {
- return nil, fmt.Errorf("building listen address: %w", err)
- }
- key, err := samnet.GenerateKey()
- if err != nil {
- return nil, fmt.Errorf("generating node key: %w", err)
- }
- return samnet.New(
- samnet.WithPrivateKey(key),
- samnet.WithListenAddrs(listen),
- samnet.WithBootstrapPeers(bootstrap...),
- samnet.WithDHTMode(mode),
- )
-}
-
-// ---------------------------------------------------------------------------
-// Process management
-// (roleProcess is defined in p2p_test.go; reuse it here)
-// ---------------------------------------------------------------------------
-
-func startMeshRoleProcess(t *testing.T, role, infoFile, ip string, port int) *roleProcess {
- t.Helper()
- proc := &roleProcess{}
- cmd := exec.Command(os.Args[0], "-test.run=TestMeshDiscovery$", "-test.v=true")
- cmd.Env = append(os.Environ(),
- meshHelperEnv+"=1",
- meshRoleEnv+"="+role,
- meshInfoEnv+"="+infoFile,
- meshIPEnv+"="+ip,
- meshPortEnv+"="+strconv.Itoa(port),
- )
- cmd.SysProcAttr = &syscall.SysProcAttr{
- Cloneflags: syscall.CLONE_NEWUSER | syscall.CLONE_NEWNET,
- UidMappings: []syscall.SysProcIDMap{{ContainerID: 0, HostID: os.Getuid(), Size: 1}},
- GidMappings: []syscall.SysProcIDMap{{ContainerID: 0, HostID: os.Getgid(), Size: 1}},
- GidMappingsEnableSetgroups: false,
- }
- stdin, err := cmd.StdinPipe()
- if err != nil {
- t.Fatalf("creating %s stdin pipe: %v", role, err)
- }
- proc.stdin = stdin
- cmd.Stdout = &proc.stdout
- cmd.Stderr = &proc.stderr
- if err := cmd.Start(); err != nil {
- t.Fatalf("starting %s process: %v", role, err)
- }
- proc.cmd = cmd
- return proc
-}
-
-func stopMeshRoleProcess(proc *roleProcess) {
- if proc == nil || proc.cmd == nil || proc.cmd.Process == nil {
- return
- }
- _ = proc.stdin.Close()
- _ = proc.cmd.Process.Kill()
- _, _ = proc.cmd.Process.Wait()
-}
-
-func waitMeshRoleExit(t *testing.T, proc *roleProcess, timeout time.Duration) {
- t.Helper()
- done := make(chan error, 1)
- go func() { done <- proc.cmd.Wait() }()
- select {
- case err := <-done:
- if err != nil {
- t.Fatalf("role process wait failed: %v\nstdout:\n%s\nstderr:\n%s",
- err, proc.stdout.String(), proc.stderr.String())
- }
- case <-time.After(timeout):
- t.Fatalf("role process timed out\nstdout:\n%s\nstderr:\n%s",
- proc.stdout.String(), proc.stderr.String())
- }
-}
-
-// ---------------------------------------------------------------------------
-// Network namespace helpers
-// ---------------------------------------------------------------------------
-
-func configureMeshVethPair(t *testing.T, publisherPID, subscriberPID int) {
- t.Helper()
- if err := netlink.LinkAdd(&netlink.Veth{
- LinkAttrs: netlink.LinkAttrs{Name: "meshveth-p"},
- PeerName: "meshveth-s",
- }); err != nil {
- t.Fatalf("creating mesh veth pair: %v", err)
- }
-
- pubLink, err := netlink.LinkByName("meshveth-p")
- if err != nil {
- t.Fatalf("finding publisher veth: %v", err)
- }
- subLink, err := netlink.LinkByName("meshveth-s")
- if err != nil {
- t.Fatalf("finding subscriber veth: %v", err)
- }
-
- if err := netlink.LinkSetNsPid(pubLink, publisherPID); err != nil {
- t.Fatalf("moving publisher veth to pid %d: %v", publisherPID, err)
- }
- if err := netlink.LinkSetNsPid(subLink, subscriberPID); err != nil {
- t.Fatalf("moving subscriber veth to pid %d: %v", subscriberPID, err)
- }
-
- configureMeshLinkInNetNS(t, publisherPID, "meshveth-p", meshPublisherIP+"/24")
- configureMeshLinkInNetNS(t, subscriberPID, "meshveth-s", meshSubscriberIP+"/24")
-}
-
-func configureMeshLinkInNetNS(t *testing.T, pid int, linkName, cidr string) {
- t.Helper()
- runtime.LockOSThread()
- defer runtime.UnlockOSThread()
-
- originalNS, err := netns.Get()
- if err != nil {
- t.Fatalf("getting current netns: %v", err)
- }
- defer func() { _ = originalNS.Close() }()
-
- targetNS, err := netns.GetFromPid(pid)
- if err != nil {
- t.Fatalf("getting netns for pid %d: %v", pid, err)
- }
- defer func() { _ = targetNS.Close() }()
-
- if err := netns.Set(targetNS); err != nil {
- t.Fatalf("entering netns for pid %d: %v", pid, err)
- }
- defer func() {
- if err := netns.Set(originalNS); err != nil {
- t.Fatalf("restoring original netns: %v", err)
- }
- }()
-
- lo, err := netlink.LinkByName("lo")
- if err != nil {
- t.Fatalf("getting loopback in netns pid %d: %v", pid, err)
- }
- if err := netlink.LinkSetUp(lo); err != nil {
- t.Fatalf("bringing loopback up in netns pid %d: %v", pid, err)
- }
-
- link, err := netlink.LinkByName(linkName)
- if err != nil {
- t.Fatalf("getting link %s in netns pid %d: %v", linkName, pid, err)
- }
- addr, err := netlink.ParseAddr(cidr)
- if err != nil {
- t.Fatalf("parsing cidr %s: %v", cidr, err)
- }
- if err := netlink.AddrAdd(link, addr); err != nil {
- t.Fatalf("assigning addr %s to %s in pid %d: %v", cidr, linkName, pid, err)
- }
- if err := netlink.LinkSetUp(link); err != nil {
- t.Fatalf("bringing link %s up in netns pid %d: %v", linkName, pid, err)
- }
-}
-
-// ---------------------------------------------------------------------------
-// File I/O helpers
-// ---------------------------------------------------------------------------
-
-func writeMeshPeerInfo(path string, info meshPeerInfo) error {
- f, err := os.Create(path)
- if err != nil {
- return fmt.Errorf("creating mesh info file: %w", err)
- }
- defer func() { _ = f.Close() }()
- return json.NewEncoder(f).Encode(info)
-}
-
-func waitMeshPeerInfo(ctx context.Context, path string) (meshPeerInfo, error) {
- for {
- data, err := os.ReadFile(path)
- if err == nil {
- var info meshPeerInfo
- if unmarshalErr := json.Unmarshal(data, &info); unmarshalErr != nil {
- return meshPeerInfo{}, fmt.Errorf("decoding mesh info: %w", unmarshalErr)
- }
- return info, nil
- }
- if !errors.Is(err, os.ErrNotExist) {
- return meshPeerInfo{}, fmt.Errorf("reading mesh info: %w", err)
- }
- select {
- case <-ctx.Done():
- return meshPeerInfo{}, fmt.Errorf("waiting for mesh info file: %w", ctx.Err())
- case <-time.After(100 * time.Millisecond):
- }
- }
-}
-
-func waitForMeshInfoFile(path string, timeout time.Duration) error {
- deadline := time.Now().Add(timeout)
- for {
- if _, err := os.Stat(path); err == nil {
- return nil
- }
- if time.Now().After(deadline) {
- return fmt.Errorf("timed out waiting for %s", path)
- }
- time.Sleep(100 * time.Millisecond)
- }
-}
-
-func parseMeshPort() (int, error) {
- raw := os.Getenv(meshPortEnv)
- if raw == "" {
- return 0, fmt.Errorf("missing %s", meshPortEnv)
- }
- p, err := strconv.Atoi(raw)
- if err != nil || p <= 0 {
- return 0, fmt.Errorf("invalid mesh port %q", raw)
- }
- return p, nil
-}
-
-// ---------------------------------------------------------------------------
-// Stub verifier — accepts any micropayment token (mesh test has no real Biscuit)
-// ---------------------------------------------------------------------------
-
-type meshAllowVerifier struct{}
-
-func (meshAllowVerifier) Verify(_ context.Context, _ economy.VerifyRequest) (*economy.VerifyDecision, error) {
- return &economy.VerifyDecision{Subject: "peer:mesh"}, nil
-}
-
-// ---------------------------------------------------------------------------
-// Stub MCP connector — loopback echo server
-// ---------------------------------------------------------------------------
-
-type meshEchoConnector struct{}
-
-func (meshEchoConnector) Open(context.Context) (mcp.Transport, error) {
- a, b := net.Pipe()
- go func() {
- defer func() { _ = b.Close() }()
- buf := make([]byte, 32*1024)
- for {
- n, err := b.Read(buf)
- if n > 0 {
- if _, werr := b.Write(buf[:n]); werr != nil {
- return
- }
- }
- if err != nil {
- return
- }
- }
- }()
- return &mcp.IOTransport{Reader: a, Writer: a}, nil
}
diff --git a/tests/integration/minimal_helpers_test.go b/tests/integration/minimal_helpers_test.go
new file mode 100644
index 00000000..ae2f8476
--- /dev/null
+++ b/tests/integration/minimal_helpers_test.go
@@ -0,0 +1,82 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package integration_test
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "os/exec"
+ "path/filepath"
+ "runtime"
+ "testing"
+ "time"
+)
+
+func repoRoot(t *testing.T) string {
+ t.Helper()
+ _, thisFile, _, ok := runtime.Caller(0)
+ if !ok {
+ t.Fatal("unable to resolve test file path")
+ }
+ return filepath.Clean(filepath.Join(filepath.Dir(thisFile), "..", ".."))
+}
+
+func buildBinary(t *testing.T, pkgPath string) string {
+ t.Helper()
+ root := repoRoot(t)
+ out := filepath.Join(t.TempDir(), filepath.Base(pkgPath))
+ cmd := exec.Command("go", "build", "-o", out, pkgPath)
+ cmd.Dir = root
+ if output, err := cmd.CombinedOutput(); err != nil {
+ t.Fatalf("building %s failed: %v\n%s", pkgPath, err, string(output))
+ }
+ return out
+}
+
+func runCommand(
+ t *testing.T,
+ cwd string,
+ timeout time.Duration,
+ env []string,
+ stdin string,
+ name string,
+ args ...string,
+) (string, string, error) {
+ t.Helper()
+
+ ctx, cancel := context.WithTimeout(context.Background(), timeout)
+ defer cancel()
+
+ cmd := exec.CommandContext(ctx, name, args...)
+ cmd.Dir = cwd
+ if len(env) > 0 {
+ cmd.Env = append(cmd.Env, env...)
+ }
+ if stdin != "" {
+ cmd.Stdin = bytes.NewBufferString(stdin)
+ }
+
+ var stdout bytes.Buffer
+ var stderr bytes.Buffer
+ cmd.Stdout = &stdout
+ cmd.Stderr = &stderr
+
+ err := cmd.Run()
+ if errors.Is(ctx.Err(), context.DeadlineExceeded) {
+ return stdout.String(), stderr.String(), context.DeadlineExceeded
+ }
+ return stdout.String(), stderr.String(), err
+}
diff --git a/tests/integration/p2p_test.go b/tests/integration/p2p_test.go
index 47184373..fd410873 100644
--- a/tests/integration/p2p_test.go
+++ b/tests/integration/p2p_test.go
@@ -15,675 +15,26 @@
package integration_test
import (
- "bufio"
- "bytes"
- "context"
- "encoding/json"
- "errors"
- "fmt"
- "io"
- "net"
"os"
- "os/exec"
"path/filepath"
- "runtime"
- "strconv"
"strings"
- "syscall"
"testing"
"time"
-
- "github.com/libp2p/go-libp2p/core/peer"
- "github.com/modelcontextprotocol/go-sdk/mcp"
- "github.com/multiformats/go-multiaddr"
- "github.com/vishvananda/netlink"
- "github.com/vishvananda/netns"
-
- "sam/internal/testutils"
- "sam/pkg/economy"
- "sam/pkg/identity"
- samnet "sam/pkg/net"
- protocol "sam/pkg/protocol/discovery"
- mcpprotocol "sam/pkg/protocol/mcp"
-)
-
-const (
- helperEnv = "SAM_INTEGRATION_HELPER"
- helperRoleEnv = "SAM_INTEGRATION_ROLE"
- helperInfoEnv = "SAM_INTEGRATION_INFO_FILE"
- helperIPEnv = "SAM_INTEGRATION_IP"
- helperPortEnv = "SAM_INTEGRATION_PORT"
- providerRole = "provider"
- consumerRole = "consumer"
- providerIP = "10.199.0.1"
- consumerIP = "10.199.0.2"
- providerPort = 4101
- consumerPort = 4102
- validBiscuit = "valid-biscuit"
- capabilityName = "agent.chat"
)
-type providerInfo struct {
- PeerID string `json:"peer_id"`
- Bootstrap string `json:"bootstrap"`
-}
-
-type roleProcess struct {
- cmd *exec.Cmd
- stdin io.WriteCloser
- stdout bytes.Buffer
- stderr bytes.Buffer
-}
-
-func TestFirstContactP2P(t *testing.T) {
- if os.Getenv(helperEnv) == "1" {
- if err := runHelperRole(); err != nil {
- t.Fatalf("integration helper failed: %v", err)
- }
- return
- }
-
- testutils.Run(t, func(t *testing.T) {
- runFirstContact(t)
- }, syscall.CLONE_NEWNET)
-}
-
-func runFirstContact(t *testing.T) {
- tmpDir := t.TempDir()
- infoFile := filepath.Join(tmpDir, "provider.json")
-
- provider := startRoleProcess(t, providerRole, infoFile, providerIP, providerPort)
- defer stopRoleProcess(provider)
-
- consumer := startRoleProcess(t, consumerRole, infoFile, consumerIP, consumerPort)
- defer stopRoleProcess(consumer)
-
- configureVethPair(t, provider.cmd.Process.Pid, consumer.cmd.Process.Pid)
-
- if _, err := io.WriteString(provider.stdin, "start\n"); err != nil {
- t.Fatalf("starting provider helper: %v", err)
- }
- if _, err := io.WriteString(consumer.stdin, "start\n"); err != nil {
- t.Fatalf("starting consumer helper: %v", err)
- }
-
- if err := waitForProviderInfoFile(infoFile, 10*time.Second); err != nil {
- t.Fatalf("provider did not publish startup info: %v\nprovider stdout:\n%s\nprovider stderr:\n%s",
- err, provider.stdout.String(), provider.stderr.String())
- }
-
- waitRoleExit(t, consumer, 30*time.Second)
-
- if consumer.cmd.ProcessState.ExitCode() != 0 {
- t.Fatalf("consumer process failed\nstdout:\n%s\nstderr:\n%s", consumer.stdout.String(), consumer.stderr.String())
- }
-}
-
-func runHelperRole() error {
- reader := bufio.NewReader(os.Stdin)
- if _, err := reader.ReadString('\n'); err != nil {
- return fmt.Errorf("waiting for helper start signal: %w", err)
- }
-
- role := os.Getenv(helperRoleEnv)
- switch role {
- case providerRole:
- return runProviderRole()
- case consumerRole:
- return runConsumerRole()
- default:
- return fmt.Errorf("unknown helper role %q", role)
- }
-}
-
-func runProviderRole() error {
- ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
- defer cancel()
-
- port, err := parseHelperPort()
- if err != nil {
- return err
- }
-
- node, err := newNode(port, samnet.DHTModeServer, nil)
- if err != nil {
- return err
- }
- defer func() { _ = node.Stop(context.Background()) }()
-
- if err := node.Start(ctx); err != nil {
- return fmt.Errorf("provider node start: %w", err)
- }
- if err := configureNodePassport(ctx, node, "provider"); err != nil {
- return fmt.Errorf("provider passport setup: %w", err)
- }
-
- priv := node.Host().Peerstore().PrivKey(node.PeerID())
- card, err := protocol.NewAgentCard(
- node.PeerID(),
- []string{capabilityName},
- []mcpprotocol.Resource{{Name: "echo", Kind: "tool", Endpoint: "mcp://echo"}},
- priv,
- )
- if err != nil {
- return fmt.Errorf("provider card creation: %w", err)
- }
-
- discovery, err := protocol.NewDiscoveryService(node)
- if err != nil {
- return fmt.Errorf("provider discovery service: %w", err)
- }
- if err := discovery.RegisterLocalCard(card); err != nil {
- return fmt.Errorf("provider register local card: %w", err)
- }
-
- if _, err := mcpprotocol.NewMCPBridge(node.Host(), tokenVerifier{token: validBiscuit}, echoConnector{}); err != nil {
- return fmt.Errorf("provider bridge setup: %w", err)
- }
-
- providerAddr := fmt.Sprintf("/ip4/%s/udp/%d/quic-v1/p2p/%s", os.Getenv(helperIPEnv), port, node.PeerID())
- info := providerInfo{PeerID: node.PeerID().String(), Bootstrap: providerAddr}
- if err := writeProviderInfo(os.Getenv(helperInfoEnv), info); err != nil {
- return err
- }
-
- publisher, err := protocol.NewPublisher(node)
- if err != nil {
- return fmt.Errorf("provider publisher: %w", err)
- }
- if err := publisher.Publish(ctx, card); err != nil {
- if err := publishWithRetry(ctx, publisher, card); err != nil {
- return fmt.Errorf("provider publish: %w", err)
- }
- }
-
- // Keep the provider online while the consumer performs discovery and bridge calls.
- <-ctx.Done()
- return nil
-}
-
-func publishWithRetry(ctx context.Context, publisher *protocol.Publisher, card *protocol.AgentCard) error {
- ticker := time.NewTicker(250 * time.Millisecond)
- defer ticker.Stop()
-
- var lastErr error
- for {
- if err := publisher.Publish(ctx, card); err == nil {
- return nil
- } else {
- lastErr = err
- }
-
- select {
- case <-ctx.Done():
- if lastErr != nil { //nolint:staticcheck // lastErr is assigned only on error in the loop
- return fmt.Errorf("context ended before publish converged: %w", lastErr)
- }
- return ctx.Err()
- case <-ticker.C:
- }
- }
-}
-
-func runConsumerRole() error {
- ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
- defer cancel()
-
- port, err := parseHelperPort()
- if err != nil {
- return err
- }
-
- info, err := waitProviderInfo(ctx, os.Getenv(helperInfoEnv))
- if err != nil {
- return err
- }
- bootstrap, err := multiaddr.NewMultiaddr(info.Bootstrap)
- if err != nil {
- return fmt.Errorf("parsing bootstrap address: %w", err)
- }
- providerID, err := peer.Decode(info.PeerID)
- if err != nil {
- return fmt.Errorf("decoding provider peer ID: %w", err)
- }
- providerAddrInfo, err := peer.AddrInfoFromP2pAddr(bootstrap)
- if err != nil {
- return fmt.Errorf("building provider addr info from bootstrap: %w", err)
- }
-
- // In a two-node isolated mesh, both peers need DHT server participation so
- // provider records can be stored and later discovered.
- node, err := newNode(port, samnet.DHTModeServer, []multiaddr.Multiaddr{bootstrap})
- if err != nil {
- return err
- }
- defer func() { _ = node.Stop(context.Background()) }()
-
- if err := node.Start(ctx); err != nil {
- return fmt.Errorf("consumer node start: %w", err)
- }
- if err := configureNodePassport(ctx, node, "consumer"); err != nil {
- return fmt.Errorf("consumer passport setup: %w", err)
- }
- if err := connectWithRetry(ctx, node, *providerAddrInfo); err != nil {
- return fmt.Errorf("connecting to bootstrap provider: %w", err)
- }
-
- discovery, err := protocol.NewDiscoveryService(node)
- if err != nil {
- return fmt.Errorf("consumer discovery service: %w", err)
- }
-
- peerIDs, err := discoverAndConnectWithRetry(ctx, discovery, capabilityName)
- if err != nil {
- return err
- }
-
- _, discoverErr := discoverCardsWithRetry(ctx, discovery, capabilityName)
- if discoverErr != nil {
- return discoverErr
- }
- _ = peerIDs
-
- bridge, err := mcpprotocol.NewMCPBridge(node.Host(), allowVerifier{}, echoConnector{})
- if err != nil {
- return fmt.Errorf("consumer bridge setup: %w", err)
- }
-
- if err := expectDeniedBridge(ctx, bridge, providerID); err != nil {
- return err
- }
- if err := expectAllowedBridge(ctx, bridge, providerID); err != nil {
- return err
- }
-
- return nil
-}
-
-func discoverAndConnectWithRetry(ctx context.Context, svc *protocol.DiscoveryService, capability string) ([]peer.ID, error) {
- ticker := time.NewTicker(300 * time.Millisecond)
- defer ticker.Stop()
-
- var lastErr error
- for {
- ids, err := svc.DiscoverAndConnect(ctx, capability)
- if len(ids) > 0 {
- return ids, nil
- }
- if err != nil {
- lastErr = err
- }
-
- select {
- case <-ctx.Done():
- if lastErr != nil {
- return nil, fmt.Errorf("no peers connected for capability %q: %w", capability, lastErr)
- }
- return nil, fmt.Errorf("no peers connected for capability %q: %w", capability, ctx.Err())
- case <-ticker.C:
- }
- }
-}
-
-func connectWithRetry(ctx context.Context, node samnet.Node, pi peer.AddrInfo) error {
- ticker := time.NewTicker(250 * time.Millisecond)
- defer ticker.Stop()
-
- var lastErr error
- for {
- if err := node.Connect(ctx, pi); err == nil {
- return nil
- } else {
- lastErr = err
- }
-
- select {
- case <-ctx.Done():
- if lastErr != nil {
- return lastErr
- }
- return ctx.Err()
- case <-ticker.C:
- }
- }
-}
-
-func discoverCardsWithRetry(ctx context.Context, svc *protocol.DiscoveryService, capability string) ([]*protocol.AgentCard, error) {
- ticker := time.NewTicker(300 * time.Millisecond)
- defer ticker.Stop()
-
- var lastErr error
- for {
- cards, err := svc.Discover(ctx, capability)
- if err == nil && len(cards) > 0 {
- return cards, nil
- }
- if err != nil {
- lastErr = err
- }
-
- select {
- case <-ctx.Done():
- if lastErr != nil {
- return nil, fmt.Errorf("discovering cards for capability %q: %w", capability, lastErr)
- }
- return nil, fmt.Errorf("expected at least one discovered card for capability %q", capability)
- case <-ticker.C:
- }
- }
-}
-
-func expectDeniedBridge(ctx context.Context, bridge *mcpprotocol.MCPBridge, providerID peer.ID) error {
- stream, err := bridge.Open(ctx, providerID, mcpprotocol.BridgeOpenRequest{
- BiscuitToken: "invalid-biscuit",
- Amount: 1,
- Asset: "sam-credit",
- Nonce: "nonce-denied",
- Capability: capabilityName,
- })
- if err != nil {
- return fmt.Errorf("opening denied bridge stream: %w", err)
- }
- defer func() { _ = stream.Close() }()
-
- buf := make([]byte, 1024)
- n, readErr := stream.Read(buf)
- if readErr != nil && !errors.Is(readErr, io.EOF) {
- return fmt.Errorf("reading denied bridge response: %w", readErr)
- }
- if !strings.Contains(string(buf[:n]), economy.ErrVerifierDeniedRequest.Error()) {
- return fmt.Errorf("expected denied verifier response, got %q", string(buf[:n]))
- }
- return nil
-}
-
-func expectAllowedBridge(ctx context.Context, bridge *mcpprotocol.MCPBridge, providerID peer.ID) error {
- stream, err := bridge.Open(ctx, providerID, mcpprotocol.BridgeOpenRequest{
- BiscuitToken: validBiscuit,
- Amount: 2,
- Asset: "sam-credit",
- Nonce: "nonce-allowed",
- Capability: capabilityName,
- })
- if err != nil {
- return fmt.Errorf("opening allowed bridge stream: %w", err)
- }
- defer func() { _ = stream.Close() }()
-
- payload := []byte("{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"handshake\"}\n")
- if _, err := stream.Write(payload); err != nil {
- return fmt.Errorf("writing allowed bridge payload: %w", err)
- }
-
- received := make([]byte, len(payload))
- if _, err := io.ReadFull(stream, received); err != nil {
- return fmt.Errorf("reading allowed bridge response: %w", err)
- }
- if string(received) != string(payload) {
- return fmt.Errorf("expected echo payload %q, got %q", string(payload), string(received))
- }
- return nil
-}
-
-func newNode(port int, mode samnet.DHTMode, bootstrap []multiaddr.Multiaddr) (samnet.Node, error) {
- listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/0.0.0.0/udp/%d/quic-v1", port))
- if err != nil {
- return nil, fmt.Errorf("building listen address: %w", err)
+func TestSamNodeRunWithoutIdentity(t *testing.T) {
+ nodeBin := buildBinary(t, "./cmd/sam-node")
+ tmpHome := t.TempDir()
+ env := []string{
+ "HOME=" + tmpHome,
+ "XDG_CONFIG_HOME=" + filepath.Join(tmpHome, ".config"),
}
- key, err := samnet.GenerateKey()
+ stdout, stderr, err := runCommand(t, repoRoot(t), 10*time.Second, append(os.Environ(), env...), "", nodeBin, "run")
if err != nil {
- return nil, fmt.Errorf("generating node key: %w", err)
- }
- return samnet.New(
- samnet.WithPrivateKey(key),
- samnet.WithListenAddrs(listen),
- samnet.WithBootstrapPeers(bootstrap...),
- samnet.WithDHTMode(mode),
- )
-}
-
-func configureNodePassport(ctx context.Context, node samnet.Node, subject string) error {
- passport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{
- PeerID: node.PeerID().String(),
- FederationID: "default",
- Subject: subject,
- })
- if err != nil {
- return err
- }
- return identity.SetLocalPassport(node.Host(), "default", passport)
-}
-
-func writeProviderInfo(path string, info providerInfo) error {
- f, err := os.Create(path)
- if err != nil {
- return fmt.Errorf("creating provider info file: %w", err)
- }
- defer func() { _ = f.Close() }()
- if err := json.NewEncoder(f).Encode(info); err != nil {
- return fmt.Errorf("encoding provider info: %w", err)
- }
- return nil
-}
-
-func waitProviderInfo(ctx context.Context, path string) (providerInfo, error) {
- for {
- data, err := os.ReadFile(path)
- if err == nil {
- var info providerInfo
- if unmarshalErr := json.Unmarshal(data, &info); unmarshalErr != nil {
- return providerInfo{}, fmt.Errorf("decoding provider info: %w", unmarshalErr)
- }
- return info, nil
- }
- if !errors.Is(err, os.ErrNotExist) {
- return providerInfo{}, fmt.Errorf("reading provider info: %w", err)
- }
- select {
- case <-ctx.Done():
- return providerInfo{}, fmt.Errorf("waiting for provider info: %w", ctx.Err())
- case <-time.After(100 * time.Millisecond):
- }
+ t.Fatalf("sam-node run without identity failed unexpectedly: %v\nstdout:\n%s\nstderr:\n%s", err, stdout, stderr)
}
-}
-
-func waitForProviderInfoFile(path string, timeout time.Duration) error {
- deadline := time.Now().Add(timeout)
- for {
- if _, err := os.Stat(path); err == nil {
- return nil
- }
- if time.Now().After(deadline) {
- return fmt.Errorf("timed out waiting for %s", path)
- }
- time.Sleep(100 * time.Millisecond)
+ out := stdout + stderr
+ if !strings.Contains(out, "No identity found") {
+ t.Fatalf("expected missing identity message, got:\n%s", out)
}
}
-
-func parseHelperPort() (int, error) {
- portRaw := strings.TrimSpace(os.Getenv(helperPortEnv))
- if portRaw == "" {
- return 0, fmt.Errorf("missing %s", helperPortEnv)
- }
- port, err := strconv.Atoi(portRaw)
- if err != nil || port <= 0 {
- return 0, fmt.Errorf("invalid helper port %q", portRaw)
- }
- return port, nil
-}
-
-func startRoleProcess(t *testing.T, role, infoFile, ip string, port int) *roleProcess {
- t.Helper()
-
- proc := &roleProcess{}
- cmd := exec.Command(os.Args[0], "-test.run=TestFirstContactP2P$", "-test.v=true")
- cmd.Env = append(os.Environ(),
- helperEnv+"=1",
- helperRoleEnv+"="+role,
- helperInfoEnv+"="+infoFile,
- helperIPEnv+"="+ip,
- helperPortEnv+"="+strconv.Itoa(port),
- )
- cmd.SysProcAttr = &syscall.SysProcAttr{
- Cloneflags: syscall.CLONE_NEWUSER | syscall.CLONE_NEWNET,
- UidMappings: []syscall.SysProcIDMap{{ContainerID: 0, HostID: os.Getuid(), Size: 1}},
- GidMappings: []syscall.SysProcIDMap{{ContainerID: 0, HostID: os.Getgid(), Size: 1}},
- GidMappingsEnableSetgroups: false,
- }
- stdin, err := cmd.StdinPipe()
- if err != nil {
- t.Fatalf("creating %s stdin pipe: %v", role, err)
- }
- proc.stdin = stdin
- cmd.Stdout = &proc.stdout
- cmd.Stderr = &proc.stderr
-
- if err := cmd.Start(); err != nil {
- t.Fatalf("starting %s process: %v", role, err)
- }
- proc.cmd = cmd
- return proc
-}
-
-func stopRoleProcess(proc *roleProcess) {
- if proc == nil || proc.cmd == nil || proc.cmd.Process == nil {
- return
- }
- _ = proc.stdin.Close()
- _ = proc.cmd.Process.Kill()
- _, _ = proc.cmd.Process.Wait()
-}
-
-func waitRoleExit(t *testing.T, proc *roleProcess, timeout time.Duration) {
- t.Helper()
- done := make(chan error, 1)
- go func() {
- done <- proc.cmd.Wait()
- }()
- select {
- case err := <-done:
- if err != nil {
- t.Fatalf("role process wait failed: %v\nstdout:\n%s\nstderr:\n%s", err, proc.stdout.String(), proc.stderr.String())
- }
- case <-time.After(timeout):
- t.Fatalf("role process timed out\nstdout:\n%s\nstderr:\n%s", proc.stdout.String(), proc.stderr.String())
- }
-}
-
-func configureVethPair(t *testing.T, providerPID, consumerPID int) {
- t.Helper()
- if err := netlink.LinkAdd(&netlink.Veth{
- LinkAttrs: netlink.LinkAttrs{Name: "samveth-p"},
- PeerName: "samveth-c",
- }); err != nil {
- t.Fatalf("creating veth pair: %v", err)
- }
-
- providerLink, err := netlink.LinkByName("samveth-p")
- if err != nil {
- t.Fatalf("finding provider veth: %v", err)
- }
- consumerLink, err := netlink.LinkByName("samveth-c")
- if err != nil {
- t.Fatalf("finding consumer veth: %v", err)
- }
-
- if err := netlink.LinkSetNsPid(providerLink, providerPID); err != nil {
- t.Fatalf("moving provider veth to netns pid %d: %v", providerPID, err)
- }
- if err := netlink.LinkSetNsPid(consumerLink, consumerPID); err != nil {
- t.Fatalf("moving consumer veth to netns pid %d: %v", consumerPID, err)
- }
-
- configureLinkInNetNS(t, providerPID, "samveth-p", providerIP+"/24")
- configureLinkInNetNS(t, consumerPID, "samveth-c", consumerIP+"/24")
-}
-
-func configureLinkInNetNS(t *testing.T, pid int, linkName, cidr string) {
- t.Helper()
- runtime.LockOSThread()
- defer runtime.UnlockOSThread()
-
- originalNS, err := netns.Get()
- if err != nil {
- t.Fatalf("getting current netns: %v", err)
- }
- defer func() { _ = originalNS.Close() }()
-
- targetNS, err := netns.GetFromPid(pid)
- if err != nil {
- t.Fatalf("getting target netns for pid %d: %v", pid, err)
- }
- defer func() { _ = targetNS.Close() }()
-
- if err := netns.Set(targetNS); err != nil {
- t.Fatalf("entering netns for pid %d: %v", pid, err)
- }
- defer func() {
- if err := netns.Set(originalNS); err != nil {
- t.Fatalf("restoring original netns: %v", err)
- }
- }()
-
- lo, err := netlink.LinkByName("lo")
- if err != nil {
- t.Fatalf("getting loopback in netns pid %d: %v", pid, err)
- }
- if err := netlink.LinkSetUp(lo); err != nil {
- t.Fatalf("bringing loopback up in netns pid %d: %v", pid, err)
- }
-
- link, err := netlink.LinkByName(linkName)
- if err != nil {
- t.Fatalf("getting link %s in netns pid %d: %v", linkName, pid, err)
- }
- addr, err := netlink.ParseAddr(cidr)
- if err != nil {
- t.Fatalf("parsing cidr %s: %v", cidr, err)
- }
- if err := netlink.AddrAdd(link, addr); err != nil {
- t.Fatalf("assigning addr %s to %s in pid %d: %v", cidr, linkName, pid, err)
- }
- if err := netlink.LinkSetUp(link); err != nil {
- t.Fatalf("bringing link %s up in netns pid %d: %v", linkName, pid, err)
- }
-}
-
-type tokenVerifier struct {
- token string
-}
-
-func (v tokenVerifier) Verify(_ context.Context, req economy.VerifyRequest) (*economy.VerifyDecision, error) {
- if req.Token != v.token {
- return nil, fmt.Errorf("invalid biscuit token")
- }
- return &economy.VerifyDecision{Subject: "peer:test"}, nil
-}
-
-type allowVerifier struct{}
-
-func (allowVerifier) Verify(_ context.Context, _ economy.VerifyRequest) (*economy.VerifyDecision, error) {
- return &economy.VerifyDecision{Subject: "peer:test"}, nil
-}
-
-type echoConnector struct{}
-
-func (echoConnector) Open(context.Context) (mcp.Transport, error) {
- a, b := net.Pipe()
- go func() {
- defer func() { _ = b.Close() }()
- buf := make([]byte, 32*1024)
- for {
- n, err := b.Read(buf)
- if n > 0 {
- if _, werr := b.Write(buf[:n]); werr != nil {
- return
- }
- }
- if err != nil {
- return
- }
- }
- }()
- return &mcp.IOTransport{Reader: a, Writer: a}, nil
-}
diff --git a/tests/integration/proxy_test.go b/tests/integration/proxy_test.go
index 86db4632..9a7db421 100644
--- a/tests/integration/proxy_test.go
+++ b/tests/integration/proxy_test.go
@@ -15,427 +15,56 @@
package integration_test
import (
- "bytes"
"context"
- "fmt"
- "io"
- "net/http"
- "net/http/httptest"
"os"
"path/filepath"
"strings"
- "sync/atomic"
"testing"
"time"
-
- "github.com/libp2p/go-libp2p/core/peer"
- "github.com/multiformats/go-multiaddr"
- "go.etcd.io/bbolt"
-
- internaldb "sam/internal/db"
- "sam/internal/testutils"
- "sam/pkg/economy"
- "sam/pkg/identity"
- samnet "sam/pkg/net"
- a2aprotocol "sam/pkg/protocol/a2a"
- httpprotocol "sam/pkg/protocol/http"
)
-const proxyRecordVersion = 1
-
-func TestProxyTunnelLegacyFlowIntegration(t *testing.T) {
- testutils.Run(t, func(t *testing.T) {
- runProxyTunnelLegacyFlowIntegration(t)
- })
-}
-
-func TestProxyTunnelUnauthorizedBeforeDial(t *testing.T) {
- testutils.Run(t, func(t *testing.T) {
- runProxyTunnelUnauthorizedBeforeDial(t)
- })
-}
-
-func runProxyTunnelLegacyFlowIntegration(t *testing.T) {
- t.Helper()
-
- ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
- defer cancel()
-
+func TestSamNodeLoginThenRunWithStoredIdentity(t *testing.T) {
+ nodeBin := buildBinary(t, "./cmd/sam-node")
tmpHome := t.TempDir()
- t.Setenv("HOME", tmpHome)
- t.Setenv("XDG_CONFIG_HOME", filepath.Join(tmpHome, ".config"))
-
- federation := "proxy-legacy"
- observer, err := a2aprotocol.NewBoltObserverForFederation(federation)
- if err != nil {
- t.Fatalf("creating observer: %v", err)
- }
- defer func() { _ = observer.Close() }()
-
- requestSeen := make(chan *http.Request, 1)
- bodySeen := make(chan []byte, 1)
- backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- body, _ := io.ReadAll(r.Body)
- requestSeen <- r.Clone(r.Context())
- bodySeen <- append([]byte(nil), body...)
- w.Header().Set("Content-Type", "application/json")
- w.Header().Set("X-Backend", "sam-provider")
- w.WriteHeader(http.StatusCreated)
- _, _ = w.Write([]byte(`{"status":"ok"}`))
- }))
- defer backend.Close()
-
- providerNode, err := newProxyNode(0, nil)
- if err != nil {
- t.Fatalf("creating provider node: %v", err)
- }
- if err := providerNode.Start(ctx); err != nil {
- t.Fatalf("starting provider node: %v", err)
- }
- providerPassport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{
- PeerID: providerNode.PeerID().String(),
- FederationID: "default",
- Subject: "test-subject",
- Claims: map[string]string{"email": "[email protected]"},
- })
- if err != nil {
- t.Fatalf("issuing provider passport biscuit: %v", err)
- }
- if err := identity.SetLocalPassport(providerNode.Host(), "default", providerPassport); err != nil {
- t.Fatalf("setting provider local passport auth: %v", err)
- }
- defer func() { _ = providerNode.Stop(context.Background()) }()
-
- tunnelSvc, err := httpprotocol.NewHTTPTunnelService(
- providerNode.Host(),
- backend.URL,
- httpprotocol.WithHTTPTunnelSkillGate(economy.NewBiscuitSkillGate(nil)),
+ env := append(os.Environ(),
+ "HOME="+tmpHome,
+ "XDG_CONFIG_HOME="+filepath.Join(tmpHome, ".config"),
)
- if err != nil {
- t.Fatalf("creating tunnel service: %v", err)
- }
- defer tunnelSvc.Close()
-
- consumerNode, err := newProxyNode(0, providerBootstrap(providerNode))
- if err != nil {
- t.Fatalf("creating consumer node: %v", err)
- }
- if err := consumerNode.Start(ctx); err != nil {
- t.Fatalf("starting consumer node: %v", err)
- }
- passport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{
- PeerID: consumerNode.PeerID().String(),
- FederationID: "default",
- Subject: "test-subject",
- Claims: map[string]string{"email": "[email protected]"},
- })
- if err != nil {
- t.Fatalf("issuing passport biscuit: %v", err)
- }
- if err := identity.SetLocalPassport(consumerNode.Host(), "default", passport); err != nil {
- t.Fatalf("setting local passport auth: %v", err)
- }
- defer func() { _ = consumerNode.Stop(context.Background()) }()
-
- providerInfo := peer.AddrInfo{ID: providerNode.PeerID(), Addrs: providerNode.Host().Addrs()}
- if err := connectProxyWithRetry(ctx, consumerNode, providerInfo); err != nil {
- t.Fatalf("connecting consumer->provider: %v", err)
- }
-
- proxySrv := httptest.NewServer(proxyTunnelHandler(consumerNode, observer, "X-SAM-Target", "alice;allow_skill=risk-audit", passport))
- defer proxySrv.Close()
-
- payload := []byte(`{"request":"through-proxy"}`)
- req, err := http.NewRequestWithContext(ctx, http.MethodPost, proxySrv.URL+"/data.json?via=proxy", bytes.NewReader(payload))
- if err != nil {
- t.Fatalf("creating request: %v", err)
- }
- req.Header.Set("X-SAM-Target", providerNode.PeerID().String())
- req.Header.Set("Authorization", "Bearer test-token")
- req.Header.Set("User-Agent", "curl/8.5.0")
- req.Header.Set("Content-Type", "application/json")
- req.Header.Set("X-Trace-ID", "trace-123")
-
- resp, err := http.DefaultClient.Do(req)
- if err != nil {
- t.Fatalf("sending proxy request: %v", err)
- }
- defer func() { _ = resp.Body.Close() }()
- respBody, err := io.ReadAll(resp.Body)
- if err != nil {
- t.Fatalf("reading proxy response: %v", err)
- }
- if resp.StatusCode != http.StatusCreated {
- t.Fatalf("unexpected status code: got=%d body=%s", resp.StatusCode, string(respBody))
- }
- if got := resp.Header.Get("X-Backend"); got != "sam-provider" {
- t.Fatalf("expected X-Backend header to be preserved, got=%q", got)
- }
- if !strings.Contains(string(respBody), `"status":"ok"`) {
- t.Fatalf("unexpected response body: %s", string(respBody))
- }
-
- select {
- case backendReq := <-requestSeen:
- if backendReq.Method != http.MethodPost {
- t.Fatalf("backend method mismatch: got=%s", backendReq.Method)
- }
- if backendReq.URL.RequestURI() != "/data.json?via=proxy" {
- t.Fatalf("backend path mismatch: got=%s", backendReq.URL.RequestURI())
- }
- if got := backendReq.Header.Get("Authorization"); got != "Bearer test-token" {
- t.Fatalf("Authorization header not preserved: got=%q", got)
- }
- if got := backendReq.Header.Get("User-Agent"); got != "curl/8.5.0" {
- t.Fatalf("User-Agent header not preserved: got=%q", got)
- }
- if got := backendReq.Header.Get("X-Trace-ID"); got != "trace-123" {
- t.Fatalf("X-Trace-ID header not preserved: got=%q", got)
- }
- case <-time.After(2 * time.Second):
- t.Fatalf("backend did not receive request")
- }
-
- select {
- case gotBody := <-bodySeen:
- if string(gotBody) != string(payload) {
- t.Fatalf("backend payload mismatch: got=%s", string(gotBody))
- }
- case <-time.After(2 * time.Second):
- t.Fatalf("backend body not captured")
- }
-
- repDBPath := filepath.Join(tmpHome, ".config", "sam", "federations", federation+".db")
- if err := observer.Close(); err != nil {
- t.Fatalf("closing observer: %v", err)
- }
- successes, failures, err := readProxyReputationCounts(repDBPath)
- if err != nil {
- t.Fatalf("reading reputation db: %v", err)
- }
- if successes == 0 {
- t.Fatalf("expected at least one success reputation record")
- }
- if failures != 0 {
- t.Fatalf("unexpected failure reputation records: %d", failures)
- }
-}
-
-func runProxyTunnelUnauthorizedBeforeDial(t *testing.T) {
- t.Helper()
-
- ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
- defer cancel()
-
- var backendHits atomic.Int64
- backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- backendHits.Add(1)
- w.WriteHeader(http.StatusOK)
- _, _ = w.Write([]byte("unexpected"))
- }))
- defer backend.Close()
-
- providerNode, err := newProxyNode(0, nil)
- if err != nil {
- t.Fatalf("creating provider node: %v", err)
- }
- if err := providerNode.Start(ctx); err != nil {
- t.Fatalf("starting provider node: %v", err)
- }
- defer func() { _ = providerNode.Stop(context.Background()) }()
-
- tunnelSvc, err := httpprotocol.NewHTTPTunnelService(providerNode.Host(), backend.URL)
- if err != nil {
- t.Fatalf("creating tunnel service: %v", err)
- }
- defer tunnelSvc.Close()
-
- consumerNode, err := newProxyNode(0, providerBootstrap(providerNode))
- if err != nil {
- t.Fatalf("creating consumer node: %v", err)
- }
- if err := consumerNode.Start(ctx); err != nil {
- t.Fatalf("starting consumer node: %v", err)
- }
- defer func() { _ = consumerNode.Stop(context.Background()) }()
-
- proxySrv := httptest.NewServer(proxyTunnelHandler(consumerNode, a2aprotocol.NopObserver{}, "X-SAM-Target", "", ""))
- defer proxySrv.Close()
-
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, proxySrv.URL+"/blocked", nil)
- if err != nil {
- t.Fatalf("creating request: %v", err)
- }
- req.Header.Set("X-SAM-Target", providerNode.PeerID().String())
-
- resp, err := http.DefaultClient.Do(req)
+ loginOut, loginErrOut, err := runCommand(
+ t,
+ repoRoot(t),
+ 10*time.Second,
+ env,
+ "test-biscuit-token\n",
+ nodeBin,
+ "login",
+ )
if err != nil {
- t.Fatalf("sending request: %v", err)
+ t.Fatalf("sam-node login failed: %v\nstdout:\n%s\nstderr:\n%s", err, loginOut, loginErrOut)
}
- defer func() { _ = resp.Body.Close() }()
-
- if resp.StatusCode != http.StatusUnauthorized {
- body, _ := io.ReadAll(resp.Body)
- t.Fatalf("expected unauthorized, got=%d body=%s", resp.StatusCode, string(body))
- }
- if backendHits.Load() != 0 {
- t.Fatalf("expected no backend hits before authorization, got=%d", backendHits.Load())
+ if !strings.Contains(loginOut+loginErrOut, "Success! Identity stored") {
+ t.Fatalf("unexpected login output:\n%s\n%s", loginOut, loginErrOut)
}
-}
-func proxyTunnelHandler(node samnet.Node, observer a2aprotocol.Observer, targetHeader, biscuit string, passport string) http.Handler {
- return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- if strings.TrimSpace(passport) == "" {
- http.Error(w, "unauthorized: local identity login required", http.StatusUnauthorized)
- return
- }
-
- targetArg := strings.TrimSpace(r.Header.Get(targetHeader))
- if targetArg == "" {
- http.Error(w, "missing target header", http.StatusBadRequest)
- return
- }
- targetID, err := peer.Decode(targetArg)
- if err != nil {
- http.Error(w, fmt.Sprintf("invalid target: %v", err), http.StatusBadRequest)
- return
- }
-
- body, err := io.ReadAll(r.Body)
- if err != nil {
- http.Error(w, fmt.Sprintf("reading body: %v", err), http.StatusBadRequest)
- return
- }
-
- headers := r.Header.Clone()
- headers.Del(targetHeader)
-
- start := time.Now()
- resp, err := httpprotocol.TunnelHTTP(r.Context(), node.Host(), targetID, httpprotocol.HTTPTunnelOpenRequest{
- Biscuit: biscuit,
- Capability: "risk-audit",
- Request: httpprotocol.HTTPTunnelRequest{
- Method: r.Method,
- Path: r.URL.RequestURI(),
- Headers: headers,
- Body: body,
- },
- })
- if err != nil {
- observer.OnFailure(targetID.String(), a2aprotocol.FailureTypeLiveness)
- http.Error(w, fmt.Sprintf("tunnel request failed: %v", err), http.StatusBadGateway)
- return
- }
- if resp.Error != "" {
- observer.OnFailure(targetID.String(), a2aprotocol.FailureTypeRemote)
- status := resp.StatusCode
- if status == 0 {
- status = http.StatusBadGateway
- }
- http.Error(w, resp.Error, status)
- return
- }
-
- for key, vals := range resp.Headers {
- for _, val := range vals {
- w.Header().Add(key, val)
- }
- }
- status := resp.StatusCode
- if status == 0 {
- status = http.StatusOK
- }
- w.WriteHeader(status)
- _, _ = w.Write(resp.Body)
-
- observer.OnSuccess(targetID.String(), time.Since(start))
- })
-}
-
-func providerBootstrap(node samnet.Node) []multiaddr.Multiaddr {
- addrs := node.Host().Addrs()
- if len(addrs) == 0 {
- return nil
- }
- return []multiaddr.Multiaddr{addrs[0].Encapsulate(multiaddr.StringCast("/p2p/" + node.PeerID().String()))}
-}
-
-func newProxyNode(port int, bootstrap []multiaddr.Multiaddr) (samnet.Node, error) {
- listen, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/udp/%d/quic-v1", port))
- if err != nil {
- return nil, fmt.Errorf("building listen address: %w", err)
- }
- key, err := samnet.GenerateKey()
- if err != nil {
- return nil, fmt.Errorf("generating node key: %w", err)
- }
- return samnet.New(
- samnet.WithPrivateKey(key),
- samnet.WithListenAddrs(listen),
- samnet.WithBootstrapPeers(bootstrap...),
- samnet.WithDHTMode(samnet.DHTModeServer),
+ runOut, runErrOut, err := runCommand(
+ t,
+ repoRoot(t),
+ 3*time.Second,
+ env,
+ "",
+ nodeBin,
+ "run",
+ "--listen", "/ip4/127.0.0.1/udp/0/quic-v1",
+ "--listen", "/ip4/127.0.0.1/tcp/0",
)
-}
-
-func connectProxyWithRetry(ctx context.Context, node samnet.Node, pi peer.AddrInfo) error {
- ticker := time.NewTicker(250 * time.Millisecond)
- defer ticker.Stop()
- var last error
- for {
- if err := node.Connect(ctx, pi); err == nil {
- return nil
- } else {
- last = err
- }
- select {
- case <-ctx.Done():
- return last
- case <-ticker.C:
- }
- }
-}
-
-func readProxyReputationCounts(path string) (int, int, error) {
- if _, err := os.Stat(path); err != nil {
- return 0, 0, err
- }
- db, err := bbolt.Open(path, 0o600, &bbolt.Options{Timeout: 2 * time.Second})
- if err != nil {
- return 0, 0, err
+ if err != context.DeadlineExceeded {
+ t.Fatalf("expected run command to keep running until timeout, got: %v\nstdout:\n%s\nstderr:\n%s", err, runOut, runErrOut)
}
- defer func() { _ = db.Close() }()
-
- type reputationRecord struct {
- PeerID string `json:"peer_id"`
- OK bool `json:"ok"`
- LatencyMS int64 `json:"latency_ms,omitempty"`
- ErrorType string `json:"error_type,omitempty"`
+ if strings.Contains(runOut+runErrOut, "No identity found") {
+ t.Fatalf("run command did not use stored identity:\n%s\n%s", runOut, runErrOut)
}
-
- codec := internaldb.JSONCodec{}
- successes := 0
- failures := 0
- err = db.View(func(tx *bbolt.Tx) error {
- bucket := tx.Bucket([]byte(internaldb.BucketReputation))
- if bucket == nil {
- return fmt.Errorf("missing reputation bucket")
- }
- return bucket.ForEach(func(_ []byte, value []byte) error {
- var rec reputationRecord
- if err := codec.Unmarshal(value, proxyRecordVersion, &rec, nil); err != nil {
- return err
- }
- if rec.OK {
- successes++
- } else {
- failures++
- }
- return nil
- })
- })
- if err != nil {
- return 0, 0, err
+ if !strings.Contains(runOut+runErrOut, "SAM Node Online") {
+ t.Fatalf("node did not reach online state:\n%s\n%s", runOut, runErrOut)
}
- return successes, failures, nil
}