package content import ( "bytes" "context" "database/sql" "errors" "fmt" "os" "path/filepath" "sort" "strings" "testing" "time" "mediarr/database" "mediarr/document" "mediarr/ident" "mediarr/permission" "mediarr/storage" ) func TestSetHeadVersionAndPurge(t *testing.T) { env := newTestEnv(t, allowAll()) ctx := context.Background() first := createTestVersion(t, env, env.videoID, "un") second := createTestVersion(t, env, env.videoID, "deux") if _, err := env.service.SetHeadVersion(ctx, env.owner.ID, env.videoID, first.ID); err != nil { t.Fatalf("SetHeadVersion : %v", err) } documentRow, err := env.db.Queries.GetDocument(ctx, env.videoID) if err != nil { t.Fatalf("GetDocument : %v", err) } if documentRow.HeadVersionID == nil || *documentRow.HeadVersionID != first.ID { t.Fatalf("head_version_id = %v, attendu %s", documentRow.HeadVersionID, first.ID) } rev := documentRow.Rev if _, err := env.service.SetHeadVersion(ctx, env.owner.ID, env.videoID, first.ID); err != nil { t.Fatalf("SetHeadVersion(idempotent) : %v", err) } documentRow, err = env.db.Queries.GetDocument(ctx, env.videoID) if err != nil { t.Fatalf("GetDocument : %v", err) } if documentRow.Rev != rev { t.Fatalf("rev = %d, attendu %d", documentRow.Rev, rev) } otherVideoID := createVideo(t, env.db, env.owner, env.library, "autre.mkv") otherVersion := createTestVersion(t, env, otherVideoID, "autre") if _, err := env.service.SetHeadVersion(ctx, env.owner.ID, env.videoID, otherVersion.ID); !errors.Is(err, ErrVersionMismatch) { t.Fatalf("SetHeadVersion(mauvais document) : erreur = %v, attendu ErrVersionMismatch", err) } if err := env.service.PurgeVersion(ctx, env.owner.ID, second.ID); err != nil { t.Fatalf("PurgeVersion : %v", err) } if err := env.service.PurgeVersion(ctx, env.owner.ID, second.ID); err != nil { t.Fatalf("PurgeVersion(idempotent) : %v", err) } if _, err := env.service.SetHeadVersion(ctx, env.owner.ID, env.videoID, second.ID); !errors.Is(err, ErrContentPurged) { t.Fatalf("SetHeadVersion(purgée) : erreur = %v, attendu ErrContentPurged", err) } if err := env.service.PurgeVersion(ctx, env.owner.ID, first.ID); !errors.Is(err, ErrVersionIsHead) { t.Fatalf("PurgeVersion(tête) : erreur = %v, attendu ErrVersionIsHead", err) } readOnly := NewService(*env.db, env.store, testBackendID, &testAuthorizer{allowed: permission.Read}) if _, err := readOnly.SetHeadVersion(ctx, env.owner.ID, env.videoID, first.ID); !errors.Is(err, document.ErrPermissionDenied) { t.Fatalf("SetHeadVersion sans Write : erreur = %v, attendu ErrPermissionDenied", err) } if err := readOnly.PurgeVersion(ctx, env.owner.ID, second.ID); !errors.Is(err, document.ErrPermissionDenied) { t.Fatalf("PurgeVersion sans Delete : erreur = %v, attendu ErrPermissionDenied", err) } } func TestRetentionPurgeIDs(t *testing.T) { now := time.Date(2026, 1, 31, 12, 0, 0, 0, time.UTC).UnixMilli() at := func(days int) int64 { return now - int64(days)*dayMillis } headID := ident.MustParse("00000000-0000-7000-8000-000000000001") versions := []database.DocumentVersion{ retentionVersion(t, 1, at(1000), 0, false), retentionVersion(t, 2, at(1000), 1, false), retentionVersion(t, 3, at(10), 0, false), retentionVersion(t, 4, at(40), 0, false), retentionVersion(t, 5, at(40)-60*60*1000, 0, false), retentionVersion(t, 6, at(41), 0, false), retentionVersion(t, 7, at(100), 0, false), retentionVersion(t, 8, at(110), 0, false), retentionVersion(t, 9, at(200), 0, false), retentionVersion(t, 10, at(300), 0, false), retentionVersion(t, 11, at(400), 0, false), retentionVersion(t, 12, at(10), 0, true), } sort.Slice(versions, func(i, j int) bool { return versions[i].CreatedAt > versions[j].CreatedAt }) purged := retentionPurgeIDs(versions, &headID, retentionPolicy{ KeepAllDays: 30, KeepDailyDays: 60, KeepMonthly: 2, }, now) expected := map[ident.UUID]bool{ ident.MustParse("00000000-0000-7000-8000-000000000005"): true, ident.MustParse("00000000-0000-7000-8000-000000000008"): true, ident.MustParse("00000000-0000-7000-8000-000000000010"): true, ident.MustParse("00000000-0000-7000-8000-000000000011"): true, } if len(purged) != len(expected) { t.Fatalf("versions purgées = %v, attendu %v", purged, expected) } for _, versionID := range purged { if !expected[versionID] { t.Fatalf("version purgée inattendue : %s", versionID) } } } func TestApplyRetention(t *testing.T) { env := newTestEnv(t, allowAll()) ctx := context.Background() if _, err := env.db.WriteDB.ExecContext(ctx, "UPDATE storage_policy SET version_retention = ? WHERE id = ?", `{"keep_all_days":30,"keep_daily_days":0,"keep_monthly":0}`, testPolicyID, ); err != nil { t.Fatalf("UPDATE storage_policy : %v", err) } first := createTestVersion(t, env, env.videoID, "un") second := createTestVersion(t, env, env.videoID, "deux") head := createTestVersion(t, env, env.videoID, "trois") now := time.Now().UnixMilli() setVersionCreatedAt(t, env, first.ID, now-100*dayMillis) setVersionCreatedAt(t, env, second.ID, now-40*dayMillis) setVersionCreatedAt(t, env, head.ID, now) result, err := env.service.ApplyRetention(ctx, env.owner.ID, env.videoID) if err != nil { t.Fatalf("ApplyRetention : %v", err) } if len(result.Purged) != 2 || result.Kept != 1 { t.Fatalf("résultat = %+v, attendu 2 purgées et 1 conservée", result) } firstRow, _ := env.db.Queries.GetDocumentVersion(ctx, first.ID) secondRow, _ := env.db.Queries.GetDocumentVersion(ctx, second.ID) headRow, _ := env.db.Queries.GetDocumentVersion(ctx, head.ID) if !firstRow.ContentPurgedAt.Valid || !secondRow.ContentPurgedAt.Valid { t.Fatalf("versions anciennes non purgées : %+v %+v", firstRow, secondRow) } if headRow.ContentPurgedAt.Valid { t.Fatalf("version tête purgée : %+v", headRow) } again, err := env.service.ApplyRetention(ctx, env.owner.ID, env.videoID) if err != nil { t.Fatalf("ApplyRetention(idempotent) : %v", err) } if len(again.Purged) != 0 || again.Kept != 3 { t.Fatalf("second résultat = %+v, attendu 0 purgée et 3 conservées", again) } adminDenied := NewService(*env.db, env.store, testBackendID, &testAuthorizer{allowed: permission.Write}) if _, err := adminDenied.ApplyRetention(ctx, env.owner.ID, env.videoID); !errors.Is(err, document.ErrPermissionDenied) { t.Fatalf("ApplyRetention sans Admin : erreur = %v, attendu ErrPermissionDenied", err) } if _, err := env.db.WriteDB.ExecContext(ctx, "UPDATE storage_policy SET version_retention = ? WHERE id = ?", `{"keep_all_days":-1}`, testPolicyID, ); err != nil { t.Fatalf("UPDATE storage_policy(invalide) : %v", err) } if _, err := env.service.ApplyRetention(ctx, env.owner.ID, env.videoID); !errors.Is(err, ErrInvalidRetention) { t.Fatalf("ApplyRetention(politique invalide) : erreur = %v, attendu ErrInvalidRetention", err) } } func TestCollectGarbage(t *testing.T) { env := newTestEnv(t, allowAll()) ctx := context.Background() purged := createTestVersion(t, env, env.videoID, "un") kept := createTestVersion(t, env, env.videoID, "deux") location, err := env.db.Queries.GetBlobLocation(ctx, database.GetBlobLocationParams{ Root: purged.ContentRoot, BackendID: testBackendID, }) if err != nil { t.Fatalf("GetBlobLocation : %v", err) } if err := env.service.PurgeVersion(ctx, env.owner.ID, purged.ID); err != nil { t.Fatalf("PurgeVersion : %v", err) } result, err := env.service.CollectGarbage(ctx) if err != nil { t.Fatalf("CollectGarbage : %v", err) } if result.Blobs != 1 || result.Locations != 1 || result.Bytes != purged.Size { t.Fatalf("résultat = %+v", result) } if _, err := env.db.Queries.GetBlob(ctx, purged.ContentRoot); !errors.Is(err, sql.ErrNoRows) { t.Fatalf("blob purgé encore présent : %v", err) } if _, err := env.db.Queries.GetBlob(ctx, kept.ContentRoot); err != nil { t.Fatalf("blob conservé : %v", err) } if _, err := env.store.Open(ctx, location.Locator); !errors.Is(err, storage.ErrNotFound) { t.Fatalf("fichier purgé encore présent : %v", err) } withoutStore := NewService(*env.db, nil, testBackendID, allowAll()) if _, err := withoutStore.CollectGarbage(ctx); !errors.Is(err, ErrStorageNotConfigured) { t.Fatalf("CollectGarbage sans stockage : erreur = %v, attendu ErrStorageNotConfigured", err) } } func TestVerifyVersion(t *testing.T) { env := newTestEnv(t, allowAll()) ctx := context.Background() version := createTestVersion(t, env, env.videoID, "contenu vérifié") if err := env.service.VerifyVersion(ctx, env.owner.ID, version.ID); err != nil { t.Fatalf("VerifyVersion : %v", err) } blob, err := env.db.Queries.GetBlob(ctx, version.ContentRoot) if err != nil { t.Fatalf("GetBlob : %v", err) } if blob.State != BlobStatePresent || !blob.LastVerifiedAt.Valid { t.Fatalf("blob = %+v", blob) } location, err := env.db.Queries.GetBlobLocation(ctx, database.GetBlobLocationParams{ Root: version.ContentRoot, BackendID: testBackendID, }) if err != nil { t.Fatalf("GetBlobLocation : %v", err) } path := filepath.Join("store", filepath.FromSlash(location.Locator)) if err := os.WriteFile(path, []byte("corrompu"), 0o640); err != nil { t.Fatalf("WriteFile : %v", err) } if err := env.service.VerifyVersion(ctx, env.owner.ID, version.ID); !errors.Is(err, ErrBlobCorrupt) { t.Fatalf("VerifyVersion(corrompu) : erreur = %v, attendu ErrBlobCorrupt", err) } blob, err = env.db.Queries.GetBlob(ctx, version.ContentRoot) if err != nil { t.Fatalf("GetBlob(corrompu) : %v", err) } if blob.State != BlobStateCorrupt || !blob.VerifyError.Valid { t.Fatalf("blob corrompu = %+v", blob) } if _, _, err := env.service.OpenVersion(ctx, env.owner.ID, version.ID); !errors.Is(err, ErrContentUnavailable) { t.Fatalf("OpenVersion(corrompu) : erreur = %v, attendu ErrContentUnavailable", err) } healed, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{ Source: strings.NewReader("contenu vérifié"), Mime: "video/mp4", }) if err != nil { t.Fatalf("CreateVersion(réparation) : %v", err) } if !bytes.Equal(healed.ContentRoot, version.ContentRoot) { t.Fatalf("content_root réparé = %x, attendu %x", healed.ContentRoot, version.ContentRoot) } if err := env.service.VerifyVersion(ctx, env.owner.ID, healed.ID); err != nil { t.Fatalf("VerifyVersion(réparé) : %v", err) } reader, _, err := env.service.OpenVersion(ctx, env.owner.ID, healed.ID) if err != nil { t.Fatalf("OpenVersion(réparé) : %v", err) } if err := reader.Close(); err != nil { t.Fatalf("Close(réparé) : %v", err) } readOnly := NewService(*env.db, env.store, testBackendID, &testAuthorizer{allowed: permission.Write}) if err := readOnly.VerifyVersion(ctx, env.owner.ID, version.ID); !errors.Is(err, document.ErrPermissionDenied) { t.Fatalf("VerifyVersion sans Read : erreur = %v, attendu ErrPermissionDenied", err) } } func TestVerifyVersionMissingFile(t *testing.T) { env := newTestEnv(t, allowAll()) ctx := context.Background() version := createTestVersion(t, env, env.videoID, "fichier manquant") location, err := env.db.Queries.GetBlobLocation(ctx, database.GetBlobLocationParams{ Root: version.ContentRoot, BackendID: testBackendID, }) if err != nil { t.Fatalf("GetBlobLocation : %v", err) } path := filepath.Join("store", filepath.FromSlash(location.Locator)) if err := os.Remove(path); err != nil { t.Fatalf("Remove : %v", err) } if err := env.service.VerifyVersion(ctx, env.owner.ID, version.ID); !errors.Is(err, ErrContentUnavailable) { t.Fatalf("VerifyVersion : erreur = %v, attendu ErrContentUnavailable", err) } location, err = env.db.Queries.GetBlobLocation(ctx, database.GetBlobLocationParams{ Root: version.ContentRoot, BackendID: testBackendID, }) if err != nil { t.Fatalf("GetBlobLocation(après) : %v", err) } if location.State != BlobLocationMissing { t.Fatalf("state = %q, attendu %q", location.State, BlobLocationMissing) } } func createTestVersion(t *testing.T, env *testEnv, documentID ident.UUID, payload string) *Version { t.Helper() version, err := env.service.CreateVersion(context.Background(), env.owner.ID, documentID, CreateVersionParams{ Source: strings.NewReader(payload), Mime: "video/mp4", }) if err != nil { t.Fatalf("CreateVersion : %v", err) } return version } func setVersionCreatedAt(t *testing.T, env *testEnv, versionID ident.UUID, createdAt int64) { t.Helper() if _, err := env.db.WriteDB.ExecContext(context.Background(), "UPDATE document_version SET created_at = ? WHERE id = ?", createdAt, versionID, ); err != nil { t.Fatalf("UPDATE created_at : %v", err) } } func retentionVersion(t *testing.T, suffix int, createdAt int64, pinned int64, purged bool) database.DocumentVersion { t.Helper() version := database.DocumentVersion{ ID: ident.MustParse(fmt.Sprintf("00000000-0000-7000-8000-%012d", suffix)), CreatedAt: createdAt, Pinned: pinned, } if purged { version.ContentPurgedAt = sql.NullInt64{Int64: createdAt, Valid: true} } return version }