Skip to content

Agent Mesh

fix tests

Antonio Ojea02b9312ef4df
diff --git a/cmd/sam-agent/proxy.go b/cmd/sam-agent/proxy.go
index 95b0af17..77ca80da 100644
--- a/cmd/sam-agent/proxy.go
+++ b/cmd/sam-agent/proxy.go
@@ -28,9 +28,7 @@ import (
"strings"
"time"
- "github.com/ipfs/go-cid"
"github.com/libp2p/go-libp2p/core/peer"
- "github.com/multiformats/go-multihash"
"github.com/spf13/cobra"
"sam/pkg/identity"
@@ -409,18 +407,14 @@ func discoverCardsByCapability(ctx context.Context, node samnet.Node, capability
}
func findProvidersForNamespace(ctx context.Context, node samnet.Node, namespace string) ([]peer.AddrInfo, error) {
- d := node.DHT()
- if d == nil {
- return nil, fmt.Errorf("dht is not available")
- }
- topicCID, err := namespaceToCID(namespace)
+ ch, err := node.Discover(ctx, namespace)
if err != nil {
return nil, err
}
results := make([]peer.AddrInfo, 0)
seen := map[string]struct{}{}
- for info := range d.FindProvidersAsync(ctx, topicCID, 64) {
+ for info := range ch {
if info.ID == "" || info.ID == node.PeerID() {
continue
}
@@ -433,18 +427,6 @@ func findProvidersForNamespace(ctx context.Context, node samnet.Node, namespace
return results, nil
}
-func namespaceToCID(namespace string) (cid.Cid, error) {
- namespace = strings.TrimSpace(namespace)
- if namespace == "" {
- return cid.Undef, fmt.Errorf("namespace is required")
- }
- h, err := multihash.Sum([]byte(namespace), multihash.SHA2_256, -1)
- if err != nil {
- return cid.Undef, fmt.Errorf("hashing namespace: %w", err)
- }
- return cid.NewCidV1(cid.Raw, h), nil
-}
-
func fetchCardFromDHT(ctx context.Context, node samnet.Node, peerID string) (*protocol.AgentCard, error) {
raw, err := node.GetValue(ctx, protocol.DHTPeerCardKey(peerID))
if err != nil {
diff --git a/cmd/sam-agent/proxy_reserved_test.go b/cmd/sam-agent/proxy_reserved_test.go
index 7ccb7c63..418472dc 100644
--- a/cmd/sam-agent/proxy_reserved_test.go
+++ b/cmd/sam-agent/proxy_reserved_test.go
@@ -27,6 +27,7 @@ import (
"github.com/libp2p/go-libp2p/core/peer"
"github.com/multiformats/go-multiaddr"
+ "sam/pkg/identity"
samnet "sam/pkg/net"
"sam/pkg/protocol"
)
@@ -74,6 +75,19 @@ func TestSAMReservedSearchReturnsPublishedWriterCard(t *testing.T) {
}
defer func() { _ = nodeB.Stop(context.Background()) }()
+ // Set passport on nodeB
+ passportB, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{
+ PeerID: nodeB.PeerID().String(),
+ FederationID: "default",
+ Subject: nodeB.PeerID().String(),
+ })
+ if err != nil {
+ t.Fatalf("issuing nodeB passport: %v", err)
+ }
+ if err := identity.SetLocalPassport(nodeB.Host(), "default", passportB); err != nil {
+ t.Fatalf("setting nodeB passport: %v", err)
+ }
+
bootstrap := []multiaddr.Multiaddr{nodeB.Addrs()[0].Encapsulate(multiaddr.StringCast("/p2p/" + nodeB.PeerID().String()))}
nodeA, err := newProxyReservedNode(0, bootstrap)
if err != nil {
@@ -84,6 +98,19 @@ func TestSAMReservedSearchReturnsPublishedWriterCard(t *testing.T) {
}
defer func() { _ = nodeA.Stop(context.Background()) }()
+ // Set passport on nodeA
+ passportA, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{
+ PeerID: nodeA.PeerID().String(),
+ FederationID: "default",
+ Subject: nodeA.PeerID().String(),
+ })
+ if err != nil {
+ t.Fatalf("issuing nodeA passport: %v", err)
+ }
+ if err := identity.SetLocalPassport(nodeA.Host(), "default", passportA); err != nil {
+ t.Fatalf("setting nodeA passport: %v", err)
+ }
+
if err := connectProxyReservedWithRetry(ctx, nodeA, peer.AddrInfo{ID: nodeB.PeerID(), Addrs: nodeB.Addrs()}); err != nil {
t.Fatalf("connecting publisher to search node: %v", err)
}
@@ -109,8 +136,11 @@ func TestSAMReservedSearchReturnsPublishedWriterCard(t *testing.T) {
cfg := &runConfig{proxyTimeout: 3 * time.Second}
- deadline := time.Now().Add(12 * time.Second)
+ deadline := time.Now().Add(20 * time.Second)
for {
+ // Re-publish while polling to handle DHT provider propagation races in short-lived tests.
+ _ = pub.Publish(ctx, card)
+
req := httptest.NewRequest(http.MethodGet, "/.sam/search?skill=writer", nil)
rr := httptest.NewRecorder()
handleSAMReserved(rr, req, nodeB, cfg)
@@ -143,12 +173,20 @@ func newProxyReservedNode(port int, bootstrap []multiaddr.Multiaddr) (samnet.Nod
if err != nil {
return nil, fmt.Errorf("generating node key: %w", err)
}
- return samnet.New(
+ node, err := samnet.New(
samnet.WithPrivateKey(key),
samnet.WithListenAddrs(listen),
samnet.WithBootstrapPeers(bootstrap...),
samnet.WithDHTMode(samnet.DHTModeServer),
)
+ if err != nil {
+ return nil, err
+ }
+
+ // Set a test passport so the node can authenticate with other peers.
+ // Note: Must be done after node creation but the actual SetLocalPassport
+ // happens after Start in the test that calls this.
+ return node, nil
}
func connectProxyReservedWithRetry(ctx context.Context, node samnet.Node, pi peer.AddrInfo) error {
diff --git a/pkg/protocol/a2a_test.go b/pkg/protocol/a2a_test.go
index 1ded2fca..460a833f 100644
--- a/pkg/protocol/a2a_test.go
+++ b/pkg/protocol/a2a_test.go
@@ -117,6 +117,19 @@ func TestExecuteSuccessRecordsObserver(t *testing.T) {
}
defer func() { _ = clientHost.Close() }()
+ // Set up server passport
+ serverPassport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{
+ PeerID: serverHost.ID().String(),
+ FederationID: "default",
+ Subject: "server-sub",
+ })
+ if err != nil {
+ t.Fatalf("IssuePassportBiscuit(server) error = %v", err)
+ }
+ if err := identity.SetLocalPassport(serverHost, "default", serverPassport); err != nil {
+ t.Fatalf("SetLocalPassport(server) error = %v", err)
+ }
+
serverObserver := &testObserver{}
svc, err := NewA2AService(serverHost, staticResponseConnector{}, serverObserver)
if err != nil {
@@ -131,10 +144,10 @@ func TestExecuteSuccessRecordsObserver(t *testing.T) {
Subject: "sub",
})
if err != nil {
- t.Fatalf("IssuePassportBiscuit() error = %v", err)
+ t.Fatalf("IssuePassportBiscuit(client) error = %v", err)
}
if err := identity.SetLocalPassport(clientHost, "default", passport); err != nil {
- t.Fatalf("SetLocalPassport() error = %v", err)
+ t.Fatalf("SetLocalPassport(client) error = %v", err)
}
resp, err := Execute(ctx, clientHost, ExecuteRequest{
Target: peer.AddrInfo{ID: serverHost.ID(), Addrs: serverHost.Addrs()},
diff --git a/tests/integration/call_test.go b/tests/integration/call_test.go
index 1a9ad76c..7926d76d 100644
--- a/tests/integration/call_test.go
+++ b/tests/integration/call_test.go
@@ -186,6 +186,17 @@ func runCallProviderRole() error {
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() {
@@ -287,6 +298,17 @@ func runCallConsumerRole() error {
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() {
@@ -307,17 +329,6 @@ func runCallConsumerRole() error {
}
defer func() { _ = observer.Close() }()
- 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)
- }
req := protocol.ExecuteRequest{
Target: target,
Capability: callCapability,
diff --git a/tests/integration/cuj_test.go b/tests/integration/cuj_test.go
index bc811c21..20a43675 100644
--- a/tests/integration/cuj_test.go
+++ b/tests/integration/cuj_test.go
@@ -29,6 +29,7 @@ import (
"github.com/multiformats/go-multiaddr"
"sam/internal/testutils"
+ "sam/pkg/identity"
samnet "sam/pkg/net"
)
@@ -161,9 +162,33 @@ func cujStartNode(t *testing.T, cfg cujNodeConfig) samnet.Node {
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()) }()
})
@@ -185,6 +210,27 @@ func cujBootstrapAddrs(t *testing.T, n samnet.Node) []multiaddr.Multiaddr {
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()
diff --git a/tests/integration/proxy_test.go b/tests/integration/proxy_test.go
index 1798db73..bb5b15a3 100644
--- a/tests/integration/proxy_test.go
+++ b/tests/integration/proxy_test.go
@@ -91,6 +91,18 @@ func runProxyTunnelLegacyFlowIntegration(t *testing.T) {
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 := protocol.NewHTTPTunnelService(
@@ -110,13 +122,6 @@ func runProxyTunnelLegacyFlowIntegration(t *testing.T) {
if err := consumerNode.Start(ctx); err != nil {
t.Fatalf("starting consumer node: %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)
- }
-
passport, err := identity.IssuePassportBiscuit(ctx, identity.PassportIssueRequest{
PeerID: consumerNode.PeerID().String(),
FederationID: "default",
@@ -129,6 +134,13 @@ func runProxyTunnelLegacyFlowIntegration(t *testing.T) {
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()