Files
OpenFlare/internal/apps/openflare/agent/registration_test.go
T
ArthurKoba 72d67c80f2 fix(agent): make discovery enrollment compatible and idempotent (#53)
* fix(agent): make discovery enrollment compatible and idempotent

* fix(agent): confirm enrollment persistence and document token aliases
2026-11-07 21:29:47 +08:00

169 lines
5.5 KiB
Go

// Copyright 2026 Arctel.net
// SPDX-License-Identifier: Apache-2.0
package agent
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"sync"
"testing"
"time"
agentclient "github.com/Rain-kl/Wavelet/internal/apps/agent/httpclient"
db "github.com/Rain-kl/Wavelet/internal/infra/persistence"
"github.com/Rain-kl/Wavelet/internal/model"
"github.com/Rain-kl/Wavelet/internal/repository"
"github.com/Rain-kl/Wavelet/internal/shared/response"
"github.com/Rain-kl/Wavelet/pkg/protocol"
)
func TestRegistrationResponseServerClientContract(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(response.OK(RegistrationResponse{NodeID: "node-contract", AccessToken: "issued", Name: "edge"})); err != nil {
t.Error(err)
}
}))
t.Cleanup(server.Close)
client := agentclient.New(server.URL, "discovery", time.Second)
got, err := client.RegisterNode(context.Background(), protocol.RegisterNodeRequest{})
if err != nil {
t.Fatalf("RegisterNode(server response) error = %v", err)
}
if got.NodeID != "node-contract" || got.AccessToken != "issued" || got.Name != "edge" {
t.Errorf("RegisterNode(server response) = %+v, want node-contract/issued/edge", got)
}
data, err := json.Marshal(RegistrationResponse{AccessToken: "issued"})
if err != nil {
t.Fatal(err)
}
var legacy struct {
AccessToken string `json:"access_token"`
}
if err = json.Unmarshal(data, &legacy); err != nil || legacy.AccessToken != "issued" {
t.Errorf("Decode legacy server response = %q, %v; want issued, nil", legacy.AccessToken, err)
}
var documented RegistrationResponseDocs
if err = json.Unmarshal(data, &documented); err != nil {
t.Fatal(err)
}
if documented.AgentToken != "issued" || documented.AccessToken != documented.AgentToken {
t.Error("RegistrationResponseDocs does not describe both emitted token aliases")
}
}
func TestDiscoveryRetriesKeepOneIdentityAndPreserveChanges(t *testing.T) {
t.Cleanup(setupAgentAuthTestDB(t))
ctx := context.Background()
key := strings.Repeat("a1", 32)
payload := NodePayload{IP: "10.0.0.8", Version: "test", Name: "edge"}
first, err := RegisterWithDiscovery(ctx, payload, key)
if err != nil {
t.Fatal(err)
}
record, err := repository.GetOpenFlareNodeByNodeID(ctx, first.NodeID)
if err != nil {
t.Fatal(err)
}
record.Name = "administrator name"
record.UpdateRequested = true
if err = repository.SaveOpenFlareNode(ctx, record); err != nil {
t.Fatal(err)
}
second, err := RegisterWithDiscovery(ctx, payload, key)
if err != nil {
t.Fatal(err)
}
if first.NodeID != second.NodeID || first.AccessToken != second.AccessToken {
t.Errorf("RegisterWithDiscovery(retry) identity = %+v, want original identity", second)
}
record, err = repository.GetOpenFlareNodeByNodeID(ctx, first.NodeID)
if err != nil {
t.Fatal(err)
}
if record.Name != "administrator name" || !record.UpdateRequested {
t.Errorf("RegisterWithDiscovery(retry) overwrote administrator metadata: %+v", record)
}
other, err := RegisterWithDiscovery(ctx, payload, strings.Repeat("b2", 32))
if err != nil {
t.Fatal(err)
}
if other.NodeID == first.NodeID || other.AccessToken == first.AccessToken {
t.Error("RegisterWithDiscovery(distinct key, same host/IP) reused identity")
}
var count int64
if err = db.DB(ctx).Model(&model.OpenFlareNode{}).Count(&count).Error; err != nil {
t.Fatal(err)
}
if count != 2 {
t.Errorf("RegisterWithDiscovery(two keys, retry) node count = %d, want 2", count)
}
}
func TestDiscoveryConcurrentRetriesAndRevokedCredential(t *testing.T) {
t.Cleanup(setupAgentAuthTestDB(t))
ctx := context.Background()
sqlDB, err := db.DB(ctx).DB()
if err != nil {
t.Fatal(err)
}
sqlDB.SetMaxOpenConns(1)
key := strings.Repeat("c3", 32)
payload := NodePayload{IP: "10.0.0.8", Version: "test"}
const attempts = 12
results := make(chan *RegistrationResponse, attempts)
errors := make(chan error, attempts)
var wg sync.WaitGroup
for range attempts {
wg.Go(func() {
result, registrationErr := RegisterWithDiscovery(ctx, payload, key)
results <- result
errors <- registrationErr
})
}
wg.Wait()
close(results)
close(errors)
for registrationErr := range errors {
if registrationErr != nil {
t.Fatalf("Concurrent RegisterWithDiscovery error = %v", registrationErr)
}
}
var first *RegistrationResponse
for result := range results {
if first == nil {
first = result
}
if result.NodeID != first.NodeID || result.AccessToken != first.AccessToken {
t.Error("Concurrent enrollment returned different identities")
}
}
var count int64
if err = db.DB(ctx).Model(&model.OpenFlareNode{}).Count(&count).Error; err != nil {
t.Fatal(err)
}
if count != 1 {
t.Errorf("Concurrent enrollment node count = %d, want 1", count)
}
record, err := repository.GetOpenFlareNodeByNodeID(ctx, first.NodeID)
if err != nil {
t.Fatal(err)
}
record.AccessToken = "rotated-by-administrator"
if err = repository.SaveOpenFlareNode(ctx, record); err != nil {
t.Fatal(err)
}
if result, retryErr := RegisterWithDiscovery(ctx, payload, key); retryErr == nil || result != nil {
t.Errorf("RegisterWithDiscovery(rotated credential) = %+v, %v; want rejection", result, retryErr)
}
for _, invalid := range []string{"short", strings.Repeat("g", 64), first.NodeID} {
if result, retryErr := RegisterWithDiscovery(ctx, payload, invalid); retryErr == nil || result != nil {
t.Errorf("RegisterWithDiscovery(invalid/public key) = %+v, %v; want rejection", result, retryErr)
}
}
}