Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package environment
import (
"cmp"
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/coder/websocket"
"github.com/getarcaneapp/arcane/types/v2/backup"
"github.com/getarcaneapp/arcane/types/v2/containerregistry"
"github.com/getarcaneapp/arcane/types/v2/environment"
"github.com/getarcaneapp/arcane/types/v2/gitops"
"github.com/getarcaneapp/arcane/types/v2/scheduler"
"github.com/libtnb/sqlite"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
kit "go.getarcane.app/kit/pkg"
"go.getarcane.app/sys/crypto"
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/apikey"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/environment/children/snippets"
"github.com/getarcaneapp/arcane/backend/v2/internal/event"
"github.com/getarcaneapp/arcane/backend/v2/internal/gitrepo"
"github.com/getarcaneapp/arcane/backend/v2/internal/registry"
"github.com/getarcaneapp/arcane/backend/v2/internal/s3"
"github.com/getarcaneapp/arcane/backend/v2/internal/session"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/internal/user"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/edge"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
"github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler/entityjobs"
"github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler/runs"
francistest "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/francis/testing"
)
type environmentTestScheduler struct {
submitted []scheduler.Request
added []string
removed []string
}
// Project imports environment, so these rows avoid an import cycle in tests.
type testProjectRow struct {
database.BaseModel
Name string
Path string
Status string
GitOpsManagedBy *string `gorm:"column:gitops_managed_by"`
}
type testGitOpsSyncRow struct {
database.BaseModel
Name string
EnvironmentID string
RepositoryID string
ComposePath string
ProjectName string
SyncInterval int
}
type testFederatedCredentialRow struct {
database.BaseModel
Name string
IdentityUserID string `gorm:"column:identity_user_id"`
EnvironmentID *string `gorm:"column:environment_id"`
}
type testGlobalVariableRow struct {
database.BaseModel
Key string
AllEnvironments bool `gorm:"column:all_environments"`
}
type testGlobalVariableEnvironmentRow struct {
GlobalVariableID string `gorm:"column:global_variable_id;primaryKey"`
EnvironmentID string `gorm:"column:environment_id;primaryKey"`
}
func (testFederatedCredentialRow) TableName() string { return "federated_credentials" }
func (testGlobalVariableRow) TableName() string { return "global_variables" }
func (testGlobalVariableEnvironmentRow) TableName() string { return "global_variable_environments" }
func TestEnvironmentService_OverlappingHealthCheckIsSkipped(t *testing.T) {
gate := newAdmissionGateForEnvironmentTest(t)
key := scheduler.AdmissionKey{Scope: environmentHealthAdmissionScope, ID: "environment-id"}
lease, admitted, err := gate.TryAcquire(t.Context(), key)
require.NoError(t, err)
require.True(t, admitted)
service := NewEnvironmentService(nil, http.DefaultClient, nil, nil, nil, nil)
require.NoError(t, service.SetScheduler(t.Context(), &environmentTestScheduler{}, gate))
outcome, runErr := service.runHealthCheck(t.Context(), "environment-id")
require.NoError(t, runErr)
require.Equal(t, scheduler.Skipped, outcome.Status)
lease.Release(t.Context())
}
func (s *environmentTestScheduler) AddJob(_ context.Context, job scheduler.Job) error {
s.added = append(s.added, job.Name())
return nil
}
func (s *environmentTestScheduler) RemoveJob(_ context.Context, name string) {
s.removed = append(s.removed, name)
}
func (s *environmentTestScheduler) HasJob(_ string) bool {
return false
}
func newAdmissionGateForEnvironmentTest(t testing.TB) *runs.Admission {
t.Helper()
runtime := francistest.New(t)
gate := runs.NewAdmission(runtime.Service(), t.Name())
require.NoError(t, gate.Register(runtime))
francistest.Start(t, runtime)
return gate
}
func (testProjectRow) TableName() string { return "projects" }
func (testGitOpsSyncRow) TableName() string { return "gitops_syncs" }
func setupEnvironmentServiceTestDB(t *testing.T) *database.DB {
t.Helper()
dsn := fmt.Sprintf("file:%s?mode=memory&cache=shared", strings.NewReplacer("/", "_", " ", "_").Replace(t.Name()))
db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, db.AutoMigrate(
&Environment{},
®istry.ContainerRegistry{},
&s3.S3Destination{},
&settings.SettingVariable{},
&user.User{},
&apikey.ApiKey{},
&event.Event{},
&testProjectRow{},
&testGitOpsSyncRow{},
&testFederatedCredentialRow{},
&testGlobalVariableRow{},
&testGlobalVariableEnvironmentRow{},
))
sqlDB, err := db.DB()
require.NoError(t, err)
sqlDB.SetMaxOpenConns(1)
sqlDB.SetMaxIdleConns(1)
testCfg := &config.Config{
EncryptionKey: "test-encryption-key-for-testing-32bytes-min",
Environment: "test",
}
crypto.InitEncryption(&crypto.Config{
EncryptionKey: testCfg.EncryptionKey,
Environment: string(testCfg.Environment),
AgentMode: testCfg.AgentMode,
})
return &database.DB{DB: db}
}
func createTestEnvironmentServiceUser(t *testing.T, ctx context.Context, userService *user.UserService, id string) *user.User {
t.Helper()
localUser := &user.User{
ID: id,
Username: "user-" + id,
}
created, err := userService.CreateUser(ctx, localUser)
require.NoError(t, err)
return created
}
func createTestEnvironment(t *testing.T, db *database.DB, id, apiURL string, accessToken *string) {
t.Helper()
createNamedTestEnvironment(t, db, id, "env-"+id, apiURL, accessToken)
}
func createNamedTestEnvironment(t *testing.T, db *database.DB, id, name, apiURL string, accessToken *string) {
t.Helper()
now := time.Now()
env := &Environment{
ID: id,
CreatedAt: now,
UpdatedAt: &now,
Name: name,
ApiUrl: apiURL,
Status: string(EnvironmentStatusOnline),
Enabled: true,
AccessToken: accessToken,
}
require.NoError(t, db.WithContext(t.Context()).Create(env).Error)
}
func createTestEnvironmentWithState(t *testing.T, db *database.DB, id, apiURL, status string, isEdge bool, accessToken *string) {
t.Helper()
now := time.Now()
env := &Environment{
ID: id,
CreatedAt: now,
UpdatedAt: &now,
Name: "env-" + id,
ApiUrl: apiURL,
Status: status,
Enabled: true,
IsEdge: isEdge,
AccessToken: accessToken,
}
require.NoError(t, db.WithContext(t.Context()).Create(env).Error)
}
func TestEnvironmentService_DeleteEnvironment_CascadesGitOpsSyncs(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
require.NoError(t, db.AutoMigrate(&testProjectRow{}, &testGitOpsSyncRow{}))
createTestEnvironment(t, db, "env-delete-gitops", "http://env.example", nil)
syncID := "sync-delete-env"
require.NoError(t, db.Create(&testGitOpsSyncRow{
ID: syncID,
Name: "delete-env-sync",
EnvironmentID: "env-delete-gitops",
RepositoryID: "repo-1",
ComposePath: "compose.yml",
ProjectName: "demo",
SyncInterval: 15,
}).Error)
require.NoError(t, db.Create(&testProjectRow{
ID: "project-managed-by-deleted-env",
Name: "demo",
Path: "/tmp/demo",
Status: "stopped",
GitOpsManagedBy: &syncID,
}).Error)
jobScheduler := &environmentTestScheduler{}
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
require.NoError(t, svc.SetScheduler(ctx, jobScheduler, newAdmissionGateForEnvironmentTest(t)))
require.NoError(t, svc.DeleteEnvironment(ctx, "env-delete-gitops", nil, nil))
var syncCount int64
require.NoError(t, db.Model(&testGitOpsSyncRow{}).Where("id = ?", syncID).Count(&syncCount).Error)
require.Zero(t, syncCount)
var project testProjectRow
require.NoError(t, db.First(&project, "id = ?", "project-managed-by-deleted-env").Error)
require.Nil(t, project.GitOpsManagedBy)
require.Contains(t, jobScheduler.removed, entityjobs.GitOpsSyncJobPrefix+syncID)
}
func TestEnvironmentService_DeleteEnvironment_RemovesScopedCredentialsAndVariables(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
createTestEnvironment(t, db, "env-delete-scoped", "http://scoped.example", nil)
createTestEnvironment(t, db, "env-keep", "http://keep.example", nil)
require.NoError(t, db.Create(&user.User{ID: "federated-user", Username: "federated-user"}).Error)
require.NoError(t, db.Create(&testFederatedCredentialRow{
ID: "credential-scoped",
Name: "scoped",
IdentityUserID: "federated-user",
EnvironmentID: new("env-delete-scoped"),
}).Error)
require.NoError(t, db.Create(&[]testGlobalVariableRow{
{ID: "var-only-deleted", Key: "ONLY_DELETED"},
{ID: "var-shared", Key: "SHARED"},
{ID: "var-all", Key: "ALL", AllEnvironments: true},
}).Error)
require.NoError(t, db.Create(&[]testGlobalVariableEnvironmentRow{
{GlobalVariableID: "var-only-deleted", EnvironmentID: "env-delete-scoped"},
{GlobalVariableID: "var-shared", EnvironmentID: "env-delete-scoped"},
{GlobalVariableID: "var-shared", EnvironmentID: "env-keep"},
}).Error)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
var invalidatedUserIDs []string
svc.SetUserInvalidator(func(userID string) { invalidatedUserIDs = append(invalidatedUserIDs, userID) })
require.NoError(t, svc.DeleteEnvironment(ctx, "env-delete-scoped", nil, nil))
require.Equal(t, []string{"federated-user"}, invalidatedUserIDs)
var credentialCount, userCount int64
require.NoError(t, db.Model(&testFederatedCredentialRow{}).Count(&credentialCount).Error)
require.NoError(t, db.Model(&user.User{}).Where("id = ?", "federated-user").Count(&userCount).Error)
require.Zero(t, credentialCount)
require.Zero(t, userCount)
var variableIDs []string
require.NoError(t, db.Model(&testGlobalVariableRow{}).Order("id").Pluck("id", &variableIDs).Error)
require.Equal(t, []string{"var-all", "var-shared"}, variableIDs)
var scopes []testGlobalVariableEnvironmentRow
require.NoError(t, db.Find(&scopes).Error)
require.Equal(t, []testGlobalVariableEnvironmentRow{{GlobalVariableID: "var-shared", EnvironmentID: "env-keep"}}, scopes)
}
func TestEnvironmentService_IsKnownAccessToken_TracksTokenWrites(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
createTestEnvironmentWithState(t, db, "env-known", "http://known.example", string(EnvironmentStatusOnline), false, new("seeded-token"))
createTestEnvironmentWithState(t, db, "env-shared", "http://shared.example", string(EnvironmentStatusOnline), false, new("seeded-token"))
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
require.False(t, svc.IsKnownAccessToken("seeded-token"))
require.NoError(t, svc.LoadAccessTokens(ctx))
require.True(t, svc.IsKnownAccessToken("seeded-token"))
require.False(t, svc.IsKnownAccessToken(strings.Repeat("x", maxAccessTokenLength+1)))
require.NoError(t, svc.linkEnvironmentApiKey(ctx, "env-known", "key-rotated", "rotated-token", "", "", "env-known"))
require.True(t, svc.IsKnownAccessToken("seeded-token"))
require.True(t, svc.IsKnownAccessToken("rotated-token"))
_, err := svc.UpdateEnvironment(ctx, "env-known", map[string]any{"access_token": "updated-token"}, nil, nil)
require.NoError(t, err)
require.False(t, svc.IsKnownAccessToken("rotated-token"))
require.True(t, svc.IsKnownAccessToken("updated-token"))
require.NoError(t, svc.DeleteEnvironment(ctx, "env-known", nil, nil))
require.False(t, svc.IsKnownAccessToken("updated-token"))
require.True(t, svc.IsKnownAccessToken("seeded-token"))
require.NoError(t, svc.DeleteEnvironment(ctx, "env-shared", nil, nil))
require.False(t, svc.IsKnownAccessToken("seeded-token"))
}
func createTestRegistry(t *testing.T, db *database.DB, id string) {
t.Helper()
encryptedToken, err := crypto.Encrypt("registry-token")
require.NoError(t, err)
now := time.Now()
localRegistry := ®istry.ContainerRegistry{
BaseModel: database.BaseModel{
ID: id,
CreatedAt: now,
UpdatedAt: &now,
},
URL: "registry.example.com",
Username: "registry-user",
Token: encryptedToken,
Enabled: true,
Insecure: false,
RegistryType: registry.RegistryTypeGeneric,
CreatedAt: now,
UpdatedAt: now,
}
require.NoError(t, db.WithContext(t.Context()).Create(localRegistry).Error)
}
func createTestECRRegistry(t *testing.T, db *database.DB, id string) {
t.Helper()
encryptedSecret, err := crypto.Encrypt("aws-secret")
require.NoError(t, err)
now := time.Now()
localRegistry := ®istry.ContainerRegistry{
BaseModel: database.BaseModel{
ID: id,
CreatedAt: now,
UpdatedAt: &now,
},
URL: "123456789012.dkr.ecr.us-east-1.amazonaws.com",
Enabled: true,
RegistryType: registry.RegistryTypeECR,
AWSAccessKeyID: "AKIA1234567890EXAMPLE",
AWSSecretAccessKey: encryptedSecret,
AWSRegion: "us-east-1",
CreatedAt: now,
UpdatedAt: now,
}
require.NoError(t, db.WithContext(t.Context()).Create(localRegistry).Error)
}
func createTestGitRepository(t *testing.T, db *database.DB, repository gitrepo.GitRepository) {
t.Helper()
require.NoError(t, db.Create(&repository).Error)
}
func encryptSecretForTest(t *testing.T, value string) string {
t.Helper()
encrypted, err := crypto.Encrypt(value)
require.NoError(t, err)
return encrypted
}
func TestEnvironmentService_SyncRegistriesToRemoteEnvironments_SyncsEligibleRemotes(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestRegistry(t, db, "reg-1")
var env1Calls atomic.Int32
env1Token := "token-1"
env1Server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !assert.Equal(t, http.MethodPost, r.Method) {
return
}
if !assert.Equal(t, "/api/container-registries/sync", r.URL.Path) {
return
}
if !assert.Equal(t, env1Token, r.Header.Get("X-API-Key")) {
return
}
if !assert.Equal(t, env1Token, r.Header.Get("X-Arcane-Agent-Token")) {
return
}
var syncReq containerregistry.SyncRequest
if !assert.NoError(t, json.NewDecoder(r.Body).Decode(&syncReq)) {
return
}
if !assert.Len(t, syncReq.Registries, 1) {
return
}
env1Calls.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"success":true,"data":{"message":"ok"}}`))
}))
defer env1Server.Close()
var env2Calls atomic.Int32
env2Token := "token-2"
env2Server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !assert.Equal(t, http.MethodPost, r.Method) {
return
}
if !assert.Equal(t, "/api/container-registries/sync", r.URL.Path) {
return
}
if !assert.Equal(t, env2Token, r.Header.Get("X-API-Key")) {
return
}
if !assert.Equal(t, env2Token, r.Header.Get("X-Arcane-Agent-Token")) {
return
}
var syncReq containerregistry.SyncRequest
if !assert.NoError(t, json.NewDecoder(r.Body).Decode(&syncReq)) {
return
}
if !assert.Len(t, syncReq.Registries, 1) {
return
}
env2Calls.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"success":true,"data":{"message":"ok"}}`))
}))
defer env2Server.Close()
createTestEnvironment(t, db, "0", "http://localhost:3552", nil) // local env should be excluded
createTestEnvironment(t, db, "env-1", env1Server.URL, &env1Token)
createTestEnvironment(t, db, "env-2", env2Server.URL, &env2Token)
err := svc.SyncRegistriesToRemoteEnvironments(ctx)
require.NoError(t, err)
require.EqualValues(t, 1, env1Calls.Load())
require.EqualValues(t, 1, env2Calls.Load())
}
func TestEnvironmentService_SyncRegistriesToEnvironment_IncludesECRFields(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestECRRegistry(t, db, "reg-ecr")
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !assert.Equal(t, http.MethodPost, r.Method) {
return
}
if !assert.Equal(t, "/api/container-registries/sync", r.URL.Path) {
return
}
var syncReq containerregistry.SyncRequest
if !assert.NoError(t, json.NewDecoder(r.Body).Decode(&syncReq)) {
return
}
if !assert.Len(t, syncReq.Registries, 1) {
return
}
syncedRegistry := syncReq.Registries[0]
if !assert.Equal(t, registry.RegistryTypeECR, syncedRegistry.RegistryType) {
return
}
if !assert.Equal(t, "123456789012.dkr.ecr.us-east-1.amazonaws.com", syncedRegistry.URL) {
return
}
if !assert.Equal(t, "AKIA1234567890EXAMPLE", syncedRegistry.AWSAccessKeyID) {
return
}
if !assert.Equal(t, "aws-secret", syncedRegistry.AWSSecretAccessKey) {
return
}
if !assert.Equal(t, "us-east-1", syncedRegistry.AWSRegion) {
return
}
if !assert.Empty(t, syncedRegistry.Username) {
return
}
if !assert.Empty(t, syncedRegistry.Token) {
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"success":true,"data":{"message":"ok"}}`))
}))
defer server.Close()
createTestEnvironment(t, db, "env-1", server.URL, new("token-1"))
err := svc.SyncRegistriesToEnvironment(ctx, "env-1")
require.NoError(t, err)
}
func TestEnvironmentService_SyncS3DestinationsToEnvironment(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
encryptedSecret, err := crypto.Encrypt("s3-secret")
require.NoError(t, err)
require.NoError(t, db.WithContext(ctx).Create(&s3.S3Destination{
ID: "s3-1",
Name: "Offsite",
Endpoint: "https://s3.example.com",
Bucket: "volume-backups",
Region: "eu-central-1",
AccessKeyID: "s3-access-key",
SecretAccessKey: encryptedSecret,
Prefix: "agents",
UseSSL: true,
ForcePathStyle: true,
}).Error)
accessToken := "agent-token"
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !assert.Equal(t, http.MethodPost, r.Method) {
return
}
if !assert.Equal(t, "/api/backups/s3/sync", r.URL.Path) {
return
}
if !assert.Equal(t, accessToken, r.Header.Get("X-API-Key")) {
return
}
if !assert.Equal(t, accessToken, r.Header.Get("X-Arcane-Agent-Token")) {
return
}
var syncReq backup.S3DestinationSyncRequest
if !assert.NoError(t, json.NewDecoder(r.Body).Decode(&syncReq)) {
return
}
if !assert.Len(t, syncReq.Destinations, 1) {
return
}
if !assert.Equal(t, "s3-1", syncReq.Destinations[0].ID) {
return
}
if !assert.Equal(t, "s3-secret", syncReq.Destinations[0].SecretAccessKey) {
return
}
if !assert.Equal(t, "volume-backups", syncReq.Destinations[0].Bucket) {
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"success":true,"data":{"message":"ok"}}`))
}))
defer server.Close()
createTestEnvironment(t, db, "env-s3", server.URL, &accessToken)
require.NoError(t, svc.SyncS3DestinationsToEnvironment(ctx, "env-s3"))
}
func TestEnvironmentService_SyncRepositoriesToEnvironment_UsesAgentHeaders(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
require.NoError(t, db.AutoMigrate(&gitrepo.GitRepository{}))
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestGitRepository(t, db, gitrepo.GitRepository{
ID: "repo-1", CreatedAt: time.Now(),
Name: "repo-1",
URL: "https://github.com/getarcaneapp/arcane.git",
AuthType: "http",
Username: "arcane",
Token: encryptSecretForTest(t, "repo-token"),
Enabled: true,
Description: new("test repo"),
})
accessToken := "token-1"
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !assert.Equal(t, http.MethodPost, r.Method) {
return
}
if !assert.Equal(t, "/api/git-repositories/sync", r.URL.Path) {
return
}
if !assert.Equal(t, accessToken, r.Header.Get("X-API-Key")) {
return
}
if !assert.Equal(t, accessToken, r.Header.Get("X-Arcane-Agent-Token")) {
return
}
var syncReq gitops.RepositorySyncRequest
if !assert.NoError(t, json.NewDecoder(r.Body).Decode(&syncReq)) {
return
}
if !assert.Len(t, syncReq.Repositories, 1) {
return
}
if !assert.Equal(t, "repo-token", syncReq.Repositories[0].Token) {
return
}
if !assert.Equal(t, "arcane", syncReq.Repositories[0].Username) {
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"success":true,"data":{"message":"ok"}}`))
}))
defer server.Close()
createTestEnvironment(t, db, "env-1", server.URL, &accessToken)
err := svc.SyncRepositoriesToEnvironment(ctx, "env-1")
require.NoError(t, err)
}
func TestEnvironmentService_SyncRegistriesToRemoteEnvironments_SkipsRemoteWithoutAccessToken(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestRegistry(t, db, "reg-1")
var syncCalls atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
syncCalls.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"success":true,"data":{"message":"ok"}}`))
}))
defer server.Close()
createTestEnvironment(t, db, "env-auth", server.URL, new("token-with-auth"))
createTestEnvironment(t, db, "env-no-token", "http://127.0.0.1:1", nil)
err := svc.SyncRegistriesToRemoteEnvironments(ctx)
require.NoError(t, err)
require.EqualValues(t, 1, syncCalls.Load())
}
func TestEnvironmentService_SyncRegistriesToRemoteEnvironments_ReportsFailuresButContinues(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestRegistry(t, db, "reg-1")
var successCalls atomic.Int32
successServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
successCalls.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"success":true,"data":{"message":"ok"}}`))
}))
defer successServer.Close()
createTestEnvironment(t, db, "env-success", successServer.URL, new("token-success"))
createTestEnvironment(t, db, "env-fail", "http://127.0.0.1:1", new("token-fail"))
err := svc.SyncRegistriesToRemoteEnvironments(ctx)
require.Error(t, err)
require.Contains(t, err.Error(), "failed to sync registries to 1 remote environment")
require.EqualValues(t, 1, successCalls.Load())
}
func TestEnvironmentService_ReconcileEdgeStatusesOnStartup(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestEnvironmentWithState(t, db, "edge-online", "edge://online", string(EnvironmentStatusOnline), true, nil)
createTestEnvironmentWithState(t, db, "edge-error", "edge://error", string(EnvironmentStatusError), true, nil)
createTestEnvironmentWithState(t, db, "edge-pending", "edge://pending", string(EnvironmentStatusPending), true, nil)
createTestEnvironmentWithState(t, db, "remote-http", "http://remote.example", string(EnvironmentStatusOnline), false, nil)
err := svc.ReconcileEdgeStatusesOnStartup(ctx)
require.NoError(t, err)
var edgeOnline Environment
require.NoError(t, db.WithContext(ctx).Where("id = ?", "edge-online").First(&edgeOnline).Error)
require.Equal(t, string(EnvironmentStatusOffline), edgeOnline.Status)
var edgeError Environment
require.NoError(t, db.WithContext(ctx).Where("id = ?", "edge-error").First(&edgeError).Error)
require.Equal(t, string(EnvironmentStatusOffline), edgeError.Status)
var edgePending Environment
require.NoError(t, db.WithContext(ctx).Where("id = ?", "edge-pending").First(&edgePending).Error)
require.Equal(t, string(EnvironmentStatusPending), edgePending.Status)
var remoteHTTP Environment
require.NoError(t, db.WithContext(ctx).Where("id = ?", "remote-http").First(&remoteHTTP).Error)
require.Equal(t, string(EnvironmentStatusOnline), remoteHTTP.Status)
}
func TestEnvironmentService_UpdateEnvironmentConnectionState(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestEnvironmentWithState(t, db, "edge-runtime", "edge://runtime", string(EnvironmentStatusOffline), true, nil)
err := svc.UpdateEnvironmentConnectionState(ctx, "edge-runtime", true)
require.NoError(t, err)
var env Environment
require.NoError(t, db.WithContext(ctx).Where("id = ?", "edge-runtime").First(&env).Error)
require.Equal(t, string(EnvironmentStatusOnline), env.Status)
require.NotNil(t, env.LastSeen)
lastSeen := env.LastSeen
err = svc.UpdateEnvironmentConnectionState(ctx, "edge-runtime", false)
require.NoError(t, err)
require.NoError(t, db.WithContext(ctx).Where("id = ?", "edge-runtime").First(&env).Error)
require.Equal(t, string(EnvironmentStatusOffline), env.Status)
require.NotNil(t, env.LastSeen)
require.Equal(t, *lastSeen, *env.LastSeen)
}
func TestEnvironmentService_UpdateEnvironmentStatus_PromotesPendingDirectEnv(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestEnvironmentWithState(t, db, "direct-pending", "http://agent:3553", string(EnvironmentStatusPending), false, nil)
require.NoError(t, svc.updateEnvironmentStatus(ctx, "direct-pending", string(EnvironmentStatusOnline)))
var env Environment
require.NoError(t, db.WithContext(ctx).Where("id = ?", "direct-pending").First(&env).Error)
require.Equal(t, string(EnvironmentStatusOnline), env.Status)
require.NotNil(t, env.LastSeen)
}
func TestEnvironmentService_UpdateEnvironmentStatus_DoesNotDemotePendingDirectEnvOnFailedTick(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestEnvironmentWithState(t, db, "direct-pending", "http://agent:3553", string(EnvironmentStatusPending), false, nil)
// A transient failure before pairing must leave a pending direct env pending.
require.NoError(t, svc.updateEnvironmentStatus(ctx, "direct-pending", string(EnvironmentStatusOffline)))
require.NoError(t, svc.updateEnvironmentStatus(ctx, "direct-pending", string(EnvironmentStatusError)))
var env Environment
require.NoError(t, db.WithContext(ctx).Where("id = ?", "direct-pending").First(&env).Error)
require.Equal(t, string(EnvironmentStatusPending), env.Status)
require.Nil(t, env.LastSeen)
}
func TestEnvironmentService_UpdateEnvironmentStatus_LeavesPendingEdgeEnvAlone(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestEnvironmentWithState(t, db, "edge-pending", "edge://agent", string(EnvironmentStatusPending), true, nil)
// Edge envs in pending must complete pairing via the agent's outbound tunnel;
// a manager-side reachability tick must NOT promote them.
require.NoError(t, svc.updateEnvironmentStatus(ctx, "edge-pending", string(EnvironmentStatusOnline)))
var env Environment
require.NoError(t, db.WithContext(ctx).Where("id = ?", "edge-pending").First(&env).Error)
require.Equal(t, string(EnvironmentStatusPending), env.Status)
require.Nil(t, env.LastSeen)
}
func TestEnvironmentService_ResolveEdgeEnvironmentByToken_CachesAndInvalidatesOnUpdate(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
oldToken := "edge-token-old"
newToken := "edge-token-new"
createTestEnvironmentWithState(t, db, "edge-auth", "edge://auth", string(EnvironmentStatusPending), true, &oldToken)
envID, err := svc.ResolveEdgeEnvironmentByToken(ctx, oldToken)
require.NoError(t, err)
require.Equal(t, "edge-auth", envID)
_, err = svc.UpdateEnvironment(ctx, "edge-auth", map[string]any{"access_token": newToken}, nil, nil)
require.NoError(t, err)
_, err = svc.ResolveEdgeEnvironmentByToken(ctx, oldToken)
require.Error(t, err)
require.Contains(t, err.Error(), "invalid agent token")
envID, err = svc.ResolveEdgeEnvironmentByToken(ctx, newToken)
require.NoError(t, err)
require.Equal(t, "edge-auth", envID)
_, err = svc.UpdateEnvironment(ctx, "edge-auth", map[string]any{"enabled": false}, nil, nil)
require.NoError(t, err)
_, err = svc.ResolveEdgeEnvironmentByToken(ctx, newToken)
require.Error(t, err)
require.NoError(t, svc.linkEnvironmentApiKey(ctx, "edge-auth", "key-rotated", "edge-token-rotated", "", "", "edge-auth"))
_, err = svc.ResolveEdgeEnvironmentByToken(ctx, "edge-token-rotated")
require.Error(t, err)
_, err = svc.UpdateEnvironment(ctx, "edge-auth", map[string]any{"enabled": true}, nil, nil)
require.NoError(t, err)
envID, err = svc.ResolveEdgeEnvironmentByToken(ctx, "edge-token-rotated")
require.NoError(t, err)
require.Equal(t, "edge-auth", envID)
require.NoError(t, db.WithContext(ctx).Model(&Environment{}).Where("id = ?", "edge-auth").Update("enabled", false).Error)
svc.invalidateEnvironmentCache("edge-auth")
_, err = svc.ResolveEdgeEnvironmentByToken(ctx, "edge-token-rotated")
require.Error(t, err)
require.NoError(t, svc.DeleteEnvironment(ctx, "edge-auth", nil, nil))
_, err = svc.ResolveEdgeEnvironmentByToken(ctx, "edge-token-rotated")
require.Error(t, err)
require.Contains(t, err.Error(), "invalid agent token")
}
func TestEnvironmentService_UpdateEnvironment_ClearingAccessTokenInvalidatesCache(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
oldToken := "edge-token-clear"
createTestEnvironmentWithState(t, db, "edge-auth-clear", "edge://auth-clear", string(EnvironmentStatusPending), true, &oldToken)
envID, err := svc.ResolveEdgeEnvironmentByToken(ctx, oldToken)
require.NoError(t, err)
require.Equal(t, "edge-auth-clear", envID)
_, err = svc.UpdateEnvironment(ctx, "edge-auth-clear", map[string]any{"access_token": nil}, nil, nil)
require.NoError(t, err)
_, tokenStillCached := svc.edgeTokens.byToken.Peek(oldToken)
svc.edgeTokens.mu.RLock()
_, reverseIndexStillCached := svc.edgeTokens.byEnvID["edge-auth-clear"]
svc.edgeTokens.mu.RUnlock()
require.False(t, tokenStillCached)
require.False(t, reverseIndexStillCached)
_, err = svc.ResolveEdgeEnvironmentByToken(ctx, oldToken)
require.Error(t, err)
require.Contains(t, err.Error(), "invalid agent token")
}
func TestEnvironmentServiceUpdateEnvironmentRejectsTargetChangeWithStoredToken(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
oldToken := "stored-agent-token"
createTestEnvironment(t, db, "env-target", "http://agent.example:3553", &oldToken)
updates := map[string]any{"api_url": "http://attacker.example:3553"}
_, err := svc.UpdateEnvironment(ctx, "env-target", updates, nil, nil)
require.ErrorIs(t, err, common.ErrValidation)
require.NotContains(t, updates, "updated_at")
var stored Environment
require.NoError(t, db.WithContext(ctx).First(&stored, "id = ?", "env-target").Error)
require.Equal(t, "http://agent.example:3553", stored.ApiUrl)
require.Equal(t, oldToken, *stored.AccessToken)
}
func TestEnvironmentServiceUpdateEnvironmentAllowsTargetChangeWithExplicitToken(t *testing.T) {
for _, tc := range []struct {
name string
token string
}{
{name: "reenter existing token", token: "stored-agent-token"},
{name: "use replacement token", token: "replacement-agent-token"},
} {
t.Run(tc.name, func(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
oldToken := "stored-agent-token"
createTestEnvironment(t, db, "env-target", "http://agent.example:3553", &oldToken)
updated, err := svc.UpdateEnvironment(ctx, "env-target", map[string]any{
"api_url": "http://replacement.example:3553",
"access_token": tc.token,
}, nil, nil)
require.NoError(t, err)
require.Equal(t, "http://replacement.example:3553", updated.ApiUrl)
require.Equal(t, tc.token, *updated.AccessToken)
var stored Environment
require.NoError(t, db.WithContext(ctx).First(&stored, "id = ?", "env-target").Error)
require.Equal(t, updated.ApiUrl, stored.ApiUrl)
require.Equal(t, tc.token, *stored.AccessToken)
})
}
}
func TestEnvironmentService_getCachedEnvironmentIDForToken_ExpiresAndCleansReverseIndex(t *testing.T) {
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
svc.edgeTokens.mu.Lock()
svc.edgeTokens.byEnvID["env-expired"] = "expired-token"
svc.edgeTokens.byToken.SetWithTTL("expired-token", "env-expired", time.Nanosecond)
time.Sleep(time.Millisecond)
svc.edgeTokens.mu.Unlock()
envID, err := svc.ResolveEdgeEnvironmentByToken(t.Context(), "expired-token")
require.ErrorContains(t, err, "invalid agent token")
require.Empty(t, envID)
_, tokenStillCached := svc.edgeTokens.byToken.Peek("expired-token")
svc.edgeTokens.mu.RLock()
_, reverseIndexStillCached := svc.edgeTokens.byEnvID["env-expired"]
svc.edgeTokens.mu.RUnlock()
require.False(t, tokenStillCached)
require.False(t, reverseIndexStillCached)
}
func TestEnvironmentService_ResolveEnvironmentByAccessToken(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
accessToken := "remote-token"
createNamedTestEnvironment(t, db, "env-remote", "Remote Alpha", "http://remote.example", &accessToken)
env, err := svc.ResolveEnvironmentByAccessToken(ctx, accessToken)
require.NoError(t, err)
require.NotNil(t, env)
require.Equal(t, "env-remote", env.ID)
require.Equal(t, "Remote Alpha", env.Name)
_, err = svc.ResolveEnvironmentByAccessToken(ctx, "missing-token")
require.Error(t, err)
require.ErrorIs(t, err, ErrInvalidEnvironmentAccessToken)
}
func TestEnvironmentService_GenerateDeploymentSnippets_TransportDefaults(t *testing.T) {
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
standard, err := svc.GenerateDeploymentSnippets(t.Context(), "env-1", "https://manager.example.com", "https://agent.example.com", "token-123")
require.NoError(t, err)
require.NotNil(t, standard)
// Direct agents never run the edge tunnel, so their snippets carry no transport setting.
require.NotContains(t, standard.DockerRun, "EDGE_TRANSPORT")
require.NotContains(t, standard.DockerCompose, "EDGE_TRANSPORT")
require.Contains(t, standard.DockerRun, "AGENT_TOKEN=token-123")
require.Contains(t, standard.DockerRun, "-v arcane-data:/app/data")
require.Contains(t, standard.DockerCompose, "- arcane-data:/app/data")
require.NotContains(t, standard.DockerRun, "-v arcane-data:/data")
edgeSnippets, err := svc.GenerateEdgeDeploymentSnippets(t.Context(), "env-2", "https://manager.example.com", "token-456", nil)
require.NoError(t, err)
require.NotNil(t, edgeSnippets)
require.Contains(t, edgeSnippets.DockerRun, "EDGE_TRANSPORT=auto")
require.Contains(t, edgeSnippets.DockerCompose, "EDGE_TRANSPORT=auto")
require.Contains(t, edgeSnippets.DockerRun, "AGENT_TOKEN=token-456")
require.Contains(t, edgeSnippets.DockerRun, "-v arcane-data:/app/data")
require.Contains(t, edgeSnippets.DockerCompose, "- arcane-data:/app/data")
require.NotContains(t, edgeSnippets.DockerRun, "-v arcane-data:/data")
}
func TestEnvironmentService_GenerateDeploymentSnippets_PublishesAgentURLPort(t *testing.T) {
t.Parallel()
tests := []struct {
name string
agentURL string
portMapping string
}{
{name: "default port", agentURL: "http://agent.example.com:3553", portMapping: "3553:3553"},
{name: "custom port", agentURL: "http://agent.example.com:1234", portMapping: "1234:3553"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
svc := NewEnvironmentService(nil, nil, nil, nil, nil, nil)
deploymentSnippets, err := svc.GenerateDeploymentSnippets(t.Context(), "env-1", "https://manager.example.com", tt.agentURL, "token-123")
require.NoError(t, err)
require.NotNil(t, deploymentSnippets)
require.Contains(t, deploymentSnippets.DockerRun, " -p "+tt.portMapping+" \\")
require.Contains(t, deploymentSnippets.DockerCompose, fmt.Sprintf(" ports:\n - %q\n", tt.portMapping))
require.Contains(t, deploymentSnippets.DockerRun, "MANAGER_API_URL=https://manager.example.com")
require.Contains(t, deploymentSnippets.DockerCompose, "MANAGER_API_URL=https://manager.example.com")
if tt.portMapping != "3553:3553" {
require.NotContains(t, deploymentSnippets.DockerRun, "-p 3553:3553")
require.NotContains(t, deploymentSnippets.DockerCompose, "3553:3553")
}
})
}
}
func TestAgentHostPort(t *testing.T) {
t.Parallel()
tests := []struct {
name string
url string
want string
}{
{name: "explicit custom port", url: "http://agent.example.com:1234", want: "1234"},
{name: "default agent port", url: "http://agent.example.com:3553", want: "3553"},
{name: "http without port uses 80", url: "http://agent.example.com", want: "80"},
{name: "https without port uses 443", url: "https://agent.example.com", want: "443"},
{name: "ipv6 with port", url: "http://[2001:db8::1]:9999", want: "9999"},
{name: "empty falls back to container port", url: "", want: "3553"},
{name: "invalid falls back to container port", url: "not a url", want: "3553"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
require.Equal(t, tt.want, snippets.AgentHostPort(tt.url))
})
}
}
func TestEnvironmentService_EnsureSwarmNodeAgentEnvironment_CreatesVisibleEnvironmentAndReusesToken(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
userService := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
apiKeyService := apikey.NewApiKeyService(db, userService, nil)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, apiKeyService)
localUser := createTestEnvironmentServiceUser(t, ctx, userService, "swarm-admin")
createdEnv, createdToken, err := svc.EnsureSwarmNodeAgentEnvironment(
ctx,
"manager-env",
"node-1234567890abcdef",
"worker-1",
localUser.ID,
localUser.Username,
false,
)
require.NoError(t, err)
require.NotNil(t, createdEnv)
require.NotEmpty(t, createdToken)
require.Equal(t, "worker-1", createdEnv.Name)
require.Equal(t, "edge://swarm-node-node-1234567", createdEnv.ApiUrl)
require.False(t, createdEnv.Hidden)
require.True(t, createdEnv.IsEdge)
require.True(t, createdEnv.Enabled)
require.Equal(t, string(EnvironmentStatusPending), createdEnv.Status)
require.NotNil(t, createdEnv.ParentEnvironmentID)
require.Equal(t, "manager-env", *createdEnv.ParentEnvironmentID)
require.NotNil(t, createdEnv.SwarmNodeID)
require.Equal(t, "node-1234567890abcdef", *createdEnv.SwarmNodeID)
require.NotNil(t, createdEnv.AccessToken)
require.Equal(t, createdToken, *createdEnv.AccessToken)
require.NotNil(t, createdEnv.ApiKeyID)
var childEnvironments []Environment
require.NoError(t, db.WithContext(ctx).
Where("parent_environment_id = ?", "manager-env").
Where("swarm_node_id = ?", "node-1234567890abcdef").
Find(&childEnvironments).Error)
require.Len(t, childEnvironments, 1)
var apiKeys []apikey.ApiKey
require.NoError(t, db.WithContext(ctx).
Where("environment_id = ?", createdEnv.ID).
Order("created_at asc").
Find(&apiKeys).Error)
require.Len(t, apiKeys, 1)
require.Nil(t, apiKeys[0].UserID) // environment bootstrap keys have no owner
reusedEnv, reusedToken, err := svc.EnsureSwarmNodeAgentEnvironment(
ctx,
"manager-env",
"node-1234567890abcdef",
"worker-1",
localUser.ID,
localUser.Username,
false,
)
require.NoError(t, err)
require.NotNil(t, reusedEnv)
require.Equal(t, createdEnv.ID, reusedEnv.ID)
require.Equal(t, createdToken, reusedToken)
require.Equal(t, createdEnv.ApiKeyID, reusedEnv.ApiKeyID)
var apiKeysAfterReuse []apikey.ApiKey
require.NoError(t, db.WithContext(ctx).
Where("environment_id = ?", createdEnv.ID).
Order("created_at asc").
Find(&apiKeysAfterReuse).Error)
require.Len(t, apiKeysAfterReuse, 1)
}
func TestEnvironmentService_EnsureSwarmNodeAgentEnvironment_ReusesLegacyHiddenRegistration(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
parentEnvironmentID := "manager-env"
nodeID := "legacy-node"
token := "legacy-agent-token"
legacy := &Environment{
ID: "legacy-agent",
Name: "Legacy node agent",
ApiUrl: "edge://legacy-node",
Status: string(EnvironmentStatusOffline),
Enabled: true,
IsEdge: true,
Hidden: true,
AccessToken: &token,
ParentEnvironmentID: &parentEnvironmentID,
SwarmNodeID: &nodeID,
}
{
err := db.WithContext(ctx).Create(legacy).Error
require.NoError(t, err,
"create legacy environment: %v", err)
}
reused, reusedToken, err := svc.EnsureSwarmNodeAgentEnvironment(
ctx,
parentEnvironmentID,
nodeID,
"legacy-host",
"user-id",
"username",
false,
)
require.NoError(t, err,
"EnsureSwarmNodeAgentEnvironment() error = %v", err)
require.Equal(t, legacy.ID, reused.ID,
"environment ID = %q, want %q", reused.ID, legacy.ID)
require.True(t, reused.Hidden,
"legacy environment was unexpectedly converted to visible")
require.Equal(t, token, reusedToken,
"token = %q, want existing token", reusedToken)
var environments []Environment
{
operationErr := db.WithContext(ctx).
Where("parent_environment_id = ? AND swarm_node_id = ?", parentEnvironmentID, nodeID).
Find(&environments).Error
require.NoError(t, operationErr,
"list node environments: %v", operationErr)
}
require.Len(t, environments, 1,
"environment count = %d, want 1", len(environments))
}
// The provisioned agent token must resolve back to its environment, and rotation
// must retire the old token, with no transformation between issue and validation.
func TestEnvironmentService_EnsureSwarmNodeAgentEnvironment_TokenResolvesEndToEnd(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
userService := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
apiKeyService := apikey.NewApiKeyService(db, userService, nil)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, apiKeyService)
localUser := createTestEnvironmentServiceUser(t, ctx, userService, "swarm-resolve-admin")
createdEnv, createdToken, err := svc.EnsureSwarmNodeAgentEnvironment(
ctx,
"manager-env-resolve",
"node-resolve-1234567890",
"resolve-host",
localUser.ID,
localUser.Username,
false,
)
require.NoError(t, err)
require.NotEmpty(t, createdToken)
resolvedID, err := svc.ResolveEdgeEnvironmentByToken(ctx, createdToken)
require.NoError(t, err)
require.Equal(t, createdEnv.ID, resolvedID)
// Whitespace normalization on the wire (e.g. a proxy adding a trailing
// newline) must still resolve.
resolvedID, err = svc.ResolveEdgeEnvironmentByToken(ctx, " "+createdToken+"\n")
require.NoError(t, err)
require.Equal(t, createdEnv.ID, resolvedID)
// Rotate the token: the new token must resolve and the old token must not.
rotatedEnv, rotatedToken, err := svc.EnsureSwarmNodeAgentEnvironment(
ctx,
"manager-env-resolve",
"node-resolve-1234567890",
"resolve-host",
localUser.ID,
localUser.Username,
true,
)
require.NoError(t, err)
require.Equal(t, createdEnv.ID, rotatedEnv.ID)
require.NotEqual(t, createdToken, rotatedToken)
resolvedID, err = svc.ResolveEdgeEnvironmentByToken(ctx, rotatedToken)
require.NoError(t, err)
require.Equal(t, createdEnv.ID, resolvedID)
_, err = svc.ResolveEdgeEnvironmentByToken(ctx, createdToken)
require.Error(t, err)
require.Contains(t, err.Error(), "invalid agent token")
}
func TestEnvironmentService_BindSwarmNodeEnvironment_PreservesVisibleEnvironmentToken(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
token := "existing-agent-token"
createTestEnvironment(t, db, "visible-env", "http://visible.example", &token)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
bound, err := svc.BindSwarmNodeEnvironment(ctx, "manager-env", "node-1", "visible-env", false)
require.NoError(t, err)
require.False(t, bound.Hidden)
require.Equal(t, "manager-env", *bound.ParentEnvironmentID)
require.Equal(t, "node-1", *bound.SwarmNodeID)
require.Equal(t, token, *bound.AccessToken)
require.NoError(t, svc.DetachSwarmNodeEnvironment(ctx, "manager-env", "node-1"))
detached, err := svc.GetEnvironmentByID(ctx, "visible-env")
require.NoError(t, err)
require.Nil(t, detached.ParentEnvironmentID)
require.Nil(t, detached.SwarmNodeID)
require.Equal(t, token, *detached.AccessToken)
}
func TestEnvironmentService_BindSwarmNodeEnvironment_RequiresExplicitRebind(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
createTestEnvironment(t, db, "visible-env", "http://visible.example", nil)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
_, err := svc.BindSwarmNodeEnvironment(ctx, "manager-a", "node-a", "visible-env", false)
require.NoError(t, err)
_, err = svc.BindSwarmNodeEnvironment(ctx, "manager-b", "node-b", "visible-env", false)
require.ErrorContains(t, err, "explicit rebinding is required")
rebound, err := svc.BindSwarmNodeEnvironment(ctx, "manager-b", "node-b", "visible-env", true)
require.NoError(t, err)
require.Equal(t, "manager-b", *rebound.ParentEnvironmentID)
require.Equal(t, "node-b", *rebound.SwarmNodeID)
}
func TestEnvironmentService_ListMethods_ExcludeHiddenEnvironments(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestEnvironment(t, db, "0", "http://localhost:3552", nil)
createNamedTestEnvironment(t, db, "env-visible", "Visible Remote", "http://visible.example", new("visible-token"))
createNamedTestEnvironment(t, db, "env-hidden", "Hidden Node Agent", "edge://swarm-node-hidden", new("hidden-token"))
require.NoError(t, db.WithContext(ctx).
Model(&Environment{}).
Where("id = ?", "env-hidden").
Updates(map[string]any{
"hidden": true,
"is_edge": true,
"parent_environment_id": "0",
"swarm_node_id": "node-hidden",
}).Error)
listedEnvironments, _, err := svc.ListEnvironmentsPaginated(ctx, pagination.QueryParams{
Start: 0, Limit: 20,
Filters: map[string]string{},
}, nil)
require.NoError(t, err)
require.Len(t, listedEnvironments, 2)
for _, env := range listedEnvironments {
require.NotEqual(t, "env-hidden", env.ID)
}
remoteEnvironments, err := svc.ListRemoteEnvironments(ctx)
require.NoError(t, err)
require.Len(t, remoteEnvironments, 1)
require.Equal(t, "env-visible", remoteEnvironments[0].ID)
}
func TestEnvironmentService_ListEnvironmentsPaginated_FiltersByAccessibleEnvIDs(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestEnvironment(t, db, "0", "http://localhost:3552", nil)
createNamedTestEnvironment(t, db, "env-a", "Env A", "http://a.example", new("token-a"))
createNamedTestEnvironment(t, db, "env-b", "Env B", "http://b.example", new("token-b"))
newParams := func(typeFilter string) pagination.QueryParams {
filters := map[string]string{}
filters["type"] = cmp.Or(typeFilter, filters["type"])
return pagination.QueryParams{
Start: 0, Limit: 20,
Filters: filters,
}
}
// nil = no restriction: every non-hidden environment is returned.
all, _, err := svc.ListEnvironmentsPaginated(ctx, newParams(""), nil)
require.NoError(t, err)
require.ElementsMatch(t, []string{"0", "env-a", "env-b"}, environmentIDs(all))
// A non-nil allow-list restricts the result on the DB path.
scoped, _, err := svc.ListEnvironmentsPaginated(ctx, newParams(""), []string{"env-a"})
require.NoError(t, err)
require.ElementsMatch(t, []string{"env-a"}, environmentIDs(scoped))
// The runtime-filter path (type filter) honors the allow-list too.
scopedTyped, _, err := svc.ListEnvironmentsPaginated(ctx, newParams("http"), []string{"env-a"})
require.NoError(t, err)
require.ElementsMatch(t, []string{"env-a"}, environmentIDs(scopedTyped))
// An empty (non-nil) allow-list yields no environments on either path.
none, _, err := svc.ListEnvironmentsPaginated(ctx, newParams(""), []string{})
require.NoError(t, err)
require.Empty(t, none)
noneTyped, _, err := svc.ListEnvironmentsPaginated(ctx, newParams("http"), []string{})
require.NoError(t, err)
require.Empty(t, noneTyped)
}
func TestEnvironmentService_ListEnvironmentsPaginated_FiltersByRuntimeType(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
now := time.Now()
envs := []Environment{
{
ID: "0", CreatedAt: now, UpdatedAt: &now,
Name: "Local",
ApiUrl: "http://localhost:3552",
Status: string(EnvironmentStatusOnline),
Enabled: true,
},
{
ID: "env-edge", CreatedAt: now, UpdatedAt: &now,
Name: "Edge",
ApiUrl: "edge://agent",
Status: string(EnvironmentStatusOffline),
Enabled: true,
IsEdge: true,
},
{
ID: "env-grpc", CreatedAt: now, UpdatedAt: &now,
Name: "gRPC",
ApiUrl: "edge://grpc",
Status: string(EnvironmentStatusOffline),
Enabled: true,
IsEdge: true,
},
{
ID: "env-websocket", CreatedAt: now, UpdatedAt: &now,
Name: "WebSocket",
ApiUrl: "edge://websocket",
Status: string(EnvironmentStatusOffline),
Enabled: true,
IsEdge: true,
},
{
ID: "env-polling", CreatedAt: now, UpdatedAt: &now,
Name: "Polling",
ApiUrl: "edge://polling",
Status: string(EnvironmentStatusOffline),
Enabled: true,
IsEdge: true,
},
{
ID: "env-last-ws", CreatedAt: now, UpdatedAt: &now,
Name: "LastWebsocket",
ApiUrl: "edge://last-ws",
Status: string(EnvironmentStatusOffline),
Enabled: true,
IsEdge: true,
LastEdgeTransport: new("websocket"),
},
}
require.NoError(t, db.WithContext(ctx).Create(&envs).Error)
edge.GetRegistry().Unregister("env-grpc")
edge.GetRegistry().Unregister("env-websocket")
edge.GetRegistry().Unregister("env-polling")
t.Cleanup(func() {
edge.GetRegistry().Unregister("env-grpc")
edge.GetRegistry().Unregister("env-websocket")
edge.GetRegistry().Unregister("env-polling")
})
grpcTunnel := edge.NewAgentTunnelWithConn("env-grpc", edge.NewGRPCManagerTunnelConn(nil))
edge.GetRegistry().Register("env-grpc", grpcTunnel)
websocketTunnel, closeWebSocketTunnel := newTestWebSocketTunnel(t, "env-websocket")
defer closeWebSocketTunnel()
edge.GetRegistry().Register("env-websocket", websocketTunnel)
edge.GetPollRuntimeRegistry().Update("env-polling", edge.DefaultTunnelPollInterval, time.Now())
tests := []struct {
name string
typeFilter string
wantIDs []string
}{
{name: "http", typeFilter: "http", wantIDs: []string{"0"}},
// Poll-only edge environments (no tunnel transport) classify as plain edge.
{name: "edge", typeFilter: "edge", wantIDs: []string{"env-edge", "env-polling"}},
{name: "grpc", typeFilter: "grpc", wantIDs: []string{"env-grpc"}},
// Disconnected agents classify by the transport they last used.
{name: "websocket", typeFilter: "websocket", wantIDs: []string{"env-websocket", "env-last-ws"}},
{name: "multiple", typeFilter: "http,grpc", wantIDs: []string{"0", "env-grpc"}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
listedEnvironments, _, err := svc.ListEnvironmentsPaginated(ctx, pagination.QueryParams{
Start: 0, Limit: 20,
Filters: map[string]string{"type": tt.typeFilter},
}, nil)
require.NoError(t, err)
require.ElementsMatch(t, tt.wantIDs, environmentIDs(listedEnvironments))
})
}
}
func environmentIDs(environments []environment.Environment) []string {
ids := make([]string, 0, len(environments))
for _, env := range environments {
ids = append(ids, env.ID)
}
return ids
}
func newTestWebSocketTunnel(t *testing.T, envID string) (*edge.AgentTunnel, func()) {
t.Helper()
connCh := make(chan *websocket.Conn, 1)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
conn, err := websocket.Accept(w, r, nil)
if !assert.NoError(t, err) {
return
}
connCh <- conn
}))
wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
clientConn, _, err := websocket.Dial(t.Context(), wsURL, nil)
require.NoError(t, err)
serverConn := <-connCh
return edge.NewAgentTunnelWithConn(envID, edge.NewTunnelConn(serverConn)), func() {
_ = clientConn.CloseNow()
server.Close()
}
}
func TestEnvironmentService_GenerateEdgeDeploymentSnippets_WithAutoGeneratedMTLS(t *testing.T) {
crypto.InitEncryption(&crypto.Config{
EncryptionKey: "test-encryption-key-for-testing-32bytes-min",
Environment: "test",
})
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
assetsDir := filepath.Join(t.TempDir(), "edge-mtls")
deploymentSnippets, err := svc.GenerateEdgeDeploymentSnippets(t.Context(), "env-mtls", "https://manager.example.com", "token-789", &edge.Config{
EdgeMTLSMode: edge.EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: assetsDir,
})
require.NoError(t, err)
require.NotNil(t, deploymentSnippets)
require.NotNil(t, deploymentSnippets.MTLS)
require.Contains(t, deploymentSnippets.MTLS.DockerRun, "EDGE_MTLS_MODE=required")
require.Contains(t, deploymentSnippets.MTLS.DockerRun, "EDGE_MTLS_ASSETS_DIR=/app/data/edge-mtls-agent")
require.NotContains(t, deploymentSnippets.MTLS.DockerRun, "EDGE_MTLS_CA_FILE")
require.NotContains(t, deploymentSnippets.MTLS.DockerRun, "EDGE_MTLS_CERT_FILE")
require.NotContains(t, deploymentSnippets.MTLS.DockerRun, "EDGE_MTLS_KEY_FILE")
require.NotContains(t, deploymentSnippets.MTLS.DockerRun, "./arcane-edge-certs:/app/data/edge-mtls-agent:ro")
require.Contains(t, deploymentSnippets.MTLS.DockerCompose, "EDGE_MTLS_ASSETS_DIR=/app/data/edge-mtls-agent")
require.NotContains(t, deploymentSnippets.MTLS.DockerCompose, "EDGE_MTLS_CA_FILE")
require.NotContains(t, deploymentSnippets.MTLS.DockerCompose, "EDGE_MTLS_CERT_FILE")
require.NotContains(t, deploymentSnippets.MTLS.DockerCompose, "EDGE_MTLS_KEY_FILE")
require.NotContains(t, deploymentSnippets.MTLS.DockerCompose, "./arcane-edge-certs:/app/data/edge-mtls-agent:ro")
require.Equal(t, "./arcane-edge-certs", deploymentSnippets.MTLS.HostDirHint)
require.Len(t, deploymentSnippets.MTLS.Files, 3)
require.Equal(t, "ca.crt", deploymentSnippets.MTLS.Files[0].Name)
require.Equal(t, "/app/data/edge-mtls-agent/ca.crt", deploymentSnippets.MTLS.Files[0].ContainerPath)
require.Contains(t, deploymentSnippets.MTLS.Files[0].Content, "BEGIN CERTIFICATE")
require.Equal(t, "agent.key", deploymentSnippets.MTLS.Files[2].Name)
require.Equal(t, "/app/data/edge-mtls-agent/agent.key", deploymentSnippets.MTLS.Files[2].ContainerPath)
require.Contains(t, deploymentSnippets.MTLS.Files[2].Content, "BEGIN PRIVATE KEY")
}
func TestEnvironmentService_GenerateEdgeDeploymentSnippets_ReturnsBasicSnippetsWhenMTLSGenerationFails(t *testing.T) {
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
assetsPath := filepath.Join(t.TempDir(), "edge-mtls-file")
require.NoError(t, os.WriteFile(assetsPath, []byte("not a directory"), 0o600))
deploymentSnippets, err := svc.GenerateEdgeDeploymentSnippets(t.Context(), "env-mtls", "https://manager.example.com", "token-789", &edge.Config{
EdgeMTLSMode: edge.EdgeMTLSModeRequired,
EdgeMTLSAssetsDir: assetsPath,
})
require.NoError(t, err)
require.NotNil(t, deploymentSnippets)
require.Nil(t, deploymentSnippets.MTLS)
require.Contains(t, deploymentSnippets.DockerRun, "EDGE_TRANSPORT=auto")
require.Contains(t, deploymentSnippets.DockerCompose, "MANAGER_API_URL=https://manager.example.com")
}
func TestEnvironmentService_TestConnection_RejectsInvalidCustomURL(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestEnvironment(t, db, "env-1", "http://example.com", nil)
status, err := svc.TestConnection(ctx, "env-1", new("ftp://example.com"))
require.Error(t, err)
require.Equal(t, "error", status)
require.EqualError(t, err, "Environment connection test failed")
}
func TestEnvironmentServiceTestConnectionHidesCustomURLFailure(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusTeapot)
}))
t.Cleanup(server.Close)
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, server.Client(), nil, event.NewEventService(db, nil, nil), nil, nil)
createTestEnvironment(t, db, "env-1", "http://stored.example", nil)
status, err := svc.TestConnection(ctx, "env-1", new(server.URL))
require.Equal(t, "error", status)
require.EqualError(t, err, "Environment connection test failed")
require.NotContains(t, err.Error(), "418")
}
func TestEnvironmentServiceTestConnectionAllowsStoredPrivateURL(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusOK)
}))
t.Cleanup(server.Close)
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, server.Client(), nil, event.NewEventService(db, nil, nil), nil, nil)
createTestEnvironment(t, db, "env-private", server.URL, nil)
status, err := svc.TestConnection(ctx, "env-private", nil)
require.NoError(t, err)
require.Equal(t, "online", status)
}
func TestEnvironmentService_ExecuteRemoteRequest_RejectsInvalidEnvironmentURL(t *testing.T) {
ctx := t.Context()
db := setupEnvironmentServiceTestDB(t)
svc := NewEnvironmentService(db, http.DefaultClient, nil, event.NewEventService(db, nil, nil), nil, nil)
createTestEnvironment(t, db, "env-invalid-url", "http://user:[email protected]", nil)
_, err := svc.ExecuteRemoteRequest(ctx, "env-invalid-url", http.MethodGet, "/api/health", nil)
require.Error(t, err)
require.Contains(t, err.Error(), "invalid environment API URL")
}
func (s *environmentTestScheduler) Submit(_ context.Context, request scheduler.Request) (scheduler.Run, error) {
s.submitted = append(s.submitted, request)
return scheduler.Run{
ID: request.RunID,
JobID: request.JobID,
EnvironmentID: request.EnvironmentID,
Status: scheduler.Queued,
}, nil
}
func setupSyncDB(t *testing.T) *database.DB {
t.Helper()
db, err := gorm.Open(sqlite.Open(filepath.Join(t.TempDir(), "sync.db")), &gorm.Config{})
require.NoError(t, err)
require.NoError(
t,
db.AutoMigrate(
&Environment{},
®istry.ContainerRegistry{},
&gitrepo.GitRepository{},
&s3.S3Destination{},
),
)
sqlDB, err := db.DB()
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, sqlDB.Close()) })
crypto.InitEncryption(&crypto.Config{EncryptionKey: "test-encryption-key-for-testing-32bytes-min", Environment: "test"})
return &database.DB{DB: db}
}
func TestSyncCredentialDecryptionAbortsSnapshot(t *testing.T) {
for _, kind := range []string{"registry token", "ECR secret", "repository token", "repository SSH key", "S3 secret"} {
t.Run(kind, func(t *testing.T) {
db := setupSyncDB(t)
var calls atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
calls.Add(1)
_, _ = w.Write([]byte(`{"success":true}`))
}))
defer server.Close()
require.NoError(t, db.Create(&Environment{
ID: "remote",
ApiUrl: server.URL,
AccessToken: new("agent-token"),
}).Error)
service := NewEnvironmentService(db, server.Client(), nil, event.NewEventService(db, nil, nil), nil, nil)
var syncResource func(context.Context, string) error
switch kind {
case "registry token", "ECR secret":
require.NoError(t, db.Create(®istry.ContainerRegistry{
ID: "bad-credential",
URL: "registry.example.com",
Token: "invalid-ciphertext",
RegistryType: kit.Ternary(kind == "ECR secret", registry.RegistryTypeECR, registry.RegistryTypeGeneric),
AWSSecretAccessKey: kit.Ternary(kind == "ECR secret", "invalid-ciphertext", ""),
}).Error)
syncResource = service.SyncRegistriesToEnvironment
case "repository token", "repository SSH key":
require.NoError(t, db.Create(&gitrepo.GitRepository{
ID: "bad-credential",
Name: "Repository",
URL: "https://example.com/repo.git",
Token: kit.Ternary(kind == "repository token", "invalid-ciphertext", ""),
SSHKey: kit.Ternary(kind == "repository token", "", "invalid-ciphertext"),
}).Error)
syncResource = service.SyncRepositoriesToEnvironment
case "S3 secret":
require.NoError(t, db.Create(&s3.S3Destination{
ID: "bad-credential",
Name: "Backup",
SecretAccessKey: "invalid-ciphertext",
}).Error)
syncResource = service.SyncS3DestinationsToEnvironment
}
err := syncResource(t.Context(), "remote")
require.Error(t, err)
require.Contains(t, err.Error(), "bad-credential")
require.Error(t, errors.Unwrap(err))
require.Zero(t, calls.Load(), "an incomplete snapshot must never reach the agent")
})
}
}
func TestSyncRepositoriesPreservesEmptyCredentials(t *testing.T) {
db := setupSyncDB(t)
require.NoError(t, db.Create(&gitrepo.GitRepository{
ID: "public-repo",
Name: "Public",
URL: "https://example.com/public.git",
AuthType: "none",
}).Error)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var payload gitops.RepositorySyncRequest
if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
t.Error(err)
w.WriteHeader(http.StatusBadRequest)
return
}
if rows := payload.Repositories; len(rows) != 1 || rows[0].ID != "public-repo" {
t.Errorf("missing public repository: %v", payload)
}
_, _ = w.Write([]byte(`{"success":true}`))
}))
defer server.Close()
require.NoError(t, db.Create(&Environment{
ID: "remote",
ApiUrl: server.URL,
AccessToken: new("token"),
}).Error)
service := NewEnvironmentService(db, server.Client(), nil, event.NewEventService(db, nil, nil), nil, nil)
require.NoError(t, service.SyncRepositoriesToEnvironment(t.Context(), "remote"))
}
func TestSyncSkipsUnchangedPayloadUntilForgotten(t *testing.T) {
db := setupSyncDB(t)
var calls atomic.Int32
var reject atomic.Bool
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
calls.Add(1)
if reject.Load() {
http.Error(w, "agent unavailable", http.StatusInternalServerError)
return
}
// A write failure only means the manager already gave up on this
// request, which the call-count assertions below would surface.
_, _ = w.Write([]byte(`{"success":true}`))
}))
defer server.Close()
token, err := crypto.Encrypt("secret")
require.NoError(t, err)
require.NoError(t, db.Create(®istry.ContainerRegistry{
ID: "ghcr",
URL: "ghcr.io",
Username: "user",
Token: token,
RegistryType: registry.RegistryTypeGeneric,
}).Error)
require.NoError(t, db.Create(&Environment{
ID: "remote",
ApiUrl: server.URL,
AccessToken: new("agent-token"),
}).Error)
service := NewEnvironmentService(db, server.Client(), nil, event.NewEventService(db, nil, nil), nil, nil)
localSync := func() error { return service.SyncRegistriesToEnvironment(t.Context(), "remote") }
changeRegistry := func(url string) {
require.NoError(t, db.Model(®istry.ContainerRegistry{}).Where("id = ?", "ghcr").Update("url", url).Error)
}
require.NoError(t, localSync())
require.NoError(t, localSync())
require.EqualValues(t, 1, calls.Load(), "an unchanged payload is not resent")
changeRegistry("ghcr.io/v2")
require.NoError(t, localSync())
require.EqualValues(t, 2, calls.Load(), "a changed payload is resent")
service.ForgetSyncState("remote")
require.NoError(t, localSync())
require.EqualValues(t, 3, calls.Load(), "forgetting forces a resend")
reject.Store(true)
changeRegistry("ghcr.io/v3")
require.Error(t, localSync())
require.EqualValues(t, 4, calls.Load())
reject.Store(false)
require.NoError(t, localSync())
require.EqualValues(t, 5, calls.Load(), "a rejected payload is retried")
require.NoError(t, localSync())
require.EqualValues(t, 5, calls.Load(), "an accepted payload is remembered")
}
// A watcher must see a change signal, and a burst must not block the notifier —
// it runs on the edge tunnel's connect/disconnect path.
func TestEnvironmentServiceRuntimeChangeSignalCoalesces(t *testing.T) {
s := NewEnvironmentService(nil, http.DefaultClient, nil, nil, nil, nil)
changes, unsubscribe := s.SubscribeRuntimeChanges()
defer unsubscribe()
// More notifications than the channel can hold: the extras are dropped
// rather than blocking, because a watcher re-derives live state on wake.
for range 5 {
s.NotifyRuntimeStateChanged()
}
select {
case <-changes:
default:
require.FailNow(t, "expected a pending runtime change signal")
}
select {
case <-changes:
require.FailNow(t, "expected coalesced signals, got a second wake-up")
default:
}
// Unsubscribing must stop delivery so a closed stream cannot leak.
unsubscribe()
s.NotifyRuntimeStateChanged()
select {
case <-changes:
require.FailNow(t, "expected no signal after unsubscribe")
default:
}
require.Empty(t, s.runtimeWatchers.chans)
}