Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
allow to request offline token
Antonio Ojea39138ba0a64e
diff --git a/cmd/sam-node/main.go b/cmd/sam-node/main.goindex 9c6f283d..315d57c8 100644--- a/cmd/sam-node/main.go+++ b/cmd/sam-node/main.go@@ -74,6 +74,7 @@ var (dataDirFlag stringallowLoopbackFlag boolheadlessFlag bool+ offlineAccessFlag boolautoRelayMinIntervalFlag time.DurationautoRelayBootDelayFlag time.DurationautoRelayBackoffFlag time.Duration@@ -400,7 +401,7 @@ func main() {logger.Fatalf("Failed to discover OIDC endpoints: %v", err)}- jwtStr, err := dummyNode.InteractiveLogin(ctx, authURL, tokenURL, hubInfo.ClientId, hubInfo.Audience)+ jwtStr, err := dummyNode.InteractiveLogin(ctx, authURL, tokenURL, hubInfo.ClientId, hubInfo.Audience, offlineAccessFlag)if err != nil {logger.Fatalf("Failed to get token: %v", err)}@@ -465,6 +466,9 @@ func main() {if err := store.SaveHubURL(targetHub); err != nil {logger.Warnf("Failed to save hub URL: %v", err)}+ if err := store.SaveOIDCConfig(hubInfo.OidcIssuer, hubInfo.ClientId, hubInfo.Audience); err != nil {+ logger.Warnf("Failed to save OIDC config: %v", err)+ }fmt.Println("Successfully joined the Sovereign Agent Mesh!")},@@ -490,6 +494,7 @@ func main() {runCmd.Flags().DurationVar(&keyGracePeriodFlag, "key-grace-period", 24*time.Hour, "Key grace period for old keys (e.g. 24h)")runCmd.Flags().BoolVar(&allowLoopbackFlag, "allow-loopback", false, "Allow publishing and connecting to loopback/link-local addresses")joinCmd.Flags().BoolVar(&allowLoopbackFlag, "allow-loopback", false, "Allow publishing and connecting to loopback/link-local addresses")+ joinCmd.Flags().BoolVar(&offlineAccessFlag, "offline-access", false, "Request OIDC offline access/refresh token for automatic renewal")runCmd.Flags().StringVar(&apiTokenFlag, "api-token", "", "Static Bearer token for API authorization")runCmd.Flags().StringVar(&tlsCertFlag, "tls-cert", "", "Path to TLS certificate for sidecar API")runCmd.Flags().StringVar(&tlsKeyFlag, "tls-key", "", "Path to TLS key for sidecar API")diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.goindex b976a61d..9427210c 100644--- a/cmd/sam-node/node.go+++ b/cmd/sam-node/node.go@@ -710,7 +710,7 @@ func (n *SamNode) StartRenewalLoop(ctx context.Context, issuerURL, clientID, clinewJWT = strings.TrimSpace(string(data))}} else {- fetchErr = fmt.Errorf("no credentials available for renewal")+ newJWT, fetchErr = n.renewWithRefreshToken(ctx, clientSecret)}if fetchErr == nil {@@ -735,6 +735,43 @@ func (n *SamNode) StartRenewalLoop(ctx context.Context, issuerURL, clientID, cli}()}+func (n *SamNode) renewWithRefreshToken(ctx context.Context, clientSecret string) (string, error) {+ if n.Store == nil {+ return "", fmt.Errorf("store is not initialized")+ }++ refreshToken, err := n.Store.LoadRefreshToken()+ if err != nil {+ return "", fmt.Errorf("no refresh token available for renewal: %w", err)+ }++ storedIssuer, storedClientID, _, err := n.Store.LoadOIDCConfig()+ if err != nil {+ return "", fmt.Errorf("failed to load OIDC configuration: %w", err)+ }+ if storedIssuer == "" || storedClientID == "" {+ return "", fmt.Errorf("OIDC configuration is incomplete (issuer or client ID is empty)")+ }++ tokenURL, err := n.DiscoverTokenURL(ctx, storedIssuer)+ if err != nil {+ return "", fmt.Errorf("failed to discover OIDC endpoints for renewal: %w", err)+ }++ newJWT, newRefreshToken, err := n.RefreshJWT(ctx, tokenURL, storedClientID, clientSecret, refreshToken)+ if err != nil {+ return "", fmt.Errorf("failed to refresh JWT: %w", err)+ }++ if newRefreshToken != "" {+ if err := n.Store.SaveRefreshToken(newRefreshToken); err != nil {+ logger.Warnf("Failed to save updated refresh token: %v", err)+ }+ }++ return newJWT, nil+}+// listenForHubEvents listens to the topic established by the Hubfunc (n *SamNode) listenForHubEvents(ctx context.Context) {topic, err := n.PubSub.Join(api.GossipEvents)diff --git a/cmd/sam-node/oidc.go b/cmd/sam-node/oidc.goindex a65eec71..ef6c7b10 100644--- a/cmd/sam-node/oidc.go+++ b/cmd/sam-node/oidc.go@@ -61,7 +61,7 @@ func (n *SamNode) FetchJWT(ctx context.Context, tokenURL, clientID, clientSecret}// InteractiveLogin prompts the user to go to a URL and enter a code.-func (n *SamNode) InteractiveLogin(ctx context.Context, authURL, tokenURL, clientID, audience string) (string, error) {+func (n *SamNode) InteractiveLogin(ctx context.Context, authURL, tokenURL, clientID, audience string, requestRefresh bool) (string, error) {if authURL == "" {return "", fmt.Errorf("authorization URL is required")}@@ -110,7 +110,13 @@ func (n *SamNode) InteractiveLogin(ctx context.Context, authURL, tokenURL, clienq.Add("response_type", "code")q.Add("client_id", clientID)q.Add("redirect_uri", redirectURI)- q.Add("scope", "openid email profile")+ scope := "openid email profile"+ if requestRefresh {+ scope += " offline_access"+ q.Add("access_type", "offline")+ q.Add("prompt", "consent")+ }+ q.Add("scope", scope)q.Add("state", state)q.Add("code_challenge", challenge)q.Add("code_challenge_method", "S256")@@ -264,13 +270,20 @@ func (n *SamNode) InteractiveLogin(ctx context.Context, authURL, tokenURL, clien}var tokenResp struct {- AccessToken string `json:"access_token"`- IdToken string `json:"id_token"`+ AccessToken string `json:"access_token"`+ IdToken string `json:"id_token"`+ RefreshToken string `json:"refresh_token"`}if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {return "", err}+ if tokenResp.RefreshToken != "" && n.Store != nil {+ if err := n.Store.SaveRefreshToken(tokenResp.RefreshToken); err != nil {+ logger.Warnf("Failed to save refresh token: %v", err)+ }+ }+if tokenResp.IdToken != "" {return tokenResp.IdToken, nil}@@ -334,3 +347,55 @@ func openBrowser(targetURL string) {logger.Debugf("Failed to open browser: %v", cmdErr)}}++// RefreshJWT refreshes the OIDC token using the stored refresh token.+func (n *SamNode) RefreshJWT(ctx context.Context, tokenURL, clientID, clientSecret, refreshToken string) (string, string, error) {+ tokenData := url.Values{}+ tokenData.Set("grant_type", "refresh_token")+ tokenData.Set("client_id", clientID)+ tokenData.Set("refresh_token", refreshToken)+ if clientSecret != "" {+ tokenData.Set("client_secret", clientSecret)+ }++ req, err := http.NewRequestWithContext(ctx, "POST", tokenURL, strings.NewReader(tokenData.Encode()))+ if err != nil {+ return "", "", err+ }+ req.Header.Set("Content-Type", "application/x-www-form-urlencoded")++ client := &http.Client{Timeout: 10 * time.Second}+ resp, err := client.Do(req)+ if err != nil {+ return "", "", err+ }+ defer func() {+ if err := resp.Body.Close(); err != nil {+ logger.Errorf("Failed to close response body: %v", err)+ }+ }()++ if resp.StatusCode != http.StatusOK {+ var errResp struct {+ Error string `json:"error"`+ ErrorDescription string `json:"error_description"`+ }+ _ = json.NewDecoder(resp.Body).Decode(&errResp)+ return "", "", fmt.Errorf("refresh token request failed: %s - %s", errResp.Error, errResp.ErrorDescription)+ }++ var tokenResp struct {+ AccessToken string `json:"access_token"`+ IdToken string `json:"id_token"`+ RefreshToken string `json:"refresh_token"`+ }+ if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {+ return "", "", err+ }++ jwtStr := tokenResp.AccessToken+ if tokenResp.IdToken != "" {+ jwtStr = tokenResp.IdToken+ }+ return jwtStr, tokenResp.RefreshToken, nil+}diff --git a/cmd/sam-node/oidc_test.go b/cmd/sam-node/oidc_test.goindex 857568f6..af0e9a1e 100644--- a/cmd/sam-node/oidc_test.go+++ b/cmd/sam-node/oidc_test.go@@ -6,6 +6,7 @@ import ("net/http""net/http/httptest""net/url"+ "strings""testing""time")@@ -66,7 +67,7 @@ func TestInteractiveLogin(t *testing.T) {}defer func() { openBrowserFunc = originalOpenBrowser }()- token, err := node.InteractiveLogin(ctx, "http://auth.example.com/auth", server.URL+"/token", "client_id_test", "sam-e2e")+ token, err := node.InteractiveLogin(ctx, "http://auth.example.com/auth", server.URL+"/token", "client_id_test", "sam-e2e", false)if err != nil {t.Fatalf("InteractiveLogin failed: %v", err)}@@ -107,3 +108,167 @@ func TestDiscoverEndpoints(t *testing.T) {t.Errorf("Expected authURL %s, got %s", server.URL+"/auth", authURL)}}++func TestInteractiveLoginWithRefresh(t *testing.T) {+ t.Setenv("SSH_CLIENT", "")+ t.Setenv("SSH_TTY", "")++ mux := http.NewServeMux()+ mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {+ if r.Method != "POST" {+ http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)+ return+ }+ _ = r.ParseForm()+ if r.FormValue("grant_type") != "authorization_code" {+ http.Error(w, "Invalid grant_type", http.StatusBadRequest)+ return+ }+ w.Header().Set("Content-Type", "application/json")+ _ = json.NewEncoder(w).Encode(map[string]string{+ "access_token": "access_token_xyz",+ "id_token": "id_token_abc",+ "refresh_token": "refresh_token_123",+ })+ })++ server := httptest.NewServer(mux)+ defer server.Close()++ // Initialize Store+ store, err := NewStore(t.TempDir())+ if err != nil {+ t.Fatalf("Failed to create store: %v", err)+ }+ defer func() {+ if err := store.Close(); err != nil {+ t.Errorf("failed to close store: %v", err)+ }+ }()++ node := &SamNode{Store: store}++ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)+ defer cancel()++ originalOpenBrowser := openBrowserFunc+ openBrowserFunc = func(urlStr string) {+ u, _ := url.Parse(urlStr)+ redirectURI := u.Query().Get("redirect_uri")+ state := u.Query().Get("state")++ // Verify offline_access scope and prompt are present+ scope := u.Query().Get("scope")+ if !strings.Contains(scope, "offline_access") {+ t.Errorf("Expected scope to contain 'offline_access', got %q", scope)+ }+ if u.Query().Get("access_type") != "offline" {+ t.Errorf("Expected access_type to be 'offline', got %q", u.Query().Get("access_type"))+ }++ go func() {+ time.Sleep(100 * time.Millisecond)+ _, _ = http.Get(redirectURI + "?code=dev_code_123&state=" + state)+ }()+ }+ defer func() { openBrowserFunc = originalOpenBrowser }()++ token, err := node.InteractiveLogin(ctx, "http://auth.example.com/auth", server.URL+"/token", "client_id_test", "sam-e2e", true)+ if err != nil {+ t.Fatalf("InteractiveLogin failed: %v", err)+ }++ if token != "id_token_abc" {+ t.Errorf("Expected token 'id_token_abc', got '%s'", token)+ }++ // Verify refresh token is saved in the database+ savedRefresh, err := store.LoadRefreshToken()+ if err != nil {+ t.Fatalf("Failed to load refresh token from store: %v", err)+ }+ if savedRefresh != "refresh_token_123" {+ t.Errorf("Expected saved refresh token 'refresh_token_123', got '%s'", savedRefresh)+ }+}++func TestRenewWithRefreshToken(t *testing.T) {+ mux := http.NewServeMux()+ mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ _ = json.NewEncoder(w).Encode(map[string]interface{}{+ "issuer": "http://" + r.Host,+ "token_endpoint": "http://" + r.Host + "/token",+ "authorization_endpoint": "http://" + r.Host + "/auth",+ })+ })+ mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {+ if r.Method != "POST" {+ http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)+ return+ }+ _ = r.ParseForm()+ if r.FormValue("grant_type") != "refresh_token" {+ http.Error(w, "Invalid grant_type: "+r.FormValue("grant_type"), http.StatusBadRequest)+ return+ }+ if r.FormValue("refresh_token") != "old_refresh_123" {+ http.Error(w, "Invalid refresh token", http.StatusBadRequest)+ return+ }+ if r.FormValue("client_id") != "client_id_test" {+ http.Error(w, "Invalid client_id", http.StatusBadRequest)+ return+ }+ w.Header().Set("Content-Type", "application/json")+ _ = json.NewEncoder(w).Encode(map[string]string{+ "access_token": "new_access_token_xyz",+ "id_token": "new_id_token_abc",+ "refresh_token": "new_refresh_token_456",+ })+ })++ server := httptest.NewServer(mux)+ defer server.Close()++ // Initialize Store+ store, err := NewStore(t.TempDir())+ if err != nil {+ t.Fatalf("Failed to create store: %v", err)+ }+ defer func() {+ if err := store.Close(); err != nil {+ t.Errorf("failed to close store: %v", err)+ }+ }()++ // Store OIDC Config and old refresh token+ if err := store.SaveOIDCConfig(server.URL, "client_id_test", "sam-e2e"); err != nil {+ t.Fatalf("Failed to save OIDC Config: %v", err)+ }+ if err := store.SaveRefreshToken("old_refresh_123"); err != nil {+ t.Fatalf("Failed to save Refresh Token: %v", err)+ }++ node := &SamNode{Store: store}+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)+ defer cancel()++ newJWT, err := node.renewWithRefreshToken(ctx, "")+ if err != nil {+ t.Fatalf("renewWithRefreshToken failed: %v", err)+ }++ if newJWT != "new_id_token_abc" {+ t.Errorf("Expected new JWT 'new_id_token_abc', got '%s'", newJWT)+ }++ // Verify that the new refresh token is saved+ newRefresh, err := store.LoadRefreshToken()+ if err != nil {+ t.Fatalf("Failed to load new refresh token from store: %v", err)+ }+ if newRefresh != "new_refresh_token_456" {+ t.Errorf("Expected updated refresh token 'new_refresh_token_456', got '%s'", newRefresh)+ }+}diff --git a/cmd/sam-node/store.go b/cmd/sam-node/store.goindex e5b1de41..41a7338e 100644--- a/cmd/sam-node/store.go+++ b/cmd/sam-node/store.go@@ -28,10 +28,14 @@ import ()const (- bucketIdentity = "identity"- keyBiscuit = "identity_biscuit"- keyPrivKey = "node_private_key"- keyIdentityExp = "identity_expiration"+ bucketIdentity = "identity"+ keyBiscuit = "identity_biscuit"+ keyPrivKey = "node_private_key"+ keyIdentityExp = "identity_expiration"+ keyRefreshToken = "refresh_token"+ keyOidcIssuer = "oidc_issuer"+ keyOidcClientID = "oidc_client_id"+ keyOidcAudience = "oidc_audience")type Store struct {@@ -118,6 +122,51 @@ func (s *Store) LoadIdentityExpiration() (int64, error) {return exp, nil}+func (s *Store) SaveRefreshToken(token string) error {+ return s.db.Update(func(tx *bbolt.Tx) error {+ b := tx.Bucket([]byte(bucketIdentity))+ return b.Put([]byte(keyRefreshToken), []byte(token))+ })+}++func (s *Store) LoadRefreshToken() (string, error) {+ var val []byte+ _ = s.db.View(func(tx *bbolt.Tx) error {+ b := tx.Bucket([]byte(bucketIdentity))+ val = b.Get([]byte(keyRefreshToken))+ return nil+ })+ if len(val) == 0 {+ return "", fmt.Errorf("no refresh token found")+ }+ return string(val), nil+}++func (s *Store) SaveOIDCConfig(issuer, clientID, audience string) error {+ return s.db.Update(func(tx *bbolt.Tx) error {+ b := tx.Bucket([]byte(bucketIdentity))+ if err := b.Put([]byte(keyOidcIssuer), []byte(issuer)); err != nil {+ return err+ }+ if err := b.Put([]byte(keyOidcClientID), []byte(clientID)); err != nil {+ return err+ }+ return b.Put([]byte(keyOidcAudience), []byte(audience))+ })+}++func (s *Store) LoadOIDCConfig() (string, string, string, error) {+ var issuer, clientID, audience []byte+ err := s.db.View(func(tx *bbolt.Tx) error {+ b := tx.Bucket([]byte(bucketIdentity))+ issuer = b.Get([]byte(keyOidcIssuer))+ clientID = b.Get([]byte(keyOidcClientID))+ audience = b.Get([]byte(keyOidcAudience))+ return nil+ })+ return string(issuer), string(clientID), string(audience), err+}+func (s *Store) SaveKey(key []byte) error {return s.db.Update(func(tx *bbolt.Tx) error {b := tx.Bucket([]byte(bucketIdentity))diff --git a/cmd/sam-node/store_test.go b/cmd/sam-node/store_test.goindex ba3da2b5..16447c50 100644--- a/cmd/sam-node/store_test.go+++ b/cmd/sam-node/store_test.go@@ -13,3 +13,326 @@// limitations under the License.package main++import (+ "bytes"+ "fmt"+ "os"+ "path/filepath"+ "reflect"+ "testing"++ "github.com/libp2p/go-libp2p/core/peer"+ "go.etcd.io/bbolt"+)++func TestStore_NewStore_And_Close(t *testing.T) {+ tempDir := t.TempDir()++ store, err := NewStore(tempDir)+ if err != nil {+ t.Fatalf("Failed to create store: %v", err)+ }++ dbPath := filepath.Join(tempDir, "agent.db")+ if _, err := os.Stat(dbPath); os.IsNotExist(err) {+ t.Errorf("Database file does not exist at %s", dbPath)+ }++ if err := store.Close(); err != nil {+ t.Errorf("Failed to close store: %v", err)+ }+}++func TestStore_Identity(t *testing.T) {+ store, err := NewStore(t.TempDir())+ if err != nil {+ t.Fatalf("Failed to create store: %v", err)+ }+ defer func() {+ if err := store.Close(); err != nil {+ t.Errorf("failed to close store: %v", err)+ }+ }()++ // Loading identity when not set should fail+ _, err = store.LoadIdentity()+ if err == nil {+ t.Error("Expected error loading identity when none is saved, got nil")+ }++ biscuit := []byte("dummy-biscuit-data")+ if err := store.SaveIdentity(biscuit); err != nil {+ t.Fatalf("SaveIdentity failed: %v", err)+ }++ loaded, err := store.LoadIdentity()+ if err != nil {+ t.Fatalf("LoadIdentity failed: %v", err)+ }++ if !bytes.Equal(loaded, biscuit) {+ t.Errorf("Expected loaded identity %s, got %s", string(biscuit), string(loaded))+ }+}++func TestStore_IdentityExpiration(t *testing.T) {+ store, err := NewStore(t.TempDir())+ if err != nil {+ t.Fatalf("Failed to create store: %v", err)+ }+ defer func() {+ if err := store.Close(); err != nil {+ t.Errorf("failed to close store: %v", err)+ }+ }()++ // Loading when not set should fail+ _, err = store.LoadIdentityExpiration()+ if err == nil {+ t.Error("Expected error loading identity expiration when none is saved, got nil")+ }++ exp := int64(1782418067)+ if err := store.SaveIdentityExpiration(exp); err != nil {+ t.Fatalf("SaveIdentityExpiration failed: %v", err)+ }++ loadedExp, err := store.LoadIdentityExpiration()+ if err != nil {+ t.Fatalf("LoadIdentityExpiration failed: %v", err)+ }++ if loadedExp != exp {+ t.Errorf("Expected loaded expiration %d, got %d", exp, loadedExp)+ }+}++func TestStore_RefreshToken(t *testing.T) {+ store, err := NewStore(t.TempDir())+ if err != nil {+ t.Fatalf("Failed to create store: %v", err)+ }+ defer func() {+ if err := store.Close(); err != nil {+ t.Errorf("failed to close store: %v", err)+ }+ }()++ // Loading when not set should fail+ _, err = store.LoadRefreshToken()+ if err == nil {+ t.Error("Expected error loading refresh token when none is saved, got nil")+ }++ token := "refresh-token-xyz"+ if err := store.SaveRefreshToken(token); err != nil {+ t.Fatalf("SaveRefreshToken failed: %v", err)+ }++ loaded, err := store.LoadRefreshToken()+ if err != nil {+ t.Fatalf("LoadRefreshToken failed: %v", err)+ }++ if loaded != token {+ t.Errorf("Expected loaded refresh token %q, got %q", token, loaded)+ }+}++func TestStore_OIDCConfig(t *testing.T) {+ store, err := NewStore(t.TempDir())+ if err != nil {+ t.Fatalf("Failed to create store: %v", err)+ }+ defer func() {+ if err := store.Close(); err != nil {+ t.Errorf("failed to close store: %v", err)+ }+ }()++ // Loading when not set returns empty strings+ iss, cid, aud, err := store.LoadOIDCConfig()+ if err != nil {+ t.Fatalf("LoadOIDCConfig failed: %v", err)+ }+ if iss != "" || cid != "" || aud != "" {+ t.Errorf("Expected empty OIDC config, got issuer=%q, clientID=%q, audience=%q", iss, cid, aud)+ }++ issuer := "https://auth.example.com"+ clientID := "client-123"+ audience := "sam-mesh"++ if err := store.SaveOIDCConfig(issuer, clientID, audience); err != nil {+ t.Fatalf("SaveOIDCConfig failed: %v", err)+ }++ loadedIss, loadedCID, loadedAud, err := store.LoadOIDCConfig()+ if err != nil {+ t.Fatalf("LoadOIDCConfig failed: %v", err)+ }++ if loadedIss != issuer || loadedCID != clientID || loadedAud != audience {+ t.Errorf("Expected OIDC config (%q, %q, %q), got (%q, %q, %q)", issuer, clientID, audience, loadedIss, loadedCID, loadedAud)+ }+}++func TestStore_Key(t *testing.T) {+ store, err := NewStore(t.TempDir())+ if err != nil {+ t.Fatalf("Failed to create store: %v", err)+ }+ defer func() {+ if err := store.Close(); err != nil {+ t.Errorf("failed to close store: %v", err)+ }+ }()++ // Loading when not set should return nil or empty+ loaded, err := store.LoadKey()+ if err != nil {+ t.Fatalf("LoadKey failed: %v", err)+ }+ if len(loaded) > 0 {+ t.Errorf("Expected empty key, got len %d", len(loaded))+ }++ key := []byte("private-key-bytes")+ if err := store.SaveKey(key); err != nil {+ t.Fatalf("SaveKey failed: %v", err)+ }++ loaded, err = store.LoadKey()+ if err != nil {+ t.Fatalf("LoadKey failed: %v", err)+ }++ if !bytes.Equal(loaded, key) {+ t.Errorf("Expected loaded key %v, got %v", key, loaded)+ }+}++func TestStore_HubConfig(t *testing.T) {+ store, err := NewStore(t.TempDir())+ if err != nil {+ t.Fatalf("Failed to create store: %v", err)+ }+ defer func() {+ if err := store.Close(); err != nil {+ t.Errorf("failed to close store: %v", err)+ }+ }()++ // Loading when not set+ pubKey, addrs, err := store.LoadHubConfig()+ if err != nil {+ t.Fatalf("LoadHubConfig failed: %v", err)+ }+ if len(pubKey) > 0 || len(addrs) > 0 {+ t.Errorf("Expected empty hub config, got pubKey=%v, addrs=%v", pubKey, addrs)+ }++ hubPubKey := []byte("hub-public-key-bytes")+ hubAddrs := []string{"/ip4/127.0.0.1/tcp/5001", "/dns4/hub.example.com/tcp/5001"}++ if err := store.SaveHubConfig(hubPubKey, hubAddrs); err != nil {+ t.Fatalf("SaveHubConfig failed: %v", err)+ }++ loadedPubKey, loadedAddrs, err := store.LoadHubConfig()+ if err != nil {+ t.Fatalf("LoadHubConfig failed: %v", err)+ }++ if !bytes.Equal(loadedPubKey, hubPubKey) {+ t.Errorf("Expected loaded hub pubkey %v, got %v", hubPubKey, loadedPubKey)+ }+ if !reflect.DeepEqual(loadedAddrs, hubAddrs) {+ t.Errorf("Expected loaded hub addrs %v, got %v", hubAddrs, loadedAddrs)+ }+}++func TestStore_HubURL(t *testing.T) {+ store, err := NewStore(t.TempDir())+ if err != nil {+ t.Fatalf("Failed to create store: %v", err)+ }+ defer func() {+ if err := store.Close(); err != nil {+ t.Errorf("failed to close store: %v", err)+ }+ }()++ // Loading when not set+ url, err := store.LoadHubURL()+ if err != nil {+ t.Fatalf("LoadHubURL failed: %v", err)+ }+ if url != "" {+ t.Errorf("Expected empty Hub URL, got %q", url)+ }++ hubURL := "https://hub.example.com"+ if err := store.SaveHubURL(hubURL); err != nil {+ t.Fatalf("SaveHubURL failed: %v", err)+ }++ loaded, err := store.LoadHubURL()+ if err != nil {+ t.Fatalf("LoadHubURL failed: %v", err)+ }++ if loaded != hubURL {+ t.Errorf("Expected loaded hub URL %q, got %q", hubURL, loaded)+ }+}++func TestStore_IsBanned(t *testing.T) {+ store, err := NewStore(t.TempDir())+ if err != nil {+ t.Fatalf("Failed to create store: %v", err)+ }+ defer func() {+ if err := store.Close(); err != nil {+ t.Errorf("failed to close store: %v", err)+ }+ }()++ pID, err := peer.Decode("12D3KooWBysiyDVxxj7Lq8KvhFnZVhqKdZHtwRaJu7hvGwSZFMNg")+ if err != nil {+ t.Fatalf("Failed to decode peer ID: %v", err)+ }++ // Verify not banned initially+ if store.IsBanned(pID) {+ t.Errorf("Expected peer %s to not be banned", pID)+ }++ // Manually add peer to banned bucket to test IsBanned+ err = store.db.Update(func(tx *bbolt.Tx) error {+ b := tx.Bucket([]byte("banned_peers"))+ if b == nil {+ return fmt.Errorf("banned_peers bucket not found")+ }+ return b.Put([]byte(pID.String()), []byte("banned"))+ })+ if err != nil {+ t.Fatalf("Failed to manually ban peer: %v", err)+ }++ // Verify banned now+ if !store.IsBanned(pID) {+ t.Errorf("Expected peer %s to be banned", pID)+ }+}++func TestGetDefaultDataDir(t *testing.T) {+ dir, err := GetDefaultDataDir()+ if err != nil {+ t.Fatalf("GetDefaultDataDir failed: %v", err)+ }+ if dir == "" {+ t.Error("Expected non-empty directory path")+ }+}