Files
wg-portal/internal/app/wireguard/statistics_commit_test.go
T
8ddb46c822 fix: publish collected statistics after status transactions commit (#771)
* fix: publish collected statistics after status transactions commit

Release the SQLite connection before publishing to bounded subscribers
that may read peer ownership. Schedule metrics and publish connection-
state changes only after a successful status update.

Signed-off-by: Dixiao-L <stgowl@outlook.com>

* ensure that tests are successful against the current master branch

---------

Signed-off-by: Dixiao-L <stgowl@outlook.com>
Co-authored-by: Christoph <christoph.h@sprinternet.at>
2026-11-09 22:00:04 +01:00

226 lines
8.3 KiB
Go

package wireguard
import (
"context"
"database/sql"
"errors"
"path/filepath"
"sync"
"testing"
"time"
"github.com/h44z/wg-portal/internal/adapters"
"github.com/h44z/wg-portal/internal/app"
"github.com/h44z/wg-portal/internal/config"
"github.com/h44z/wg-portal/internal/domain"
"github.com/stretchr/testify/require"
"gorm.io/gorm"
"gorm.io/gorm/schema"
)
// Only return interfaces once, so each test observes exactly one collection pass.
type statisticsTestRepo struct {
*adapters.SqlRepo
once sync.Once
}
func (r *statisticsTestRepo) GetAllInterfaces(ctx context.Context) (interfaces []domain.Interface, err error) {
r.once.Do(func() { interfaces, err = r.SqlRepo.GetAllInterfaces(ctx) })
return
}
type statisticsTestController struct{ domain.InterfaceController }
func (*statisticsTestController) GetInterface(_ context.Context, id domain.InterfaceIdentifier) (*domain.PhysicalInterface, error) {
return &domain.PhysicalInterface{Identifier: id, BytesUpload: 42, BytesDownload: 24}, nil
}
func (*statisticsTestController) GetPeers(context.Context, domain.InterfaceIdentifier) ([]domain.PhysicalPeer, error) {
return []domain.PhysicalPeer{{Identifier: "peer", BytesUpload: 42, BytesDownload: 24, LastHandshake: time.Now()}}, nil
}
type statisticsTestBus struct{ publish func(string, ...any) }
func (b statisticsTestBus) Publish(topic string, args ...any) { b.publish(topic, args...) }
func (statisticsTestBus) Subscribe(string, any) error { return nil }
type statisticsTestMetrics struct{ statuses chan any }
func (m statisticsTestMetrics) UpdateInterfaceMetrics(s domain.InterfaceStatus) { m.statuses <- s }
func (m statisticsTestMetrics) UpdatePeerMetrics(_ *domain.Peer, s domain.PeerStatus) {
m.statuses <- s
}
func (statisticsTestMetrics) DeletePeerMetrics(domain.Peer) {}
func newStatisticsTestCollector(t *testing.T) (*StatisticsCollector, *gorm.DB, statisticsTestMetrics) {
t.Helper()
schema.RegisterSerializer("encstr", app.NewGormEncryptedStringSerializer(""))
cfg := &config.Config{}
cfg.Database = config.DatabaseConfig{Type: config.DatabaseSQLite, DSN: filepath.Join(t.TempDir(), "statistics.db")}
cfg.Statistics.DataCollectionInterval = time.Millisecond
cfg.Backend.ReKeyTimeoutInterval = time.Minute
db, err := adapters.NewDatabase(cfg.Database)
require.NoError(t, err)
sqlDB, err := db.DB()
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, sqlDB.Close()) })
require.Equal(t, 1, sqlDB.Stats().MaxOpenConnections)
repo, err := adapters.NewSqlRepository(db, cfg)
require.NoError(t, err)
require.NoError(t, db.Create(&domain.Interface{Identifier: "wg0"}).Error)
require.NoError(t, db.Create(&domain.User{Identifier: "user"}).Error)
require.NoError(t, db.Create(&domain.Peer{Identifier: "peer", UserIdentifier: "user", InterfaceIdentifier: "wg0"}).Error)
old := time.Now().Add(-time.Minute)
require.NoError(t, db.Create(&domain.PeerStatus{PeerId: "peer", UpdatedAt: old, BytesReceived: 2, BytesTransmitted: 1}).Error)
require.NoError(t, db.Create(&domain.InterfaceStatus{InterfaceId: "wg0", UpdatedAt: old, BytesReceived: 2, BytesTransmitted: 1}).Error)
metrics := statisticsTestMetrics{statuses: make(chan any, 4)}
collector := &StatisticsCollector{
cfg: cfg, db: &statisticsTestRepo{SqlRepo: repo}, ms: metrics,
wg: &ControllerManager{controllers: map[domain.InterfaceBackend]backendInstance{
config.LocalBackendName: {Implementation: &statisticsTestController{}},
}},
}
return collector, db, metrics
}
func startStatisticsTestCollector(t *testing.T, collector *StatisticsCollector, kind string) {
t.Helper()
ctx, cancel := context.WithCancel(context.Background())
done := make(chan struct{})
go func() {
defer close(done)
if kind == "peer" {
collector.collectPeerData(ctx)
} else {
collector.collectInterfaceData(ctx)
}
}()
t.Cleanup(func() {
cancel()
select {
case <-done:
case <-time.After(3 * time.Second):
t.Error("collector did not stop")
}
})
}
func receiveStatisticsTest[T any](t *testing.T, ch <-chan T) T {
t.Helper()
select {
case value := <-ch:
return value
case <-time.After(3 * time.Second):
t.Fatal("timed out waiting for statistics collection")
}
var zero T
return zero
}
// The subscriber reads through the real one-connection pool before Publish returns.
// Publishing inside the transaction cannot satisfy this read.
func TestStatisticsSubscribersReadCommittedStatus(t *testing.T) {
for _, kind := range []string{"peer", "interface"} {
t.Run(kind, func(t *testing.T) {
collector, db, metrics := newStatisticsTestCollector(t)
results := make(chan error, 1)
state := make(chan domain.PeerStatus, 1)
collector.bus = statisticsTestBus{publish: func(topic string, args ...any) {
if topic == app.TopicPeerStateChanged {
state <- args[0].(domain.PeerStatus)
return
}
readCtx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
if kind == "peer" {
var status domain.PeerStatus
err := db.WithContext(readCtx).First(&status, "identifier = ?", "peer").Error
if err == nil && (status.BytesReceived != 42 || status.BytesTransmitted != 24 || !status.IsConnected) {
err = errors.New("peer event preceded committed status")
}
results <- err
} else {
var status domain.InterfaceStatus
err := db.WithContext(readCtx).First(&status, "identifier = ?", "wg0").Error
if err == nil && (status.BytesReceived != 24 || status.BytesTransmitted != 42) {
err = errors.New("interface event preceded committed status")
}
results <- err
}
}}
startStatisticsTestCollector(t, collector, kind)
require.NoError(t, receiveStatisticsTest(t, results))
status := receiveStatisticsTest(t, metrics.statuses)
if kind == "peer" {
s := status.(domain.PeerStatus)
require.EqualValues(t, 42, s.BytesReceived)
require.EqualValues(t, 24, s.BytesTransmitted)
require.True(t, s.IsConnected)
require.Equal(t, s, receiveStatisticsTest(t, state))
} else {
s := status.(domain.InterfaceStatus)
require.EqualValues(t, 24, s.BytesReceived)
require.EqualValues(t, 42, s.BytesTransmitted)
}
})
}
}
// Fail at the COMMIT boundary after the callback and real SQLite save succeed.
// Roll back the underlying transaction so the injected failure releases its connection.
type statisticsCommitFailurePool struct{ *sql.DB }
func (p statisticsCommitFailurePool) BeginTx(ctx context.Context, options *sql.TxOptions) (gorm.ConnPool, error) {
tx, err := p.DB.BeginTx(ctx, options)
if err != nil {
return nil, err
}
return &statisticsCommitFailureTx{Tx: tx}, nil
}
type statisticsCommitFailureTx struct{ *sql.Tx }
func (tx statisticsCommitFailureTx) Commit() error {
return errors.Join(errors.New("injected commit failure"), tx.Tx.Rollback())
}
func TestStatisticsRollbackDoesNotPublish(t *testing.T) {
for _, kind := range []string{"peer", "interface"} {
for _, failure := range []string{"save", "commit"} {
t.Run(kind+"/"+failure, func(t *testing.T) {
collector, db, metrics := newStatisticsTestCollector(t)
if failure == "commit" {
pool, err := db.DB()
require.NoError(t, err)
db.Statement.ConnPool = &statisticsCommitFailurePool{DB: pool}
}
failed := make(chan struct{}, 1)
require.NoError(t, db.Callback().Update().Before("gorm:update").Register("test:reject-status", func(tx *gorm.DB) {
if failure == "save" {
tx.AddError(errors.New("injected status write failure"))
}
failed <- struct{}{}
}))
published := make(chan string, 4)
collector.bus = statisticsTestBus{publish: func(topic string, _ ...any) { published <- topic }}
startStatisticsTestCollector(t, collector, kind)
receiveStatisticsTest(t, failed)
// This read also waits for rollback to release the only connection.
var peer domain.PeerStatus
var iface domain.InterfaceStatus
require.NoError(t, db.First(&peer, "identifier = ?", "peer").Error)
require.NoError(t, db.First(&iface, "identifier = ?", "wg0").Error)
require.EqualValues(t, 2, peer.BytesReceived)
require.False(t, peer.IsConnected)
require.EqualValues(t, 1, iface.BytesTransmitted)
select {
case topic := <-published:
t.Errorf("rolled back update published %s", topic)
case status := <-metrics.statuses:
t.Errorf("rolled back update scheduled metrics: %+v", status)
case <-time.After(100 * time.Millisecond):
}
})
}
}
}