PostgreSQL backup tool with Point-In-Time-Recovery and restore verification
TypeScript backupbackupsdatabasedatabase-backupdevopsdockergolangkubernetesmariadbmongodbmysqlpgpostgrespostgresqls3self-hostedsystem-administrationtoolsweb-ui
FIX (physical): Fix physical backups size calculation
Rostislav Duginaa01fe038c41
diff --git a/backend/internal/features/backups/backups/backuping/physical/backuper.go b/backend/internal/features/backups/backups/backuping/physical/backuper.goindex 8d63eb15..61678d41 100644--- a/backend/internal/features/backups/backups/backuping/physical/backuper.go+++ b/backend/internal/features/backups/backups/backuping/physical/backuper.go@@ -95,6 +95,8 @@ func (b *PhysicalBackuper) runFullBackup(b.taskCancelManager.RegisterTask(fullBackup.ID, cancel)defer b.taskCancelManager.UnregisterTask(fullBackup.ID)+ rawSizeMb := b.getSourceClusterSizeMb(ctx, logger, backupCtx.Database)+fullBackupSpec := postgresql_executor.FullBackupSpec{CommonBackupSpec: postgresql_executor.CommonBackupSpec{SourceDB: backupCtx.Database.PostgresqlPhysical,@@ -132,7 +134,7 @@ func (b *PhysicalBackuper) runFullBackup("message", backupResult.ErrorMessage)}- if err := b.persistFullResult(fullBackup, backupResult); err != nil {+ if err := b.persistFullResult(fullBackup, backupResult, rawSizeMb); err != nil {logger.Error("failed to persist full result", "error", err)return@@ -318,9 +320,36 @@ func (b *PhysicalBackuper) resolveParentManifest(}, nil}+// The size only feeds telemetry, and a cluster whose pg_hba.conf grants "host replication" but not+// "host all" backs up fine while refusing this probe, so it must never fail a backup. It runs+// before the executor and the connection string carries no connect_timeout, so it also gets its+// own deadline — a stalled source must not hold up the backup it is measuring.+func (b *PhysicalBackuper) getSourceClusterSizeMb(+ ctx context.Context,+ logger *slog.Logger,+ sourceDatabase *databases.Database,+) *float64 {+ probeCtx, cancelProbe := context.WithTimeout(ctx, clusterSizeProbeTimeout)+ defer cancelProbe()++ clusterSizeMb, err := sourceDatabase.PostgresqlPhysical.GetClusterSizeMb(+ probeCtx,+ logger,+ b.fieldEncryptor,+ )+ if err != nil {+ logger.Warn("failed to measure source cluster size", "error", err)++ return nil+ }++ return &clusterSizeMb+}+func (b *PhysicalBackuper) persistFullResult(fullBackup *physical_models.PhysicalFullBackup,backupResult postgresql_executor.PhysicalBackupResult,+ rawSizeMb *float64,) error {fullBackup.Status = backupResult.StatusfullBackup.ErrorReason = backupResult.ErrorReason@@ -331,6 +360,7 @@ func (b *PhysicalBackuper) persistFullResult(fullBackup.StartLSN = lsnPtr(backupResult.StartLSN)fullBackup.StopLSN = lsnPtr(backupResult.StopLSN)fullBackup.BackupSizeMb = &backupResult.BackupSizeMb+ fullBackup.RawSizeMb = rawSizeMbfullBackup.BackupDurationMs = &backupResult.BackupDurationMsfullBackup.Encryption = backupResult.EncryptionAlgofullBackup.EncryptionSalt = nilOrPtr(backupResult.EncryptionSalt)diff --git a/backend/internal/features/backups/backups/backuping/physical/backuper_test.go b/backend/internal/features/backups/backups/backuping/physical/backuper_test.goindex 7498745a..a00e462c 100644--- a/backend/internal/features/backups/backups/backuping/physical/backuper_test.go+++ b/backend/internal/features/backups/backups/backuping/physical/backuper_test.go@@ -140,7 +140,7 @@ func Test_PersistFullResult_WhenCompleted_CopiesCompressionManifestFieldsAndReleCompletedAt: time.Now().UTC(),}- require.NoError(t, backuper.persistFullResult(fullBackup, result))+ require.NoError(t, backuper.persistFullResult(fullBackup, result, nil))persisted, err := physical_repositories.GetFullBackupRepository().FindByID(fullBackup.ID)require.NoError(t, err)@@ -161,6 +161,53 @@ func Test_PersistFullResult_WhenCompleted_CopiesCompressionManifestFieldsAndReleassertInFlightReleased(t, prereqs.DB.ID)}+func Test_PersistFullResult_WhenCompletedWithMeasuredClusterSize_StoresRawSizeMb(t *testing.T) {+ prereqs := seedBackupPrereqs(t)+ backuper := CreateTestPhysicalBackuper(nil)++ fullBackup := seedInProgressFull(t, prereqs)+ claimInFlight(t, prereqs.DB.ID, physical_enums.PhysicalBackupTypeFull, fullBackup.ID)++ result := postgresql_executor.PhysicalBackupResult{+ Status: physical_enums.PhysicalBackupStatusCompleted,+ BackupSizeMb: 42.5,+ CompletedAt: time.Now().UTC(),+ }++ require.NoError(t, backuper.persistFullResult(fullBackup, result, new(4321.5)))++ persisted, err := physical_repositories.GetFullBackupRepository().FindByID(fullBackup.ID)+ require.NoError(t, err)+ require.NotNil(t, persisted)++ require.NotNil(t, persisted.RawSizeMb)+ assert.InDelta(t, 4321.5, *persisted.RawSizeMb, 0.001)+}++func Test_PersistFullResult_WhenClusterSizeUnmeasured_LeavesRawSizeMbNil(t *testing.T) {+ prereqs := seedBackupPrereqs(t)+ backuper := CreateTestPhysicalBackuper(nil)++ fullBackup := seedInProgressFull(t, prereqs)+ claimInFlight(t, prereqs.DB.ID, physical_enums.PhysicalBackupTypeFull, fullBackup.ID)++ result := postgresql_executor.PhysicalBackupResult{+ Status: physical_enums.PhysicalBackupStatusCompleted,+ BackupSizeMb: 42.5,+ CompletedAt: time.Now().UTC(),+ }++ require.NoError(t, backuper.persistFullResult(fullBackup, result, nil))++ persisted, err := physical_repositories.GetFullBackupRepository().FindByID(fullBackup.ID)+ require.NoError(t, err)+ require.NotNil(t, persisted)++ assert.Equal(t, physical_enums.PhysicalBackupStatusCompleted, persisted.Status,+ "a nil raw size must not downgrade the persisted status")+ assert.Nil(t, persisted.RawSizeMb)+}+func Test_PersistFullResult_WhenErrorStatus_SkipsCompletionFieldsAndReleasesInFlight(t *testing.T) {prereqs := seedBackupPrereqs(t)backuper := CreateTestPhysicalBackuper(nil)@@ -174,7 +221,7 @@ func Test_PersistFullResult_WhenErrorStatus_SkipsCompletionFieldsAndReleasesInFlManifestFileName: "should-not-be-copied",}- require.NoError(t, backuper.persistFullResult(fullBackup, result))+ require.NoError(t, backuper.persistFullResult(fullBackup, result, nil))persisted, err := physical_repositories.GetFullBackupRepository().FindByID(fullBackup.ID)require.NoError(t, err)@@ -668,7 +715,7 @@ func Test_PersistFullResult_WhenRowNoLongerInProgress_DoesNotResurrect(t *testinerr := backuper.persistFullResult(full, postgresql_executor.PhysicalBackupResult{Status: physical_enums.PhysicalBackupStatusCompleted,- })+ }, nil)require.NoError(t, err)reloaded, err := fullRepo.FindByID(full.ID)diff --git a/backend/internal/features/backups/backups/backuping/physical/constants.go b/backend/internal/features/backups/backups/backuping/physical/constants.goindex 0d2318e1..d714187e 100644--- a/backend/internal/features/backups/backups/backuping/physical/constants.go+++ b/backend/internal/features/backups/backups/backuping/physical/constants.go@@ -55,6 +55,12 @@ const (// One notification per incident, not one per reclaim cycle.defaultChainAlertMinInterval = 15 * time.Minute++ // The telemetry cluster-size probe runs before the executor and its connection+ // string carries no connect_timeout, so a source that accepts TCP and then+ // stalls would delay the backup itself. 30 s is far past a healthy+ // SUM(pg_database_size) even on a large cluster.+ clusterSizeProbeTimeout = 30 * time.Second)// Per-tick WAL deletion budget anchors to the latest FULL's size (a clusterdiff --git a/backend/internal/features/telemetry/background_service_test.go b/backend/internal/features/telemetry/background_service_test.goindex a89c2361..a4b28347 100644--- a/backend/internal/features/telemetry/background_service_test.go+++ b/backend/internal/features/telemetry/background_service_test.go@@ -52,7 +52,7 @@ func newBackgroundServiceUnderTest(t *testing.T, sender TelemetrySender) *Teleme&fakeStorageLister{},&fakeNotifierLister{},&fakeBackupChecker{},- &fakePhysicalFullBackupSizer{},+ &fakeLatestPhysicalBackupReader{},&fakeVerificationAgentLister{},&fakeVerificationConfigLister{},&fakeUserCounter{},diff --git a/backend/internal/features/telemetry/dto.go b/backend/internal/features/telemetry/dto.goindex 4a67d10a..1e8b6aef 100644--- a/backend/internal/features/telemetry/dto.go+++ b/backend/internal/features/telemetry/dto.go@@ -1,5 +1,19 @@package telemetry+import (+ "time"++ "github.com/google/uuid"++ backups_core_logical "databasus-backend/internal/features/backups/backups/core/logical"+ physical_models "databasus-backend/internal/features/backups/backups/core/physical/models"+ "databasus-backend/internal/features/databases"+ "databasus-backend/internal/features/notifiers"+ "databasus-backend/internal/features/storages"+ verification_agents "databasus-backend/internal/features/verification/agents"+ verification_config "databasus-backend/internal/features/verification/config"+)+type DatabaseEntry struct {Type string `json:"type"`Version string `json:"version"`@@ -34,3 +48,37 @@ type CollectRequest struct {Notifiers []string `json:"notifiers"`VerificationAgents []VerificationAgentEntry `json:"verificationAgents"`}++type databaseLister interface {+ GetAllDatabases() ([]*databases.Database, error)+}++type storageLister interface {+ GetAllStorages() ([]*storages.Storage, error)+}++type notifierLister interface {+ GetAllNotifiers() ([]*notifiers.Notifier, error)+}++type backupChecker interface {+ HasSuccessfulBackupSince(databaseID uuid.UUID, since time.Time) (bool, error)+ GetLatestCompletedBackup(databaseID uuid.UUID) (*backups_core_logical.LogicalBackup, error)+}++type latestPhysicalBackupReader interface {+ GetLatestCompletedFullBackup(databaseID uuid.UUID) (*physical_models.PhysicalFullBackup, error)+ GetLastBackupTimesByDatabaseIDs(databaseIDs []uuid.UUID) (map[uuid.UUID]time.Time, error)+}++type userCounter interface {+ GetUsersCount() (int64, error)+}++type verificationAgentLister interface {+ ListAgents() ([]*verification_agents.Agent, error)+}++type verificationConfigLister interface {+ ListEnabled() ([]*verification_config.BackupVerificationConfig, error)+}diff --git a/backend/internal/features/telemetry/service.go b/backend/internal/features/telemetry/service.goindex 561ad3ef..3e0238f6 100644--- a/backend/internal/features/telemetry/service.go+++ b/backend/internal/features/telemetry/service.go@@ -5,17 +5,12 @@ import ("log/slog""math""runtime"- "sort"+ "slices""time""github.com/google/uuid"- backups_core_logical "databasus-backend/internal/features/backups/backups/core/logical"- physical_models "databasus-backend/internal/features/backups/backups/core/physical/models""databasus-backend/internal/features/databases"- "databasus-backend/internal/features/notifiers"- "databasus-backend/internal/features/storages"- verification_agents "databasus-backend/internal/features/verification/agents"verification_config "databasus-backend/internal/features/verification/config")@@ -28,39 +23,6 @@ const (maxArrayEntries = 200)-type databaseLister interface {- GetAllDatabases() ([]*databases.Database, error)-}--type storageLister interface {- GetAllStorages() ([]*storages.Storage, error)-}--type notifierLister interface {- GetAllNotifiers() ([]*notifiers.Notifier, error)-}--type backupChecker interface {- HasSuccessfulBackupSince(databaseID uuid.UUID, since time.Time) (bool, error)- GetLatestCompletedBackup(databaseID uuid.UUID) (*backups_core_logical.LogicalBackup, error)-}--type physicalFullBackupSizer interface {- GetLatestCompletedFullBackup(databaseID uuid.UUID) (*physical_models.PhysicalFullBackup, error)-}--type userCounter interface {- GetUsersCount() (int64, error)-}--type verificationAgentLister interface {- ListAgents() ([]*verification_agents.Agent, error)-}--type verificationConfigLister interface {- ListEnabled() ([]*verification_config.BackupVerificationConfig, error)-}-type TelemetryService struct {instanceLoader *InstanceFileLoadersender TelemetrySender@@ -68,7 +30,7 @@ type TelemetryService struct {storageService storageListernotifierService notifierListerbackupService backupChecker- physicalBackupService physicalFullBackupSizer+ physicalBackupService latestPhysicalBackupReaderverificationAgentService verificationAgentListerverificationConfigService verificationConfigListeruserService userCounter@@ -83,7 +45,7 @@ func NewTelemetryService(storageService storageLister,notifierService notifierLister,backupService backupChecker,- physicalBackupService physicalFullBackupSizer,+ physicalBackupService latestPhysicalBackupReader,verificationAgentService verificationAgentLister,verificationConfigService verificationConfigLister,userService userCounter,@@ -149,10 +111,10 @@ func (s *TelemetryService) BuildAndSend(ctx context.Context) error {Arch: runtime.GOARCH,InstalledAt: instance.InstalledAt,UserCount: int(userCount),- Databases: capDatabases(databaseEntries),- Storages: capStrings(storageTypes),- Notifiers: capStrings(notifierTypes),- VerificationAgents: capAgents(verificationAgents),+ Databases: capEntries(databaseEntries),+ Storages: capEntries(storageTypes),+ Notifiers: capEntries(notifierTypes),+ VerificationAgents: capEntries(verificationAgents),}return s.sender.Send(ctx, req)@@ -183,11 +145,16 @@ func (s *TelemetryService) collectActiveDatabases(return nil, err}+ lastPhysicalBackupTimes, err := s.loadLastPhysicalBackupTimes(allDatabases)+ if err != nil {+ return nil, err+ }+since := time.Now().UTC().Add(-activeBackupWindow)entries := make([]DatabaseEntry, 0, len(allDatabases))for _, db := range allDatabases {- isActive, err := s.isDatabaseActive(db, since)+ isActive, err := s.isDatabaseActive(db, since, lastPhysicalBackupTimes)if err != nil {return nil, err}@@ -249,10 +216,8 @@ func (s *TelemetryService) collectVerificationAgents() ([]VerificationAgentEntryreturn entries, nil}-// attachBackupSizes records raw/compressed size from the size-of-record backup.// Physical databases have no logical backup rows, so their size comes from the-// latest completed physical FULL backup; every other type uses the latest-// completed logical backup.+// latest completed physical FULL backup.func (s *TelemetryService) attachBackupSizes(entry *DatabaseEntry,db *databases.Database,@@ -305,23 +270,47 @@ func (s *TelemetryService) attachPhysicalBackupSizes(return nil}-// isDatabaseActive returns true when a database should be counted in telemetry.-//-// - HealthStatus == AVAILABLE → active.-// - HealthStatus == UNAVAILABLE → not active (healthcheck is on and the DB is down).-// - HealthStatus == nil → healthcheck is disabled; active only if a-// successful backup happened inside `since`.+// A nil HealthStatus means the healthcheck is switched off for that database, not that it is+// broken, so the backup recency of the owning engine decides instead.func (s *TelemetryService) isDatabaseActive(db *databases.Database,since time.Time,+ lastPhysicalBackupTimes map[uuid.UUID]time.Time,) (bool, error) {if db.HealthStatus != nil {return *db.HealthStatus == databases.HealthStatusAvailable, nil}+ if db.Type == databases.DatabaseTypePostgresPhysical {+ lastBackupTime, hasBackup := lastPhysicalBackupTimes[db.ID]++ return hasBackup && lastBackupTime.After(since), nil+ }+return s.backupService.HasSuccessfulBackupSince(db.ID, since)}+// Only databases whose activity check will actually read the map are queried, so an instance+// where every physical database is healthchecked never pays for — nor fails a whole ping on — a+// query it would ignore.+func (s *TelemetryService) loadLastPhysicalBackupTimes(+ allDatabases []*databases.Database,+) (map[uuid.UUID]time.Time, error) {+ physicalDatabaseIDs := make([]uuid.UUID, 0, len(allDatabases))++ for _, db := range allDatabases {+ if db.Type == databases.DatabaseTypePostgresPhysical && db.HealthStatus == nil {+ physicalDatabaseIDs = append(physicalDatabaseIDs, db.ID)+ }+ }++ if len(physicalDatabaseIDs) == 0 {+ return map[uuid.UUID]time.Time{}, nil+ }++ return s.physicalBackupService.GetLastBackupTimesByDatabaseIDs(physicalDatabaseIDs)+}+func buildDatabaseEntry(db *databases.Database) (DatabaseEntry, bool) {switch db.Type {case databases.DatabaseTypePostgresLogical:@@ -366,18 +355,19 @@ func (s *TelemetryService) collectStorageTypes() ([]string, error) {return nil, err}- types := make([]string, 0, len(allStorages))- for _, st := range allStorages {- key := string(st.Type)- if key == "" {+ storageTypes := make([]string, 0, len(allStorages))++ for _, storage := range allStorages {+ if storage.Type == "" {continue}- types = append(types, key)+ storageTypes = append(storageTypes, string(storage.Type))}- sort.Strings(types)- return types, nil+ slices.Sort(storageTypes)++ return storageTypes, nil}func (s *TelemetryService) collectNotifierTypes() ([]string, error) {@@ -386,40 +376,25 @@ func (s *TelemetryService) collectNotifierTypes() ([]string, error) {return nil, err}- types := make([]string, 0, len(allNotifiers))- for _, n := range allNotifiers {- key := string(n.NotifierType)- if key == "" {+ notifierTypes := make([]string, 0, len(allNotifiers))++ for _, notifier := range allNotifiers {+ if notifier.NotifierType == "" {continue}- types = append(types, key)- }-- sort.Strings(types)- return types, nil-}--func capStrings(in []string) []string {- if len(in) > maxArrayEntries {- return in[:maxArrayEntries]+ notifierTypes = append(notifierTypes, string(notifier.NotifierType))}- return in-}--func capDatabases(in []DatabaseEntry) []DatabaseEntry {- if len(in) > maxArrayEntries {- return in[:maxArrayEntries]- }+ slices.Sort(notifierTypes)- return in+ return notifierTypes, nil}-func capAgents(in []VerificationAgentEntry) []VerificationAgentEntry {- if len(in) > maxArrayEntries {- return in[:maxArrayEntries]+func capEntries[T any](entries []T) []T {+ if len(entries) > maxArrayEntries {+ return entries[:maxArrayEntries]}- return in+ return entries}diff --git a/backend/internal/features/telemetry/service_test.go b/backend/internal/features/telemetry/service_test.goindex cc81d02e..e8502650 100644--- a/backend/internal/features/telemetry/service_test.go+++ b/backend/internal/features/telemetry/service_test.go@@ -5,9 +5,11 @@ import ("encoding/json""errors""log/slog"+ "maps""os""path/filepath""runtime"+ "slices""testing""time"@@ -96,21 +98,41 @@ func (f *fakeBackupChecker) GetLatestCompletedBackup(return f.latestBackups[databaseID], nil}-type fakePhysicalFullBackupSizer struct {- fullBackups map[uuid.UUID]*physical_models.PhysicalFullBackup- err error+type fakeLatestPhysicalBackupReader struct {+ fullBackups map[uuid.UUID]*physical_models.PhysicalFullBackup+ lastBackupTimes map[uuid.UUID]time.Time+ latestFullBackupErr error+ lastBackupTimesErr error}-func (f *fakePhysicalFullBackupSizer) GetLatestCompletedFullBackup(+func (f *fakeLatestPhysicalBackupReader) GetLatestCompletedFullBackup(databaseID uuid.UUID,) (*physical_models.PhysicalFullBackup, error) {- if f.err != nil {- return nil, f.err+ if f.latestFullBackupErr != nil {+ return nil, f.latestFullBackupErr}return f.fullBackups[databaseID], nil}+func (f *fakeLatestPhysicalBackupReader) GetLastBackupTimesByDatabaseIDs(+ databaseIDs []uuid.UUID,+) (map[uuid.UUID]time.Time, error) {+ if f.lastBackupTimesErr != nil {+ return nil, f.lastBackupTimesErr+ }++ foundLastBackupTimes := make(map[uuid.UUID]time.Time, len(databaseIDs))++ for _, databaseID := range databaseIDs {+ if lastBackupTime, hasBackup := f.lastBackupTimes[databaseID]; hasBackup {+ foundLastBackupTimes[databaseID] = lastBackupTime+ }+ }++ return foundLastBackupTimes, nil+}+type fakeUserCounter struct {count int64err error@@ -145,45 +167,54 @@ func (f *fakeVerificationConfigLister) ListEnabled() (return f.enabled, f.err}-func newServiceUnderTest(- t *testing.T,- databaseLister databaseLister,- storageLister storageLister,- notifierLister notifierLister,- backupChecker backupChecker,- verificationAgentLister verificationAgentLister,- verificationConfigLister verificationConfigLister,- sender TelemetrySender,-) *TelemetryService {- t.Helper()-- return newServiceUnderTestWith(- t,- databaseLister,- storageLister,- notifierLister,- backupChecker,- &fakePhysicalFullBackupSizer{},- verificationAgentLister,- verificationConfigLister,- &fakeUserCounter{},- sender,- )+type serviceDependencies struct {+ databaseLister databaseLister+ storageLister storageLister+ notifierLister notifierLister+ backupChecker backupChecker+ physicalBackupReader latestPhysicalBackupReader+ verificationAgentLister verificationAgentLister+ verificationConfigLister verificationConfigLister+ userCounter userCounter+ sender TelemetrySender}-func newServiceUnderTestWith(- t *testing.T,- databaseLister databaseLister,- storageLister storageLister,- notifierLister notifierLister,- backupChecker backupChecker,- physicalBackupSizer physicalFullBackupSizer,- verificationAgentLister verificationAgentLister,- verificationConfigLister verificationConfigLister,- userCounter userCounter,- sender TelemetrySender,-) *TelemetryService {+// Every unset dependency falls back to an empty fake so a test names only what it varies.+func newServiceUnderTest(t *testing.T, dependencies serviceDependencies) *TelemetryService {t.Helper()++ if dependencies.databaseLister == nil {+ dependencies.databaseLister = &fakeDatabaseLister{}+ }++ if dependencies.storageLister == nil {+ dependencies.storageLister = &fakeStorageLister{}+ }++ if dependencies.notifierLister == nil {+ dependencies.notifierLister = &fakeNotifierLister{}+ }++ if dependencies.backupChecker == nil {+ dependencies.backupChecker = &fakeBackupChecker{}+ }++ if dependencies.physicalBackupReader == nil {+ dependencies.physicalBackupReader = &fakeLatestPhysicalBackupReader{}+ }++ if dependencies.verificationAgentLister == nil {+ dependencies.verificationAgentLister = &fakeVerificationAgentLister{}+ }++ if dependencies.verificationConfigLister == nil {+ dependencies.verificationConfigLister = &fakeVerificationConfigLister{}+ }++ if dependencies.userCounter == nil {+ dependencies.userCounter = &fakeUserCounter{}+ }+loader := NewInstanceFileLoader(filepath.Join(t.TempDir(), "instance.json"),slog.New(slog.DiscardHandler),@@ -191,15 +222,15 @@ func newServiceUnderTestWith(return NewTelemetryService(loader,- sender,- databaseLister,- storageLister,- notifierLister,- backupChecker,- physicalBackupSizer,- verificationAgentLister,- verificationConfigLister,- userCounter,+ dependencies.sender,+ dependencies.databaseLister,+ dependencies.storageLister,+ dependencies.notifierLister,+ dependencies.backupChecker,+ dependencies.physicalBackupReader,+ dependencies.verificationAgentLister,+ dependencies.verificationConfigLister,+ dependencies.userCounter,"9.9.9",slog.New(slog.DiscardHandler),)@@ -244,10 +275,6 @@ func physicalDatabase(}}-func floatPtr(value float64) *float64 {- return &value-}-func Test_BuildAndSend_ProducesExpectedRequest(t *testing.T) {pgDB := postgresDatabase("pg", availableStatus())mysqlDB := &databases.Database{@@ -273,22 +300,18 @@ func Test_BuildAndSend_ProducesExpectedRequest(t *testing.T) {}sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{pgDB, mysqlDB, mariaDB, mongoDB}},- &fakeStorageLister{storages: []*storages.Storage{+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{pgDB, mysqlDB, mariaDB, mongoDB}},+ storageLister: &fakeStorageLister{storages: []*storages.Storage{{Type: storages.StorageTypeS3},{Type: storages.StorageTypeLocal},}},- &fakeNotifierLister{notifiers: []*notifiers.Notifier{+ notifierLister: &fakeNotifierLister{notifiers: []*notifiers.Notifier{{NotifierType: notifiers.NotifierTypeEmail},{NotifierType: notifiers.NotifierTypeTelegram},}},- &fakeBackupChecker{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)@@ -299,13 +322,15 @@ func Test_BuildAndSend_ProducesExpectedRequest(t *testing.T) {assert.Equal(t, runtime.GOARCH, req.Arch)require.Len(t, req.Databases, 4)- types := make([]string, 0, len(req.Databases))- for _, d := range req.Databases {- types = append(types, d.Type)+ databaseTypes := make([]string, 0, len(req.Databases))++ for _, databaseEntry := range req.Databases {+ databaseTypes = append(databaseTypes, databaseEntry.Type)}+assert.ElementsMatch(t,[]string{"POSTGRES_LOGICAL", "MYSQL", "MARIADB", "MONGODB"},- types,+ databaseTypes,)assert.Equal(t, []string{"LOCAL", "S3"}, req.Storages)@@ -317,25 +342,20 @@ func Test_BuildAndSend_ProducesExpectedRequest(t *testing.T) {func Test_BuildAndSend_PreservesStorageAndNotifierDuplicates(t *testing.T) {sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{},- &fakeStorageLister{storages: []*storages.Storage{+ service := newServiceUnderTest(t, serviceDependencies{+ storageLister: &fakeStorageLister{storages: []*storages.Storage{{Type: storages.StorageTypeS3},{Type: storages.StorageTypeS3},{Type: storages.StorageTypeS3},{Type: storages.StorageTypeLocal},}},- &fakeNotifierLister{notifiers: []*notifiers.Notifier{+ notifierLister: &fakeNotifierLister{notifiers: []*notifiers.Notifier{{NotifierType: notifiers.NotifierTypeEmail},{NotifierType: notifiers.NotifierTypeEmail},{NotifierType: notifiers.NotifierTypeTelegram},}},- &fakeBackupChecker{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)@@ -363,7 +383,7 @@ func Test_BuildAndSend_WhenInstanceFileFails_DoesNotCallSender(t *testing.T) {&fakeStorageLister{},&fakeNotifierLister{},&fakeBackupChecker{},- &fakePhysicalFullBackupSizer{},+ &fakeLatestPhysicalBackupReader{},&fakeVerificationAgentLister{},&fakeVerificationConfigLister{},&fakeUserCounter{},@@ -379,16 +399,9 @@ func Test_BuildAndSend_WhenSenderFails_PropagatesError(t *testing.T) {sendErr := errors.New("network down")sender := &fakeSender{err: sendErr}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ sender: sender,+ })err := service.BuildAndSend(context.Background())require.Error(t, err)@@ -399,16 +412,10 @@ func Test_BuildAndSend_WhenDbHealthStatusAvailable_DbIncluded(t *testing.T) {db := postgresDatabase("pg", availableStatus())sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)@@ -419,16 +426,10 @@ func Test_BuildAndSend_WhenDbHealthStatusUnavailable_DbExcluded(t *testing.T) {db := postgresDatabase("pg", unavailableStatus())sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)@@ -439,16 +440,11 @@ func Test_BuildAndSend_WhenHealthcheckOffAndRecentBackup_DbIncluded(t *testing.Tdb := postgresDatabase("pg", nil)sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{hasBackupSince: map[uuid.UUID]bool{db.ID: true}},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ backupChecker: &fakeBackupChecker{hasBackupSince: map[uuid.UUID]bool{db.ID: true}},+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)@@ -460,16 +456,11 @@ func Test_BuildAndSend_WhenHealthcheckOffAndNoRecentBackup_DbExcluded(t *testingdb := postgresDatabase("pg", nil)sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{hasBackupSince: map[uuid.UUID]bool{}},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ backupChecker: &fakeBackupChecker{hasBackupSince: map[uuid.UUID]bool{}},+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)@@ -481,16 +472,11 @@ func Test_BuildAndSend_WhenBackupCheckerFails_ReturnsError(t *testing.T) {checkerErr := errors.New("db down")sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{err: checkerErr},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ backupChecker: &fakeBackupChecker{err: checkerErr},+ sender: sender,+ })err := service.BuildAndSend(context.Background())require.Error(t, err)@@ -502,151 +488,125 @@ func Test_BuildAndSend_WhenLatestBackupHasBothSizes_IncludesBoth(t *testing.T) {db := postgresDatabase("pg", availableStatus())sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ backupChecker: &fakeBackupChecker{latestBackups: map[uuid.UUID]*backups_core_logical.LogicalBackup{db.ID: {BackupSizeMb: 870.4, BackupRawDbSizeMb: 4321.7},},},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)require.Len(t, sender.calls[0].Databases, 1)- entry := sender.calls[0].Databases[0]- assert.Equal(t, int64(871), entry.BackupSizeMb)- assert.Equal(t, int64(4322), entry.RawSizeMb)+ databaseEntry := sender.calls[0].Databases[0]+ assert.Equal(t, int64(871), databaseEntry.BackupSizeMb)+ assert.Equal(t, int64(4322), databaseEntry.RawSizeMb)}func Test_BuildAndSend_WhenSizesAreSubMb_RoundsUpToOne(t *testing.T) {db := postgresDatabase("pg", availableStatus())sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ backupChecker: &fakeBackupChecker{latestBackups: map[uuid.UUID]*backups_core_logical.LogicalBackup{db.ID: {BackupSizeMb: 0.3, BackupRawDbSizeMb: 0.1},},},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)require.Len(t, sender.calls[0].Databases, 1)- entry := sender.calls[0].Databases[0]- assert.Equal(t, int64(1), entry.BackupSizeMb)- assert.Equal(t, int64(1), entry.RawSizeMb)+ databaseEntry := sender.calls[0].Databases[0]+ assert.Equal(t, int64(1), databaseEntry.BackupSizeMb)+ assert.Equal(t, int64(1), databaseEntry.RawSizeMb)- encoded, err := json.Marshal(entry)+ encodedEntry, err := json.Marshal(databaseEntry)require.NoError(t, err)- assert.Contains(t, string(encoded), "backupSizeMb")- assert.Contains(t, string(encoded), "rawSizeMb")+ assert.Contains(t, string(encodedEntry), "backupSizeMb")+ assert.Contains(t, string(encodedEntry), "rawSizeMb")}func Test_BuildAndSend_WhenRawSizeZero_IncludesOnlyBackupSize(t *testing.T) {db := postgresDatabase("pg", availableStatus())sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ backupChecker: &fakeBackupChecker{latestBackups: map[uuid.UUID]*backups_core_logical.LogicalBackup{db.ID: {BackupSizeMb: 100, BackupRawDbSizeMb: 0},},},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)require.Len(t, sender.calls[0].Databases, 1)- entry := sender.calls[0].Databases[0]- assert.Equal(t, int64(100), entry.BackupSizeMb)- assert.Equal(t, int64(0), entry.RawSizeMb)+ databaseEntry := sender.calls[0].Databases[0]+ assert.Equal(t, int64(100), databaseEntry.BackupSizeMb)+ assert.Equal(t, int64(0), databaseEntry.RawSizeMb)- encoded, err := json.Marshal(entry)+ encodedEntry, err := json.Marshal(databaseEntry)require.NoError(t, err)- assert.NotContains(t, string(encoded), "rawSizeMb")- assert.Contains(t, string(encoded), "backupSizeMb")+ assert.NotContains(t, string(encodedEntry), "rawSizeMb")+ assert.Contains(t, string(encodedEntry), "backupSizeMb")}func Test_BuildAndSend_WhenBackupSizeZero_IncludesOnlyRawSize(t *testing.T) {db := postgresDatabase("pg", availableStatus())sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ backupChecker: &fakeBackupChecker{latestBackups: map[uuid.UUID]*backups_core_logical.LogicalBackup{db.ID: {BackupSizeMb: 0, BackupRawDbSizeMb: 999},},},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)require.Len(t, sender.calls[0].Databases, 1)- entry := sender.calls[0].Databases[0]- assert.Equal(t, int64(0), entry.BackupSizeMb)- assert.Equal(t, int64(999), entry.RawSizeMb)+ databaseEntry := sender.calls[0].Databases[0]+ assert.Equal(t, int64(0), databaseEntry.BackupSizeMb)+ assert.Equal(t, int64(999), databaseEntry.RawSizeMb)}func Test_BuildAndSend_WhenNoCompletedBackup_OmitsBothSizes(t *testing.T) {db := postgresDatabase("pg", availableStatus())sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)require.Len(t, sender.calls[0].Databases, 1)- entry := sender.calls[0].Databases[0]- assert.Equal(t, int64(0), entry.BackupSizeMb)- assert.Equal(t, int64(0), entry.RawSizeMb)+ databaseEntry := sender.calls[0].Databases[0]+ assert.Equal(t, int64(0), databaseEntry.BackupSizeMb)+ assert.Equal(t, int64(0), databaseEntry.RawSizeMb)- encoded, err := json.Marshal(entry)+ encodedEntry, err := json.Marshal(databaseEntry)require.NoError(t, err)- assert.NotContains(t, string(encoded), "rawSizeMb")- assert.NotContains(t, string(encoded), "backupSizeMb")+ assert.NotContains(t, string(encodedEntry), "rawSizeMb")+ assert.NotContains(t, string(encodedEntry), "backupSizeMb")}func Test_BuildAndSend_WhenLatestBackupLookupFails_ReturnsError(t *testing.T) {@@ -654,16 +614,11 @@ func Test_BuildAndSend_WhenLatestBackupLookupFails_ReturnsError(t *testing.T) {lookupErr := errors.New("query exploded")sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{latestErr: lookupErr},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ backupChecker: &fakeBackupChecker{latestErr: lookupErr},+ sender: sender,+ })err := service.BuildAndSend(context.Background())require.Error(t, err)@@ -692,16 +647,10 @@ func Test_BuildAndSend_WhenAgentsRegistered_IncludesCapacityRows(t *testing.T) {}sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakeVerificationAgentLister{agents: registeredAgents},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ verificationAgentLister: &fakeVerificationAgentLister{agents: registeredAgents},+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)@@ -714,16 +663,9 @@ func Test_BuildAndSend_WhenAgentsRegistered_IncludesCapacityRows(t *testing.T) {func Test_BuildAndSend_WhenNoAgents_VerificationAgentsIsEmpty(t *testing.T) {sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)@@ -731,125 +673,107 @@ func Test_BuildAndSend_WhenNoAgents_VerificationAgentsIsEmpty(t *testing.T) {require.NotNil(t, sender.calls[0].VerificationAgents)assert.Empty(t, sender.calls[0].VerificationAgents)- encoded, err := json.Marshal(sender.calls[0])+ encodedPayload, err := json.Marshal(sender.calls[0])require.NoError(t, err)- assert.Contains(t, string(encoded), `"verificationAgents":[]`)+ assert.Contains(t, string(encodedPayload), `"verificationAgents":[]`)}func Test_BuildAndSend_WhenDbHasAfterBackupConfig_VerificationBlockOmitsIntervalType(t *testing.T) {db := postgresDatabase("pg", availableStatus())sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{enabled: []*verification_config.BackupVerificationConfig{- {- DatabaseID: db.ID,- IsScheduledVerificationEnabled: true,- ScheduleType: verification_config.VerificationScheduleAfterBackup,+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ verificationConfigLister: &fakeVerificationConfigLister{+ enabled: []*verification_config.BackupVerificationConfig{+ {+ DatabaseID: db.ID,+ IsScheduledVerificationEnabled: true,+ ScheduleType: verification_config.VerificationScheduleAfterBackup,+ },},- }},- sender,- )+ },+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)require.Len(t, sender.calls[0].Databases, 1)- entry := sender.calls[0].Databases[0]- require.NotNil(t, entry.Verification)- assert.True(t, entry.Verification.IsEnabled)- assert.Equal(t, "AFTER_BACKUP", entry.Verification.ScheduleType)- assert.Empty(t, entry.Verification.IntervalType)+ databaseEntry := sender.calls[0].Databases[0]+ require.NotNil(t, databaseEntry.Verification)+ assert.True(t, databaseEntry.Verification.IsEnabled)+ assert.Equal(t, "AFTER_BACKUP", databaseEntry.Verification.ScheduleType)+ assert.Empty(t, databaseEntry.Verification.IntervalType)- encoded, err := json.Marshal(entry)+ encodedEntry, err := json.Marshal(databaseEntry)require.NoError(t, err)- assert.Contains(t, string(encoded), `"verification"`)- assert.NotContains(t, string(encoded), "intervalType")+ assert.Contains(t, string(encodedEntry), `"verification"`)+ assert.NotContains(t, string(encodedEntry), "intervalType")}func Test_BuildAndSend_WhenDbHasIntervalDailyConfig_IncludesIntervalType(t *testing.T) {db := postgresDatabase("pg", availableStatus())sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{enabled: []*verification_config.BackupVerificationConfig{- {- DatabaseID: db.ID,- IsScheduledVerificationEnabled: true,- ScheduleType: verification_config.VerificationScheduleInterval,- VerificationInterval: intervals.Interval{Type: intervals.IntervalDaily},+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ verificationConfigLister: &fakeVerificationConfigLister{+ enabled: []*verification_config.BackupVerificationConfig{+ {+ DatabaseID: db.ID,+ IsScheduledVerificationEnabled: true,+ ScheduleType: verification_config.VerificationScheduleInterval,+ VerificationInterval: intervals.Interval{Type: intervals.IntervalDaily},+ },},- }},- sender,- )+ },+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)require.Len(t, sender.calls[0].Databases, 1)- entry := sender.calls[0].Databases[0]- require.NotNil(t, entry.Verification)- assert.True(t, entry.Verification.IsEnabled)- assert.Equal(t, "INTERVAL", entry.Verification.ScheduleType)- assert.Equal(t, "DAILY", entry.Verification.IntervalType)+ databaseEntry := sender.calls[0].Databases[0]+ require.NotNil(t, databaseEntry.Verification)+ assert.True(t, databaseEntry.Verification.IsEnabled)+ assert.Equal(t, "INTERVAL", databaseEntry.Verification.ScheduleType)+ assert.Equal(t, "DAILY", databaseEntry.Verification.IntervalType)- encoded, err := json.Marshal(entry)+ encodedEntry, err := json.Marshal(databaseEntry)require.NoError(t, err)- assert.Contains(t, string(encoded), `"intervalType":"DAILY"`)+ assert.Contains(t, string(encodedEntry), `"intervalType":"DAILY"`)}func Test_BuildAndSend_WhenDbHasNoEnabledConfig_VerificationBlockAbsent(t *testing.T) {db := postgresDatabase("pg", availableStatus())sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)require.Len(t, sender.calls[0].Databases, 1)- entry := sender.calls[0].Databases[0]- assert.Nil(t, entry.Verification)+ databaseEntry := sender.calls[0].Databases[0]+ assert.Nil(t, databaseEntry.Verification)- encoded, err := json.Marshal(entry)+ encodedEntry, err := json.Marshal(databaseEntry)require.NoError(t, err)- assert.NotContains(t, string(encoded), "verification")+ assert.NotContains(t, string(encodedEntry), "verification")}func Test_BuildAndSend_WhenVerificationAgentListFails_ReturnsError(t *testing.T) {listErr := errors.New("agents query exploded")sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakeVerificationAgentLister{err: listErr},- &fakeVerificationConfigLister{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ verificationAgentLister: &fakeVerificationAgentLister{err: listErr},+ sender: sender,+ })err := service.BuildAndSend(context.Background())require.Error(t, err)@@ -860,16 +784,10 @@ func Test_BuildAndSend_WhenVerificationAgentListFails_ReturnsError(t *testing.T)func Test_BuildAndSend_WhenVerificationConfigListFails_ReturnsError(t *testing.T) {listErr := errors.New("configs query exploded")sender := &fakeSender{}- service := newServiceUnderTest(- t,- &fakeDatabaseLister{},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{err: listErr},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ verificationConfigLister: &fakeVerificationConfigLister{err: listErr},+ sender: sender,+ })err := service.BuildAndSend(context.Background())require.Error(t, err)@@ -885,69 +803,54 @@ func Test_BuildAndSend_WhenPhysicalDatabase_EmitsTypeBackupTypeAndFullBackupSize)sender := &fakeSender{}- service := newServiceUnderTestWith(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakePhysicalFullBackupSizer{+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ physicalBackupReader: &fakeLatestPhysicalBackupReader{fullBackups: map[uuid.UUID]*physical_models.PhysicalFullBackup{- db.ID: {BackupSizeMb: floatPtr(38400.2), RawSizeMb: floatPtr(192000.7)},+ db.ID: {BackupSizeMb: new(38400.2), RawSizeMb: new(192000.7)},},},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- &fakeUserCounter{},- sender,- )+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)require.Len(t, sender.calls[0].Databases, 1)- entry := sender.calls[0].Databases[0]- assert.Equal(t, "POSTGRES_PHYSICAL", entry.Type)- assert.Equal(t, "17", entry.Version)- assert.Equal(t, "FULL_INCREMENTAL_WAL_STREAM", entry.BackupType)- assert.Equal(t, int64(38401), entry.BackupSizeMb)- assert.Equal(t, int64(192001), entry.RawSizeMb)+ databaseEntry := sender.calls[0].Databases[0]+ assert.Equal(t, "POSTGRES_PHYSICAL", databaseEntry.Type)+ assert.Equal(t, "17", databaseEntry.Version)+ assert.Equal(t, "FULL_INCREMENTAL_WAL_STREAM", databaseEntry.BackupType)+ assert.Equal(t, int64(38401), databaseEntry.BackupSizeMb)+ assert.Equal(t, int64(192001), databaseEntry.RawSizeMb)- encoded, err := json.Marshal(entry)+ encodedEntry, err := json.Marshal(databaseEntry)require.NoError(t, err)- assert.Contains(t, string(encoded), `"backupType":"FULL_INCREMENTAL_WAL_STREAM"`)+ assert.Contains(t, string(encodedEntry), `"backupType":"FULL_INCREMENTAL_WAL_STREAM"`)}func Test_BuildAndSend_WhenPhysicalDatabaseHasNoFullBackup_OmitsSizes(t *testing.T) {db := physicalDatabase("pg-physical", postgresql_physical.BackupTypeFullOnly, availableStatus())sender := &fakeSender{}- service := newServiceUnderTestWith(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakePhysicalFullBackupSizer{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- &fakeUserCounter{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ sender: sender,+ })require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)require.Len(t, sender.calls[0].Databases, 1)- entry := sender.calls[0].Databases[0]- assert.Equal(t, "FULL", entry.BackupType)- assert.Equal(t, int64(0), entry.BackupSizeMb)- assert.Equal(t, int64(0), entry.RawSizeMb)+ databaseEntry := sender.calls[0].Databases[0]+ assert.Equal(t, "FULL", databaseEntry.BackupType)+ assert.Equal(t, int64(0), databaseEntry.BackupSizeMb)+ assert.Equal(t, int64(0), databaseEntry.RawSizeMb)- encoded, err := json.Marshal(entry)+ encodedEntry, err := json.Marshal(databaseEntry)require.NoError(t, err)- assert.NotContains(t, string(encoded), "rawSizeMb")- assert.NotContains(t, string(encoded), "backupSizeMb")+ assert.NotContains(t, string(encodedEntry), "rawSizeMb")+ assert.NotContains(t, string(encodedEntry), "backupSizeMb")}func Test_BuildAndSend_WhenPhysicalFullBackupLookupFails_ReturnsError(t *testing.T) {@@ -955,18 +858,11 @@ func Test_BuildAndSend_WhenPhysicalFullBackupLookupFails_ReturnsError(t *testinglookupErr := errors.New("physical query exploded")sender := &fakeSender{}- service := newServiceUnderTestWith(- t,- &fakeDatabaseLister{databases: []*databases.Database{db}},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakePhysicalFullBackupSizer{err: lookupErr},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- &fakeUserCounter{},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ physicalBackupReader: &fakeLatestPhysicalBackupReader{latestFullBackupErr: lookupErr},+ sender: sender,+ })err := service.BuildAndSend(context.Background())require.Error(t, err)@@ -974,21 +870,154 @@ func Test_BuildAndSend_WhenPhysicalFullBackupLookupFails_ReturnsError(t *testingassert.Empty(t, sender.calls)}-func Test_BuildAndSend_WhenUsersCounted_PopulatesUserCount(t *testing.T) {+func Test_BuildAndSend_WhenPhysicalDatabaseHasNoHealthStatusButRecentBackup_DatabaseIsReported(+ t *testing.T,+) {+ db := physicalDatabase("pg-physical", postgresql_physical.BackupTypeFullIncrementalAndWalStream, nil)+sender := &fakeSender{}- service := newServiceUnderTestWith(- t,- &fakeDatabaseLister{},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakePhysicalFullBackupSizer{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- &fakeUserCounter{count: 7},- sender,+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ physicalBackupReader: &fakeLatestPhysicalBackupReader{+ lastBackupTimes: map[uuid.UUID]time.Time{+ db.ID: time.Now().UTC().Add(-2 * time.Hour),+ },+ },+ sender: sender,+ })++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)+ require.Len(t, sender.calls[0].Databases, 1)++ databaseEntry := sender.calls[0].Databases[0]+ assert.Equal(t, "POSTGRES_PHYSICAL", databaseEntry.Type)+ assert.Equal(t, "FULL_INCREMENTAL_WAL_STREAM", databaseEntry.BackupType)+}++func Test_BuildAndSend_WhenPhysicalDatabaseHasNoHealthStatusAndStaleBackup_DatabaseIsSkipped(+ t *testing.T,+) {+ db := physicalDatabase("pg-physical", postgresql_physical.BackupTypeFullOnly, nil)++ sender := &fakeSender{}+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ physicalBackupReader: &fakeLatestPhysicalBackupReader{+ lastBackupTimes: map[uuid.UUID]time.Time{+ db.ID: time.Now().UTC().Add(-activeBackupWindow - time.Hour),+ },+ },+ sender: sender,+ })++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)+ assert.Empty(t, sender.calls[0].Databases)+}++func Test_BuildAndSend_WhenPhysicalDatabaseHasNoHealthStatusAndNoBackups_DatabaseIsSkipped(+ t *testing.T,+) {+ db := physicalDatabase("pg-physical", postgresql_physical.BackupTypeFullOnly, nil)++ sender := &fakeSender{}+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ sender: sender,+ })++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)+ assert.Empty(t, sender.calls[0].Databases)+}++func Test_BuildAndSend_WhenPhysicalLastBackupTimeLookupFails_ReturnsError(t *testing.T) {+ db := physicalDatabase("pg-physical", postgresql_physical.BackupTypeFullOnly, nil)+ lookupErr := errors.New("last backup time query exploded")++ sender := &fakeSender{}+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{db}},+ physicalBackupReader: &fakeLatestPhysicalBackupReader{lastBackupTimesErr: lookupErr},+ sender: sender,+ })++ err := service.BuildAndSend(context.Background())+ require.Error(t, err)+ assert.ErrorIs(t, err, lookupErr)+ assert.Empty(t, sender.calls)+}++func Test_BuildAndSend_WhenPayloadSerialized_ContainsDocumentedContractKeys(t *testing.T) {+ physicalDB := physicalDatabase(+ "pg-physical",+ postgresql_physical.BackupTypeFullIncrementalAndWalStream,+ availableStatus(),)+ sender := &fakeSender{}+ service := newServiceUnderTest(t, serviceDependencies{+ databaseLister: &fakeDatabaseLister{databases: []*databases.Database{physicalDB}},+ storageLister: &fakeStorageLister{storages: []*storages.Storage{{Type: storages.StorageTypeLocal}}},+ notifierLister: &fakeNotifierLister{+ notifiers: []*notifiers.Notifier{{NotifierType: notifiers.NotifierTypeEmail}},+ },+ physicalBackupReader: &fakeLatestPhysicalBackupReader{+ fullBackups: map[uuid.UUID]*physical_models.PhysicalFullBackup{+ physicalDB.ID: {BackupSizeMb: new(870.0), RawSizeMb: new(4321.0)},+ },+ },+ verificationAgentLister: &fakeVerificationAgentLister{+ agents: []*verification_agents.Agent{+ {MaxCPU: 4, MaxRAMGb: 8, MaxDiskGb: 100, MaxConcurrentJobs: 2},+ },+ },+ userCounter: &fakeUserCounter{count: 3},+ sender: sender,+ })++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)++ encodedPayload, err := json.Marshal(sender.calls[0])+ require.NoError(t, err)++ var decodedPayload map[string]any+ require.NoError(t, json.Unmarshal(encodedPayload, &decodedPayload))++ assert.ElementsMatch(t, []string{+ "instanceID",+ "appVersion",+ "os",+ "arch",+ "installedAt",+ "userCount",+ "databases",+ "storages",+ "notifiers",+ "verificationAgents",+ }, slices.Collect(maps.Keys(decodedPayload)))++ databaseEntry, isObject := decodedPayload["databases"].([]any)[0].(map[string]any)+ require.True(t, isObject)++ assert.ElementsMatch(t, []string{+ "type",+ "version",+ "backupType",+ "rawSizeMb",+ "backupSizeMb",+ }, slices.Collect(maps.Keys(databaseEntry)))+}++func Test_BuildAndSend_WhenUsersCounted_PopulatesUserCount(t *testing.T) {+ sender := &fakeSender{}+ service := newServiceUnderTest(t, serviceDependencies{+ userCounter: &fakeUserCounter{count: 7},+ sender: sender,+ })+require.NoError(t, service.BuildAndSend(context.Background()))require.Len(t, sender.calls, 1)assert.Equal(t, 7, sender.calls[0].UserCount)@@ -998,18 +1027,10 @@ func Test_BuildAndSend_WhenUserCounterFails_ReturnsError(t *testing.T) {countErr := errors.New("users count exploded")sender := &fakeSender{}- service := newServiceUnderTestWith(- t,- &fakeDatabaseLister{},- &fakeStorageLister{},- &fakeNotifierLister{},- &fakeBackupChecker{},- &fakePhysicalFullBackupSizer{},- &fakeVerificationAgentLister{},- &fakeVerificationConfigLister{},- &fakeUserCounter{err: countErr},- sender,- )+ service := newServiceUnderTest(t, serviceDependencies{+ userCounter: &fakeUserCounter{err: countErr},+ sender: sender,+ })err := service.BuildAndSend(context.Background())require.Error(t, err)