π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
package email
import (
"context"
"errors"
"strings"
"testing"
"github.com/ente/museum/ente"
bonus "github.com/ente/museum/ente/storagebonus"
"github.com/ente/museum/internal/testutil"
"github.com/ente/museum/pkg/repo"
"github.com/ente/museum/pkg/utils/billing"
"github.com/ente/museum/pkg/utils/time"
log "github.com/sirupsen/logrus"
)
type recordingUserAccessResetter struct {
callCount int
callOrder *[]string
err error
}
func (r *recordingUserAccessResetter) ResetUserAccess(_ context.Context, _ int64, _ *log.Entry) error {
r.callCount++
if r.callOrder != nil {
*r.callOrder = append(*r.callOrder, "reset")
}
return r.err
}
func TestBucketStorageWarningWaitsForExpiredWarningAnchor(t *testing.T) {
effectiveExpiry := int64(100)
expiredWarningAnchor := effectiveExpiry + storageWarningExpiredAnchorDelay
now := effectiveExpiry
got := bucketStorageWarning(storageWarningOverageThreshold+1, 0, effectiveExpiry, expiredWarningAnchor, now)
if got != storageWarningBucketNone {
t.Fatalf("unexpected bucket: got %q want %q", got, storageWarningBucketNone)
}
}
func TestBucketStorageWarningExpiredRequiresUsageAboveThreshold(t *testing.T) {
effectiveExpiry := int64(100)
expiredWarningAnchor := int64(100)
now := effectiveExpiry
got := bucketStorageWarning(storageWarningOverageThreshold, 0, effectiveExpiry, expiredWarningAnchor, now)
if got != storageWarningBucketNone {
t.Fatalf("unexpected bucket: got %q want %q", got, storageWarningBucketNone)
}
}
func TestComputeStorageWarningMetricsActiveSubscription(t *testing.T) {
now := int64(100)
subscription := &ente.Subscription{
Storage: 100,
ExpiryTime: now + 1,
PaymentProvider: ente.Stripe,
}
totalUsage := subscription.Storage + storageWarningOverageThreshold + 1
got := computeStorageWarningMetrics(subscription, nil, totalUsage, now)
if got.BaseStorage != subscription.Storage {
t.Fatalf("unexpected base storage: got %d want %d", got.BaseStorage, subscription.Storage)
}
if got.SubscriptionExpiry != subscription.ExpiryTime {
t.Fatalf("unexpected subscription expiry: got %d want %d", got.SubscriptionExpiry, subscription.ExpiryTime)
}
wantEffectiveExpiry := subscription.ExpiryTime + billing.ProviderToExpiryGracePeriodMap[ente.Stripe]
if got.EffectiveExpiry != wantEffectiveExpiry {
t.Fatalf("unexpected effective expiry: got %d want %d", got.EffectiveExpiry, wantEffectiveExpiry)
}
wantExpiredWarningAnchor := subscription.ExpiryTime + storageWarningExpiredAnchorDelay
if got.ExpiredWarningAnchor != wantExpiredWarningAnchor {
t.Fatalf("unexpected expired warning anchor: got %d want %d", got.ExpiredWarningAnchor, wantExpiredWarningAnchor)
}
if got.Bucket != storageWarningBucketActiveOverage {
t.Fatalf("unexpected bucket: got %q want %q", got.Bucket, storageWarningBucketActiveOverage)
}
}
func TestComputeStorageWarningMetricsAddonKeepsAccountActive(t *testing.T) {
now := billing.ProviderToExpiryGracePeriodMap[ente.Stripe] + 1000
subscription := &ente.Subscription{
Storage: 100,
ExpiryTime: now - billing.ProviderToExpiryGracePeriodMap[ente.Stripe] - 1,
PaymentProvider: ente.Stripe,
}
activeBonuses := &bonus.ActiveStorageBonus{
StorageBonuses: []bonus.StorageBonus{
{
Storage: 10,
Type: bonus.AddOnSupport,
ValidTill: now + time.MicroSecondsInOneHour,
},
},
}
totalUsage := int64(10) + storageWarningOverageThreshold + 1
got := computeStorageWarningMetrics(subscription, activeBonuses, totalUsage, now)
if got.BaseStorage != 0 {
t.Fatalf("unexpected base storage for expired subscription: got %d want 0", got.BaseStorage)
}
if got.SubscriptionExpiry != subscription.ExpiryTime {
t.Fatalf("unexpected subscription expiry: got %d want %d", got.SubscriptionExpiry, subscription.ExpiryTime)
}
if got.EffectiveExpiry != now+time.MicroSecondsInOneHour {
t.Fatalf("unexpected effective expiry: got %d want %d", got.EffectiveExpiry, now+time.MicroSecondsInOneHour)
}
wantExpiredWarningAnchor := subscription.ExpiryTime + storageWarningExpiredAnchorDelay
if got.ExpiredWarningAnchor != wantExpiredWarningAnchor {
t.Fatalf("unexpected expired warning anchor: got %d want %d", got.ExpiredWarningAnchor, wantExpiredWarningAnchor)
}
if got.Bucket != storageWarningBucketActiveOverage {
t.Fatalf("unexpected bucket: got %q want %q", got.Bucket, storageWarningBucketActiveOverage)
}
}
func TestComputeStorageWarningMetricsNilSubscriptionDoesNotCrash(t *testing.T) {
now := int64(1000)
activeBonuses := &bonus.ActiveStorageBonus{
StorageBonuses: []bonus.StorageBonus{
{
Storage: 10,
Type: bonus.AddOnSupport,
ValidTill: now + time.MicroSecondsInOneHour,
},
},
}
got := computeStorageWarningMetrics(nil, activeBonuses, int64(10)+storageWarningOverageThreshold+1, now)
if got.BaseStorage != 0 {
t.Fatalf("unexpected base storage without subscription: got %d want 0", got.BaseStorage)
}
if got.SubscriptionExpiry != 0 {
t.Fatalf("unexpected subscription expiry without subscription: got %d want 0", got.SubscriptionExpiry)
}
if got.ExpiredWarningAnchor != 0 {
t.Fatalf("unexpected expired warning anchor without subscription: got %d want 0", got.ExpiredWarningAnchor)
}
if got.Bucket != storageWarningBucketActiveOverage {
t.Fatalf("unexpected bucket: got %q want %q", got.Bucket, storageWarningBucketActiveOverage)
}
}
func TestComputeStorageWarningMetricsFreeSubscriptionCanBeActiveOverage(t *testing.T) {
now := int64(100)
subscription := &ente.Subscription{
Storage: 10 * (1 << 30),
ExpiryTime: now + time.MicroSecondsInOneHour,
PaymentProvider: ente.Stripe,
ProductID: ente.FreePlanProductID,
}
totalUsage := subscription.Storage + storageWarningOverageThreshold + 1
got := computeStorageWarningMetrics(subscription, nil, totalUsage, now)
if got.BaseStorage != subscription.Storage {
t.Fatalf("unexpected base storage: got %d want %d", got.BaseStorage, subscription.Storage)
}
if got.SubscriptionExpiry != subscription.ExpiryTime {
t.Fatalf("unexpected subscription expiry: got %d want %d", got.SubscriptionExpiry, subscription.ExpiryTime)
}
if got.Bucket != storageWarningBucketActiveOverage {
t.Fatalf("unexpected bucket: got %q want %q", got.Bucket, storageWarningBucketActiveOverage)
}
}
func TestResolveExpiredWarningStage(t *testing.T) {
expiredWarningAnchor := int64(100)
tests := []struct {
name string
now int64
history map[string]int64
want expiredWarningStage
}{
{
name: "before first reminder",
now: expiredWarningAnchor - 1,
history: map[string]int64{},
want: expiredWarningStageNone,
},
{
name: "first reminder at anchor day",
now: expiredWarningAnchor,
history: map[string]int64{},
want: expiredWarningStage0,
},
{
name: "second reminder after first sent",
now: expiredWarningAnchor + storageWarningExpiredWarning30Delay,
history: map[string]int64{
storageWarningExpired0TemplateID: expiredWarningAnchor,
},
want: expiredWarningStage30,
},
{
name: "third reminder after earlier stages sent",
now: expiredWarningAnchor + storageWarningExpiredWarning60Delay,
history: map[string]int64{
storageWarningExpired0TemplateID: expiredWarningAnchor,
storageWarningExpired30TemplateID: expiredWarningAnchor + storageWarningExpiredWarning30Delay,
},
want: expiredWarningStage60,
},
{
name: "fourth reminder after earlier stages sent",
now: expiredWarningAnchor + storageWarningExpiredWarning90Delay,
history: map[string]int64{
storageWarningExpired0TemplateID: expiredWarningAnchor,
storageWarningExpired30TemplateID: expiredWarningAnchor + storageWarningExpiredWarning30Delay,
storageWarningExpired60TemplateID: expiredWarningAnchor + storageWarningExpiredWarning60Delay,
},
want: expiredWarningStage90,
},
{
name: "final reminder for long expired user",
now: expiredWarningAnchor + storageWarningExpiredWarning119Delay + 10,
history: map[string]int64{
storageWarningExpired0TemplateID: expiredWarningAnchor,
storageWarningExpired30TemplateID: expiredWarningAnchor + storageWarningExpiredWarning30Delay,
storageWarningExpired60TemplateID: expiredWarningAnchor + storageWarningExpiredWarning60Delay,
storageWarningExpired90TemplateID: expiredWarningAnchor + storageWarningExpiredWarning90Delay,
},
want: expiredWarningStage119,
},
{
name: "scheduled deletion after final reminder sent",
now: expiredWarningAnchor + storageWarningExpiredDeletionDelay,
history: map[string]int64{
storageWarningExpired0TemplateID: expiredWarningAnchor,
storageWarningExpired30TemplateID: expiredWarningAnchor + storageWarningExpiredWarning30Delay,
storageWarningExpired60TemplateID: expiredWarningAnchor + storageWarningExpiredWarning60Delay,
storageWarningExpired90TemplateID: expiredWarningAnchor + storageWarningExpiredWarning90Delay,
storageWarningExpired119TemplateID: expiredWarningAnchor + storageWarningExpiredWarning119Delay,
},
want: expiredWarningStageScheduledDeletion,
},
{
name: "scheduled deletion is sent only once",
now: expiredWarningAnchor + storageWarningExpiredDeletionDelay + 10,
history: map[string]int64{
storageWarningExpired0TemplateID: expiredWarningAnchor,
storageWarningExpired30TemplateID: expiredWarningAnchor + storageWarningExpiredWarning30Delay,
storageWarningExpired60TemplateID: expiredWarningAnchor + storageWarningExpiredWarning60Delay,
storageWarningExpired90TemplateID: expiredWarningAnchor + storageWarningExpiredWarning90Delay,
storageWarningExpired119TemplateID: expiredWarningAnchor + storageWarningExpiredWarning119Delay,
repo.StorageWarningExpiredScheduledDeletionTemplateID: expiredWarningAnchor + storageWarningExpiredDeletionDelay,
},
want: expiredWarningStageNone,
},
{
name: "old cycle reminder ignored after renewal",
now: expiredWarningAnchor,
history: map[string]int64{
storageWarningExpired0TemplateID: expiredWarningAnchor - 1,
},
want: expiredWarningStage0,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
got := resolveExpiredWarningStage(expiredWarningAnchor, tc.now, tc.history)
if got != tc.want {
t.Fatalf("unexpected stage: got %q want %q", got, tc.want)
}
})
}
}
func TestResolveExpiredWarningBufferedCycleProgressesFromPersistedHistory(t *testing.T) {
cycleStart := int64(100)
autoDeleteDate := cycleStart + storageWarningExpiredBackfillMinRecoveryDelay
now := expiredBufferedWarning119At(autoDeleteDate) + 10
history := map[string]int64{
storageWarningExpired0TemplateID: cycleStart,
storageWarningExpired60TemplateID: expiredBufferedWarning60At(cycleStart, autoDeleteDate),
}
got := resolveExpiredBufferedWarningStage(cycleStart, autoDeleteDate, now, history)
if got != expiredWarningStage119 {
t.Fatalf("unexpected buffered stage: got %q want %q", got, expiredWarningStage119)
}
}
func TestExpiredWarningAutoDeleteDateClampsOverdueFinalStage(t *testing.T) {
now := int64(1000)
autoDeleteDate := now - 10
got := expiredWarningAutoDeleteDate(autoDeleteDate, expiredWarningStage119, now)
want := now + storageWarningOneDayInMicroseconds
if got != want {
t.Fatalf("unexpected auto delete date: got %d want %d", got, want)
}
}
func TestResolveActiveOverageWarningStage(t *testing.T) {
now := storageWarningActiveOverageDeletionDelay + (10 * storageWarningOneDayInMicroseconds)
firstWarningTime := now - storageWarningActiveOverageWarning89Delay - 10
tests := []struct {
name string
now int64
history map[string]int64
want activeOverageWarningStage
}{
{
name: "first reminder is immediate when no history exists",
now: now,
history: map[string]int64{},
want: activeOverageWarningStage0,
},
{
name: "30 day reminder after first send",
now: now,
history: map[string]int64{
StorageWarningActiveOverageAnchorTemplateID: now - storageWarningActiveOverageWarning30Delay,
},
want: activeOverageWarningStage30,
},
{
name: "60 day reminder after earlier stage sent",
now: now,
history: map[string]int64{
StorageWarningActiveOverageAnchorTemplateID: now - storageWarningActiveOverageWarning60Delay,
storageWarningActiveOverage30TemplateID: now - storageWarningActiveOverageWarning30Delay,
},
want: activeOverageWarningStage60,
},
{
name: "89 day reminder for long running overusage",
now: now,
history: map[string]int64{
StorageWarningActiveOverageAnchorTemplateID: firstWarningTime,
storageWarningActiveOverage30TemplateID: firstWarningTime + storageWarningActiveOverageWarning30Delay,
storageWarningActiveOverage60TemplateID: firstWarningTime + storageWarningActiveOverageWarning60Delay,
},
want: activeOverageWarningStage89,
},
{
name: "scheduled deletion after final reminder sent",
now: now,
history: map[string]int64{
StorageWarningActiveOverageAnchorTemplateID: now - storageWarningActiveOverageDeletionDelay,
storageWarningActiveOverage30TemplateID: now - storageWarningActiveOverageDeletionDelay + storageWarningActiveOverageWarning30Delay,
storageWarningActiveOverage60TemplateID: now - storageWarningActiveOverageDeletionDelay + storageWarningActiveOverageWarning60Delay,
storageWarningActiveOverage89TemplateID: now - storageWarningActiveOverageDeletionDelay + storageWarningActiveOverageWarning89Delay,
},
want: activeOverageWarningStageScheduledDeletion,
},
{
name: "no reminder when all due stages already sent",
now: now,
history: map[string]int64{
StorageWarningActiveOverageAnchorTemplateID: now - storageWarningActiveOverageWarning30Delay,
storageWarningActiveOverage30TemplateID: now - 1,
},
want: activeOverageWarningStageNone,
},
{
name: "stale anchor restarts at day zero",
now: now,
history: map[string]int64{
StorageWarningActiveOverageAnchorTemplateID: now - storageWarningActiveOverageDeletionDelay,
storageWarningActiveOverage30TemplateID: now - storageWarningActiveOverageDeletionDelay + storageWarningActiveOverageWarning30Delay,
},
want: activeOverageWarningStage0,
},
{
name: "stale final reminder restarts at day zero",
now: now + storageWarningPreviousStageFreshnessWindow + storageWarningOneDayInMicroseconds,
history: map[string]int64{
StorageWarningActiveOverageAnchorTemplateID: now - storageWarningActiveOverageDeletionDelay,
storageWarningActiveOverage30TemplateID: now - storageWarningActiveOverageDeletionDelay + storageWarningActiveOverageWarning30Delay,
storageWarningActiveOverage60TemplateID: now - storageWarningActiveOverageDeletionDelay + storageWarningActiveOverageWarning60Delay,
storageWarningActiveOverage89TemplateID: now - storageWarningActiveOverageDeletionDelay + storageWarningActiveOverageWarning89Delay,
},
want: activeOverageWarningStage0,
},
{
name: "scheduled deletion is sent only once",
now: now,
history: map[string]int64{
StorageWarningActiveOverageAnchorTemplateID: now - storageWarningActiveOverageDeletionDelay,
storageWarningActiveOverage30TemplateID: now - storageWarningActiveOverageDeletionDelay + storageWarningActiveOverageWarning30Delay,
storageWarningActiveOverage60TemplateID: now - storageWarningActiveOverageDeletionDelay + storageWarningActiveOverageWarning60Delay,
storageWarningActiveOverage89TemplateID: now - storageWarningActiveOverageDeletionDelay + storageWarningActiveOverageWarning89Delay,
repo.StorageWarningActiveOverageScheduledDeletionTemplateID: now - 1,
},
want: activeOverageWarningStageNone,
},
{
name: "terminal marker suppresses restart even without anchor history",
now: now,
history: map[string]int64{
repo.StorageWarningActiveOverageScheduledDeletionTemplateID: now - 1,
},
want: activeOverageWarningStageNone,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
got := resolveActiveOverageWarningStage(tc.now, tc.history)
if got != tc.want {
t.Fatalf("unexpected stage: got %q want %q", got, tc.want)
}
})
}
}
func TestActiveOverageWarningAutoDeleteDateClampsOverdueFinalStage(t *testing.T) {
now := storageWarningActiveOverageDeletionDelay + 1000
cycleStart := now - storageWarningActiveOverageDeletionDelay - 10
got := activeOverageWarningAutoDeleteDate(cycleStart, activeOverageWarningStage89, now)
want := now + storageWarningOneDayInMicroseconds
if got != want {
t.Fatalf("unexpected auto delete date: got %d want %d", got, want)
}
}
func TestResolveActiveOverageWarningReturnsCycleStart(t *testing.T) {
now := storageWarningActiveOverageDeletionDelay + storageWarningOneDayInMicroseconds
history := map[string]int64{
StorageWarningActiveOverageAnchorTemplateID: now - storageWarningActiveOverageWarning30Delay,
}
got := resolveActiveOverageWarning(now, history)
if got.Stage != activeOverageWarningStage30 {
t.Fatalf("unexpected stage: got %q want %q", got.Stage, activeOverageWarningStage30)
}
if got.CycleStart != history[StorageWarningActiveOverageAnchorTemplateID] {
t.Fatalf("unexpected cycle start: got %d want %d", got.CycleStart, history[StorageWarningActiveOverageAnchorTemplateID])
}
}
func TestStorageWarningCadenceBroken(t *testing.T) {
now := storageWarningActiveOverageDeletionDelay + (10 * storageWarningOneDayInMicroseconds)
tests := []struct {
name string
snapshot storageWarningSnapshot
wantBroken bool
wantStage string
}{
{
name: "initial stages are exempt",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketActiveOverage,
ActiveOverageStage: activeOverageWarningStage0,
EvaluatedAt: now,
},
wantBroken: false,
},
{
name: "active overage stage 30 requires anchor send",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketActiveOverage,
ActiveOverageStage: activeOverageWarningStage30,
EvaluatedAt: now,
WarningCycleStart: now - storageWarningActiveOverageWarning30Delay,
NotificationHistory: map[string]int64{},
},
wantBroken: true,
wantStage: string(activeOverageWarningStage0),
},
{
name: "active overage previous stage must be recent",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketActiveOverage,
ActiveOverageStage: activeOverageWarningStage60,
EvaluatedAt: now,
WarningCycleStart: now - storageWarningActiveOverageWarning60Delay,
NotificationHistory: map[string]int64{
StorageWarningActiveOverageAnchorTemplateID: now - storageWarningActiveOverageWarning60Delay,
storageWarningActiveOverage30TemplateID: now - storageWarningPreviousStageFreshnessWindow - 1,
},
},
wantBroken: true,
wantStage: string(activeOverageWarningStage30),
},
{
name: "expired previous stage from prior cycle is ignored",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage30,
EvaluatedAt: now,
EffectiveExpiry: now - storageWarningExpiredWarning30Delay,
WarningCycleStart: now - storageWarningExpiredWarning30Delay,
NotificationHistory: map[string]int64{
storageWarningExpired0TemplateID: now - storageWarningExpiredWarning30Delay - 1,
},
},
wantBroken: true,
wantStage: string(expiredWarningStage0),
},
{
name: "same cycle recent previous stage passes",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage60,
EvaluatedAt: now,
EffectiveExpiry: now - storageWarningExpiredWarning60Delay,
WarningCycleStart: now - storageWarningExpiredWarning60Delay,
NotificationHistory: map[string]int64{
storageWarningExpired30TemplateID: now - storageWarningOneDayInMicroseconds,
},
},
wantBroken: false,
},
{
name: "terminal expired stage requires final reminder",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStageScheduledDeletion,
EvaluatedAt: now,
WarningCycleStart: now - storageWarningExpiredDeletionDelay,
NotificationHistory: map[string]int64{
storageWarningExpired90TemplateID: now - storageWarningOneDayInMicroseconds,
},
},
wantBroken: true,
wantStage: string(expiredWarningStage119),
},
{
name: "expired final reminder requires prior 90-day stage",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage119,
EvaluatedAt: now,
WarningCycleStart: now - storageWarningExpiredWarning119Delay,
NotificationHistory: map[string]int64{},
},
wantBroken: true,
wantStage: string(expiredWarningStage90),
},
{
name: "expired final reminder passes when prior 90-day stage exists in overdue cycle",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage119,
EvaluatedAt: now,
WarningCycleStart: now - storageWarningExpiredWarning119Delay,
NotificationHistory: map[string]int64{
storageWarningExpired90TemplateID: now - storageWarningOneDayInMicroseconds,
},
},
wantBroken: false,
},
{
name: "buffered expired stage 60 requires initial expired notice",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage60,
ExpiredBufferedCycle: true,
EvaluatedAt: now,
WarningCycleStart: now - (storageWarningExpiredBackfillMinRecoveryDelay / 2),
NotificationHistory: map[string]int64{},
},
wantBroken: true,
wantStage: string(expiredWarningStage0),
},
{
name: "buffered expired final reminder uses the buffered midpoint stage",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage119,
ExpiredBufferedCycle: true,
EvaluatedAt: now,
WarningCycleStart: now - storageWarningExpiredBackfillMinRecoveryDelay + storageWarningOneDayInMicroseconds,
NotificationHistory: map[string]int64{
storageWarningExpired60TemplateID: now - storageWarningOneDayInMicroseconds,
},
},
wantBroken: false,
},
{
name: "buffered expired stage 60 allows predecessor older than default window",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage60,
ExpiredBufferedCycle: true,
EvaluatedAt: 148 * storageWarningOneDayInMicroseconds,
WarningCycleStart: 65 * storageWarningOneDayInMicroseconds,
AutoDeleteDate: 150 * storageWarningOneDayInMicroseconds,
NotificationHistory: map[string]int64{
storageWarningExpired0TemplateID: 107 * storageWarningOneDayInMicroseconds,
},
},
wantBroken: false,
},
{
name: "buffered expired stage 60 tolerates a two-day outage beyond midpoint",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage60,
ExpiredBufferedCycle: true,
EvaluatedAt: 150 * storageWarningOneDayInMicroseconds,
WarningCycleStart: 65 * storageWarningOneDayInMicroseconds,
AutoDeleteDate: 150 * storageWarningOneDayInMicroseconds,
NotificationHistory: map[string]int64{
storageWarningExpired0TemplateID: 105 * storageWarningOneDayInMicroseconds,
},
},
wantBroken: false,
},
{
name: "buffered expired final reminder allows predecessor older than default window",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage119,
ExpiredBufferedCycle: true,
EvaluatedAt: 150 * storageWarningOneDayInMicroseconds,
WarningCycleStart: 65 * storageWarningOneDayInMicroseconds,
AutoDeleteDate: 150 * storageWarningOneDayInMicroseconds,
NotificationHistory: map[string]int64{
storageWarningExpired60TemplateID: 108 * storageWarningOneDayInMicroseconds,
},
},
wantBroken: false,
},
{
name: "buffered expired final reminder tolerates a two-day outage beyond final reminder threshold",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage119,
ExpiredBufferedCycle: true,
EvaluatedAt: 152 * storageWarningOneDayInMicroseconds,
WarningCycleStart: 65 * storageWarningOneDayInMicroseconds,
AutoDeleteDate: 150 * storageWarningOneDayInMicroseconds,
NotificationHistory: map[string]int64{
storageWarningExpired60TemplateID: 108 * storageWarningOneDayInMicroseconds,
},
},
wantBroken: false,
},
{
name: "buffered expired stage 60 still breaks once predecessor is too stale after extra grace",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage60,
ExpiredBufferedCycle: true,
EvaluatedAt: 151 * storageWarningOneDayInMicroseconds,
WarningCycleStart: 65 * storageWarningOneDayInMicroseconds,
AutoDeleteDate: 150 * storageWarningOneDayInMicroseconds,
NotificationHistory: map[string]int64{
storageWarningExpired0TemplateID: 105 * storageWarningOneDayInMicroseconds,
},
},
wantBroken: true,
wantStage: string(expiredWarningStage0),
},
{
name: "buffered expired final reminder still breaks once predecessor is too stale after extra grace",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStage119,
ExpiredBufferedCycle: true,
EvaluatedAt: 153 * storageWarningOneDayInMicroseconds,
WarningCycleStart: 65 * storageWarningOneDayInMicroseconds,
AutoDeleteDate: 150 * storageWarningOneDayInMicroseconds,
NotificationHistory: map[string]int64{
storageWarningExpired60TemplateID: 108 * storageWarningOneDayInMicroseconds,
},
},
wantBroken: true,
wantStage: string(expiredWarningStage60),
},
{
name: "terminal active overage stage requires final reminder",
snapshot: storageWarningSnapshot{
Bucket: storageWarningBucketActiveOverage,
ActiveOverageStage: activeOverageWarningStageScheduledDeletion,
EvaluatedAt: now,
WarningCycleStart: now - storageWarningActiveOverageDeletionDelay,
NotificationHistory: map[string]int64{
storageWarningActiveOverage60TemplateID: now - storageWarningOneDayInMicroseconds,
},
},
wantBroken: true,
wantStage: string(activeOverageWarningStage89),
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
broken, alert := storageWarningCadenceBroken(tc.snapshot)
if broken != tc.wantBroken {
t.Fatalf("unexpected cadence result: got %v want %v", broken, tc.wantBroken)
}
if tc.wantBroken && !strings.Contains(alert, "previous_required_stage="+tc.wantStage) {
t.Fatalf("expected alert to include previous stage %q, got %q", tc.wantStage, alert)
}
})
}
}
func TestMergeStorageWarningCandidatesDeduplicatesAndKeepsFamilyPlan(t *testing.T) {
candidates := mergeStorageWarningCandidates(
[]repo.StorageWarningCandidate{
{RecipientID: 1, IsFamilyPlan: false},
{RecipientID: 2, IsFamilyPlan: true},
},
[]repo.StorageWarningCandidate{
{RecipientID: 1, IsFamilyPlan: true},
{RecipientID: 3, IsFamilyPlan: false},
},
)
if len(candidates) != 3 {
t.Fatalf("expected 3 merged candidates, got %d", len(candidates))
}
if candidates[0].RecipientID != 1 || !candidates[0].IsFamilyPlan {
t.Fatalf("unexpected first candidate: %+v", candidates[0])
}
if candidates[1].RecipientID != 2 || !candidates[1].IsFamilyPlan {
t.Fatalf("unexpected second candidate: %+v", candidates[1])
}
if candidates[2].RecipientID != 3 || candidates[2].IsFamilyPlan {
t.Fatalf("unexpected third candidate: %+v", candidates[2])
}
}
func TestStorageWarningShouldPreserveActiveOverageHistory(t *testing.T) {
if !storageWarningShouldPreserveActiveOverageHistory(storageWarningSnapshot{CurrentBucket: storageWarningBucketActiveOverage, Bucket: storageWarningBucketNone}) {
t.Fatal("expected active overage history to be preserved even when no stage is due")
}
if storageWarningShouldPreserveActiveOverageHistory(storageWarningSnapshot{
CurrentBucket: storageWarningBucketActiveOverage,
WarningCycleStart: 100,
NotificationHistory: map[string]int64{repo.StorageWarningActiveOverageScheduledDeletionTemplateID: 100},
}) {
t.Fatal("expected active overage history to be dropped after scheduled deletion")
}
if storageWarningShouldPreserveActiveOverageHistory(storageWarningSnapshot{CurrentBucket: storageWarningBucketExpired}) {
t.Fatal("expected expired snapshot to not preserve active overage history")
}
}
func TestProcessStorageWarningSnapshotScheduledDeletionSkipsResetWhenEmailFails(t *testing.T) {
originalSendStorageWarningTemplatedEmail := sendStorageWarningTemplatedEmail
originalPersistStorageWarningHistory := persistStorageWarningHistory
defer func() {
sendStorageWarningTemplatedEmail = originalSendStorageWarningTemplatedEmail
persistStorageWarningHistory = originalPersistStorageWarningHistory
}()
sendStorageWarningTemplatedEmail = func(_ []string, _ string, _ string, _ string, _ string, _ string, _ map[string]interface{}, _ []map[string]interface{}) error {
return errors.New("boom")
}
persistStorageWarningHistory = func(_ *repo.NotificationHistoryRepository, _ storageWarningSnapshot, _ string) error {
t.Fatal("did not expect history persistence when email send fails")
return nil
}
resetter := &recordingUserAccessResetter{}
snapshot := storageWarningSnapshot{
RecipientID: 12345,
AccountEmail: "[email protected]",
TotalUsage: storageWarningOverageThreshold + 10,
AllottedStorage: 0,
AvailableStorage: -10,
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStageScheduledDeletion,
EffectiveExpiry: 1,
NotificationHistory: map[string]int64{
storageWarningExpired119TemplateID: 1,
},
}
result, err := (&EmailNotificationController{UserAccessResetter: resetter}).processStorageWarningSnapshot(t.Context(), snapshot)
if err == nil {
t.Fatal("expected email failure to be returned")
}
if result != storageWarningProcessResultSkipped {
t.Fatalf("unexpected result: got %q want %q", result, storageWarningProcessResultSkipped)
}
if resetter.callCount != 0 {
t.Fatalf("expected no access reset when email send fails, got %d resets", resetter.callCount)
}
}
func TestProcessStorageWarningSnapshotScheduledDeletionResetsAccessAfterEmail(t *testing.T) {
originalSendStorageWarningTemplatedEmail := sendStorageWarningTemplatedEmail
originalPersistStorageWarningHistory := persistStorageWarningHistory
defer func() {
sendStorageWarningTemplatedEmail = originalSendStorageWarningTemplatedEmail
persistStorageWarningHistory = originalPersistStorageWarningHistory
}()
callOrder := []string{}
sendStorageWarningTemplatedEmail = func(_ []string, _ string, _ string, _ string, _ string, _ string, _ map[string]interface{}, _ []map[string]interface{}) error {
callOrder = append(callOrder, "send")
return nil
}
persistStorageWarningHistory = func(_ *repo.NotificationHistoryRepository, _ storageWarningSnapshot, _ string) error {
callOrder = append(callOrder, "persist")
return nil
}
resetter := &recordingUserAccessResetter{callOrder: &callOrder}
snapshot := storageWarningSnapshot{
RecipientID: 12345,
AccountEmail: "[email protected]",
TotalUsage: storageWarningOverageThreshold + 10,
AllottedStorage: 0,
AvailableStorage: -10,
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStageScheduledDeletion,
EffectiveExpiry: 1,
NotificationHistory: map[string]int64{
storageWarningExpired119TemplateID: 1,
},
}
result, err := (&EmailNotificationController{UserAccessResetter: resetter}).processStorageWarningSnapshot(t.Context(), snapshot)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if result != storageWarningProcessResultSent {
t.Fatalf("unexpected result: got %q want %q", result, storageWarningProcessResultSent)
}
if resetter.callCount != 1 {
t.Fatalf("expected one access reset after successful email, got %d", resetter.callCount)
}
if got, want := strings.Join(callOrder, ","), "send,reset,persist"; got != want {
t.Fatalf("unexpected call order: got %q want %q", got, want)
}
}
func TestProcessStorageWarningSnapshotScheduledDeletionSkipsDuringActiveLoginGrace(t *testing.T) {
originalSendStorageWarningTemplatedEmail := sendStorageWarningTemplatedEmail
originalPersistStorageWarningHistory := persistStorageWarningHistory
defer func() {
sendStorageWarningTemplatedEmail = originalSendStorageWarningTemplatedEmail
persistStorageWarningHistory = originalPersistStorageWarningHistory
}()
sendStorageWarningTemplatedEmail = func(_ []string, _ string, _ string, _ string, _ string, _ string, _ map[string]interface{}, _ []map[string]interface{}) error {
t.Fatal("did not expect email send during active login grace")
return nil
}
persistStorageWarningHistory = func(_ *repo.NotificationHistoryRepository, _ storageWarningSnapshot, _ string) error {
t.Fatal("did not expect history persistence during active login grace")
return nil
}
now := int64(10) * storageWarningOneDayInMicroseconds
graceSentAt := now - storageWarningOneDayInMicroseconds
resetter := &recordingUserAccessResetter{}
snapshot := storageWarningSnapshot{
RecipientID: 12345,
AccountEmail: "[email protected]",
TotalUsage: storageWarningOverageThreshold + 10,
AllottedStorage: 0,
AvailableStorage: -10,
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStageScheduledDeletion,
EffectiveExpiry: 1,
EvaluatedAt: now,
WarningCycleStart: graceSentAt - storageWarningOneDayInMicroseconds,
NotificationHistory: map[string]int64{
storageWarningExpired119TemplateID: graceSentAt - storageWarningOneDayInMicroseconds,
repo.StorageWarningLoginGraceTemplateID: graceSentAt,
},
}
result, err := (&EmailNotificationController{UserAccessResetter: resetter}).processStorageWarningSnapshot(t.Context(), snapshot)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if result != storageWarningProcessResultSkipped {
t.Fatalf("unexpected result: got %q want %q", result, storageWarningProcessResultSkipped)
}
if resetter.callCount != 0 {
t.Fatalf("expected no access reset during active login grace, got %d resets", resetter.callCount)
}
}
func TestProcessStorageWarningSnapshotSkipsActiveOverageRestartDuringActiveLoginGrace(t *testing.T) {
originalSendStorageWarningTemplatedEmail := sendStorageWarningTemplatedEmail
originalPersistStorageWarningHistory := persistStorageWarningHistory
defer func() {
sendStorageWarningTemplatedEmail = originalSendStorageWarningTemplatedEmail
persistStorageWarningHistory = originalPersistStorageWarningHistory
}()
sendStorageWarningTemplatedEmail = func(_ []string, _ string, _ string, _ string, _ string, _ string, _ map[string]interface{}, _ []map[string]interface{}) error {
t.Fatal("did not expect warning email during active login grace")
return nil
}
persistStorageWarningHistory = func(_ *repo.NotificationHistoryRepository, _ storageWarningSnapshot, _ string) error {
t.Fatal("did not expect history persistence during active login grace")
return nil
}
now := int64(10) * storageWarningOneDayInMicroseconds
graceSentAt := now - storageWarningOneDayInMicroseconds
resetter := &recordingUserAccessResetter{}
snapshot := storageWarningSnapshot{
RecipientID: 12345,
AccountEmail: "[email protected]",
TotalUsage: storageWarningOverageThreshold + 10,
AllottedStorage: 0,
AvailableStorage: -10,
Bucket: storageWarningBucketActiveOverage,
ActiveOverageStage: activeOverageWarningStage0,
EvaluatedAt: now,
WarningCycleStart: now,
NotificationHistory: map[string]int64{repo.StorageWarningLoginGraceTemplateID: graceSentAt},
}
result, err := (&EmailNotificationController{UserAccessResetter: resetter}).processStorageWarningSnapshot(t.Context(), snapshot)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if result != storageWarningProcessResultSkipped {
t.Fatalf("unexpected result: got %q want %q", result, storageWarningProcessResultSkipped)
}
if resetter.callCount != 0 {
t.Fatalf("expected no access reset during active login grace, got %d resets", resetter.callCount)
}
}
func TestProcessStorageWarningSnapshotScheduledDeletionAllowsExpiredLoginGraceDespiteStaleCadence(t *testing.T) {
originalSendStorageWarningTemplatedEmail := sendStorageWarningTemplatedEmail
originalPersistStorageWarningHistory := persistStorageWarningHistory
defer func() {
sendStorageWarningTemplatedEmail = originalSendStorageWarningTemplatedEmail
persistStorageWarningHistory = originalPersistStorageWarningHistory
}()
callOrder := []string{}
sendStorageWarningTemplatedEmail = func(_ []string, _ string, _ string, _ string, _ string, _ string, _ map[string]interface{}, _ []map[string]interface{}) error {
callOrder = append(callOrder, "send")
return nil
}
persistStorageWarningHistory = func(_ *repo.NotificationHistoryRepository, _ storageWarningSnapshot, _ string) error {
callOrder = append(callOrder, "persist")
return nil
}
graceSentAt := int64(40) * storageWarningOneDayInMicroseconds
now := graceSentAt + repo.StorageWarningLoginGraceDurationMicroseconds + 1
resetter := &recordingUserAccessResetter{callOrder: &callOrder}
snapshot := storageWarningSnapshot{
RecipientID: 12345,
AccountEmail: "[email protected]",
TotalUsage: storageWarningOverageThreshold + 10,
AllottedStorage: 0,
AvailableStorage: -10,
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStageScheduledDeletion,
EffectiveExpiry: 1,
EvaluatedAt: now,
WarningCycleStart: 1,
NotificationHistory: map[string]int64{
storageWarningExpired119TemplateID: 1,
repo.StorageWarningLoginGraceTemplateID: graceSentAt,
},
}
result, err := (&EmailNotificationController{UserAccessResetter: resetter}).processStorageWarningSnapshot(t.Context(), snapshot)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if result != storageWarningProcessResultSent {
t.Fatalf("unexpected result: got %q want %q", result, storageWarningProcessResultSent)
}
if resetter.callCount != 1 {
t.Fatalf("expected one access reset after login grace expiry, got %d", resetter.callCount)
}
if got, want := strings.Join(callOrder, ","), "send,reset,persist"; got != want {
t.Fatalf("unexpected call order: got %q want %q", got, want)
}
}
func TestProcessStorageWarningSnapshotExpiredLoginGraceReblocksActiveOverageRestart(t *testing.T) {
originalSendStorageWarningTemplatedEmail := sendStorageWarningTemplatedEmail
originalPersistStorageWarningHistory := persistStorageWarningHistory
defer func() {
sendStorageWarningTemplatedEmail = originalSendStorageWarningTemplatedEmail
persistStorageWarningHistory = originalPersistStorageWarningHistory
}()
callOrder := []string{}
sendStorageWarningTemplatedEmail = func(_ []string, _ string, _ string, _ string, _ string, templateName string, _ map[string]interface{}, _ []map[string]interface{}) error {
callOrder = append(callOrder, "send")
if templateName != storageWarningActiveOverageScheduledDeletionTemplate {
t.Fatalf("unexpected template: got %q want %q", templateName, storageWarningActiveOverageScheduledDeletionTemplate)
}
return nil
}
var persistedTemplateID string
persistStorageWarningHistory = func(_ *repo.NotificationHistoryRepository, _ storageWarningSnapshot, templateID string) error {
callOrder = append(callOrder, "persist")
persistedTemplateID = templateID
return nil
}
graceSentAt := int64(40) * storageWarningOneDayInMicroseconds
now := graceSentAt + repo.StorageWarningLoginGraceDurationMicroseconds + 1
resetter := &recordingUserAccessResetter{callOrder: &callOrder}
snapshot := storageWarningSnapshot{
RecipientID: 12345,
AccountEmail: "[email protected]",
TotalUsage: storageWarningOverageThreshold + 10,
AllottedStorage: 0,
AvailableStorage: -10,
Bucket: storageWarningBucketActiveOverage,
ActiveOverageStage: activeOverageWarningStage0,
EvaluatedAt: now,
WarningCycleStart: now,
NotificationHistory: map[string]int64{repo.StorageWarningLoginGraceTemplateID: graceSentAt},
}
result, err := (&EmailNotificationController{UserAccessResetter: resetter}).processStorageWarningSnapshot(t.Context(), snapshot)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if result != storageWarningProcessResultSent {
t.Fatalf("unexpected result: got %q want %q", result, storageWarningProcessResultSent)
}
if resetter.callCount != 1 {
t.Fatalf("expected one access reset after login grace expiry, got %d", resetter.callCount)
}
if persistedTemplateID != repo.StorageWarningActiveOverageScheduledDeletionTemplateID {
t.Fatalf("unexpected persisted template: got %q want %q", persistedTemplateID, repo.StorageWarningActiveOverageScheduledDeletionTemplateID)
}
if got, want := strings.Join(callOrder, ","), "send,reset,persist"; got != want {
t.Fatalf("unexpected call order: got %q want %q", got, want)
}
}
func TestProcessStorageWarningSnapshotClearsLoginGraceAfterRecovery(t *testing.T) {
db := testutil.RequireTestDB(t)
testutil.ResetTables(t, db)
t.Cleanup(func() {
testutil.ResetTables(t, db)
})
const userID int64 = 12348
testutil.InsertUser(t, db, testutil.UserFixture{
UserID: userID,
Email: "[email protected]",
CreationTime: 1,
})
graceSentAt := int64(40) * storageWarningOneDayInMicroseconds
testutil.InsertNotificationHistory(t, db, testutil.NotificationHistoryFixture{
UserID: userID,
TemplateID: repo.StorageWarningLoginGraceTemplateID,
SentTime: graceSentAt,
})
testutil.InsertNotificationHistory(t, db, testutil.NotificationHistoryFixture{
UserID: userID,
TemplateID: repo.StorageWarningExpiredScheduledDeletionTemplateID,
SentTime: graceSentAt + 1,
})
notificationHistoryRepo := &repo.NotificationHistoryRepository{DB: db}
result, err := (&EmailNotificationController{
NotificationHistoryRepo: notificationHistoryRepo,
}).processStorageWarningSnapshot(t.Context(), storageWarningSnapshot{
RecipientID: userID,
Bucket: storageWarningBucketNone,
EvaluatedAt: graceSentAt + storageWarningOneDayInMicroseconds,
NotificationHistory: map[string]int64{
repo.StorageWarningLoginGraceTemplateID: graceSentAt,
},
})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if result != storageWarningProcessResultSkipped {
t.Fatalf("unexpected result: got %q want %q", result, storageWarningProcessResultSkipped)
}
graceSentAfterClear, err := notificationHistoryRepo.GetLastNotificationTime(userID, repo.StorageWarningLoginGraceTemplateID)
if err != nil {
t.Fatalf("failed to fetch login grace after recovery: %v", err)
}
if graceSentAfterClear != 0 {
t.Fatalf("expected login grace to be cleared after recovery, got sent_time %d", graceSentAfterClear)
}
terminalRowExists, err := notificationHistoryRepo.IsStorageWarningDeletionScheduled(userID)
if err != nil {
t.Fatalf("failed to fetch terminal row after recovery: %v", err)
}
if terminalRowExists {
t.Fatal("expected stale terminal row to be cleared after recovery")
}
}
func TestStorageWarningHistoryGroup(t *testing.T) {
if got := storageWarningHistoryGroup(storageWarningSnapshot{
Bucket: storageWarningBucketActiveOverage,
ActiveOverageStage: activeOverageWarningStage60,
}); got != storageWarningActiveOverageNotificationGroup {
t.Fatalf("unexpected active overage history group: got %q want %q", got, storageWarningActiveOverageNotificationGroup)
}
if got := storageWarningHistoryGroup(storageWarningSnapshot{
Bucket: storageWarningBucketExpired,
ExpiredStage: expiredWarningStageScheduledDeletion,
}); got != "" {
t.Fatalf("unexpected terminal history group: got %q want empty", got)
}
}