create content version

This commit is contained in:
venture
2026-11-15 10:01:30 +01:00
parent 29a6ab40f0
commit 610192e2d5
13 changed files with 2226 additions and 3 deletions
+72
View File
@@ -0,0 +1,72 @@
package content
import (
"errors"
"io"
"mediarr/ident"
)
const (
OriginUpload = "upload"
OriginImport = "import"
OriginMerge = "merge"
OriginRestore = "restore"
OriginSystem = "system"
)
const (
StagingStateStaged = "staged"
StagingStateHashing = "hashing"
StagingStateCommitted = "committed"
StagingStateDiscarded = "discarded"
)
const (
BlobStatePresent = "present"
BlobRoleAuthoritative = "authoritative"
BlobTreeStateReady = "ready"
BlobEncryptionNone = "none"
BlobLocationPresent = "present"
)
const blobUnitSize = 1024 * 1024
type Version struct {
ID ident.UUID
DocumentID ident.UUID
Seq int64
ContentRoot []byte
Size int64
Mime string
AuthorID ident.UUID
DeviceID *ident.UUID
Origin string
Message string
Pinned bool
ContentPurgedAt *int64
CreatedAt int64
}
type CreateVersionParams struct {
Source io.Reader
Mime string
Origin string
Message string
Pinned bool
DeviceID *ident.UUID
JobRef string
}
var (
ErrStorageNotConfigured = errors.New("stockage non configuré")
ErrStorageBackendMissing = errors.New("backend de stockage introuvable")
ErrInvalidSource = errors.New("source de contenu invalide")
ErrInvalidOrigin = errors.New("origine de version invalide")
ErrNoContentKind = errors.New("type de document sans contenu")
ErrNoStoragePolicy = errors.New("politique de stockage introuvable")
ErrBlobUnavailable = errors.New("blob indisponible")
ErrVersionNotFound = errors.New("version introuvable")
ErrContentPurged = errors.New("contenu purgé")
ErrContentUnavailable = errors.New("contenu indisponible")
)
+143
View File
@@ -0,0 +1,143 @@
package content
import (
"context"
"encoding/hex"
"path/filepath"
"strings"
"testing"
"time"
"mediarr/database"
"mediarr/document"
"mediarr/ident"
"mediarr/identity"
"mediarr/permission"
"mediarr/storage"
)
var (
testBackendID = ident.MustParse("00000000-0000-7000-8000-000000000201")
testPolicyID = ident.MustParse("00000000-0000-7000-8000-000000000101")
)
type testAuthorizer struct {
allowed permission.Permission
}
func allowAll() *testAuthorizer {
return &testAuthorizer{allowed: permission.All}
}
func (a *testAuthorizer) IsActive(context.Context, ident.UUID) (bool, error) {
return true, nil
}
func (a *testAuthorizer) Can(_ context.Context, _ ident.UUID, _ ident.UUID, required permission.Permission) (bool, error) {
return a.allowed.Has(required), nil
}
type testEnv struct {
service *Service
db *database.DatabaseClient
store *storage.Local
owner *identity.Principal
libraryID ident.UUID
videoID ident.UUID
}
func newTestEnv(t *testing.T, authorizer document.Authorizer) *testEnv {
t.Helper()
t.Chdir(t.TempDir())
err, db := database.NewDatabase(database.NewDatabaseParams{})
if err != nil {
t.Fatalf("NewDatabase : %v", err)
}
t.Cleanup(func() {
if err := db.Close(); err != nil {
t.Errorf("Close : %v", err)
}
})
store, err := storage.NewLocal(filepath.Join("store"))
if err != nil {
t.Fatalf("NewLocal : %v", err)
}
now := time.Now().UnixMilli()
if err := db.WriteQueries.CreateStorageBackend(context.Background(), database.CreateStorageBackendParams{
ID: testBackendID,
Kind: "hub_fs",
Name: "local",
Config: `{"root":"store"}`,
Enabled: 1,
State: "ok",
CreatedAt: now,
}); err != nil {
t.Fatalf("CreateStorageBackend : %v", err)
}
ctx := context.Background()
owner, err := identity.NewService(*db).CreatePrincipal(ctx, identity.CreatePrincipalParams{
Kind: identity.KindUser,
Name: "owner",
})
if err != nil {
t.Fatalf("CreatePrincipal : %v", err)
}
documents := document.NewService(*db, allowAll())
library, err := documents.CreateLibrary(ctx, owner.ID, document.CreateLibraryParams{
OwnerID: owner.ID,
CreatedBy: owner.ID,
Name: "Bibliothèque",
PolicyID: testPolicyID,
})
if err != nil {
t.Fatalf("CreateLibrary : %v", err)
}
videoID := createVideo(t, db, owner, library, "film.mkv")
return &testEnv{
service: NewService(*db, store, testBackendID, authorizer),
db: db,
store: store,
owner: owner,
libraryID: library.ID,
videoID: videoID,
}
}
func createVideo(t *testing.T, db *database.DatabaseClient, owner *identity.Principal, parent *document.Document, name string) ident.UUID {
t.Helper()
id, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
now := time.Now().UnixMilli()
if _, err := db.WriteQueries.CreateDocument(context.Background(), database.CreateDocumentParams{
ID: id,
Kind: "video",
OwnerID: owner.ID,
CreatedBy: owner.ID,
ParentID: &parent.ID,
Name: name,
NameKey: strings.ToLower(name),
Path: parent.Path + hex.EncodeToString(id[:]) + "/",
Depth: parent.Depth + 1,
Metadata: "{}",
AclInherit: 1,
Rev: 1,
CreatedAt: now,
UpdatedAt: now,
}); err != nil {
t.Fatalf("CreateDocument : %v", err)
}
return id
}
+145
View File
@@ -0,0 +1,145 @@
package content
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"mediarr/database"
"mediarr/document"
"mediarr/ident"
"mediarr/permission"
"mediarr/storage"
)
type Service struct {
db database.DatabaseClient
store storage.Store
backendID ident.UUID
authorizer document.Authorizer
}
func NewService(db database.DatabaseClient, store storage.Store, backendID ident.UUID, authorizer document.Authorizer) *Service {
return &Service{
db: db,
store: store,
backendID: backendID,
authorizer: authorizer,
}
}
func (s *Service) withTx(ctx context.Context, fn func(*database.Queries) error) error {
tx, err := s.db.WriteDB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer func() {
_ = tx.Rollback()
}()
if err := fn(s.db.WriteQueries.WithTx(tx)); err != nil {
return err
}
return tx.Commit()
}
func (s *Service) getDocument(ctx context.Context, id ident.UUID) (*database.Document, error) {
row, err := s.db.Queries.GetDocument(ctx, id)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, fmt.Errorf("%w: %s", document.ErrDocumentNotFound, id)
}
return nil, err
}
return &row, nil
}
func (s *Service) getVersion(ctx context.Context, id ident.UUID) (*database.DocumentVersion, error) {
row, err := s.db.Queries.GetDocumentVersion(ctx, id)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, fmt.Errorf("%w: %s", ErrVersionNotFound, id)
}
return nil, err
}
return &row, nil
}
func (s *Service) can(ctx context.Context, principalID, documentID ident.UUID, required permission.Permission) error {
allowed, err := s.authorizer.Can(ctx, principalID, documentID, required)
if err != nil {
return err
}
if !allowed {
return fmt.Errorf("%w: %s sur %s", document.ErrPermissionDenied, principalID, documentID)
}
return nil
}
func (s *Service) setStagingState(ctx context.Context, id ident.UUID, state string) error {
return s.db.WriteQueries.UpdateStagingItemState(ctx, database.UpdateStagingItemStateParams{
State: state,
UpdatedAt: nowMillis(),
ID: id,
})
}
func versionFromDB(version database.DocumentVersion) *Version {
var mime string
if version.Mime.Valid {
mime = version.Mime.String
}
var message string
if version.Message.Valid {
message = version.Message.String
}
var purgedAt *int64
if version.ContentPurgedAt.Valid {
value := version.ContentPurgedAt.Int64
purgedAt = &value
}
return &Version{
ID: version.ID,
DocumentID: version.DocumentID,
Seq: version.Seq,
ContentRoot: version.ContentRoot,
Size: version.Size,
Mime: mime,
AuthorID: version.AuthorID,
DeviceID: version.DeviceID,
Origin: version.Origin,
Message: message,
Pinned: version.Pinned != 0,
ContentPurgedAt: purgedAt,
CreatedAt: version.CreatedAt,
}
}
func validOrigin(origin string) bool {
switch origin {
case OriginUpload, OriginImport, OriginMerge, OriginRestore, OriginSystem:
return true
default:
return false
}
}
func stagingOrigin(origin string) string {
if origin == OriginImport {
return OriginImport
}
return OriginUpload
}
func nowMillis() int64 {
return time.Now().UnixMilli()
}
+341
View File
@@ -0,0 +1,341 @@
package content
import (
"context"
"database/sql"
"errors"
"fmt"
"io"
"mediarr/database"
"mediarr/document"
"mediarr/ident"
"mediarr/permission"
"mediarr/storage"
)
func (s *Service) CreateVersion(ctx context.Context, actorID, documentID ident.UUID, params CreateVersionParams) (*Version, error) {
if s.store == nil {
return nil, ErrStorageNotConfigured
}
if params.Source == nil {
return nil, ErrInvalidSource
}
origin := params.Origin
if origin == "" {
origin = OriginUpload
}
if !validOrigin(origin) {
return nil, fmt.Errorf("%w: %q", ErrInvalidOrigin, origin)
}
documentRow, err := s.getDocument(ctx, documentID)
if err != nil {
return nil, err
}
if documentRow.DeletedAt.Valid {
return nil, fmt.Errorf("%w: %s", document.ErrDocumentDeleted, documentID)
}
kind, err := s.db.Queries.GetDocumentKind(ctx, documentRow.Kind)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, fmt.Errorf("%w: %s", ErrNoContentKind, documentRow.Kind)
}
return nil, err
}
if kind.HasContent == 0 {
return nil, fmt.Errorf("%w: %s", ErrNoContentKind, documentRow.Kind)
}
if err := s.can(ctx, actorID, documentID, permission.Write); err != nil {
return nil, err
}
policyBytes, err := s.db.Queries.GetEffectiveDocumentPolicy(ctx, documentID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, fmt.Errorf("%w: %s", ErrNoStoragePolicy, documentID)
}
return nil, err
}
policyID, err := ident.FromBytes(policyBytes)
if err != nil {
return nil, fmt.Errorf("%w: %v", ErrNoStoragePolicy, err)
}
if _, err := s.db.Queries.GetStoragePolicy(ctx, policyID); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, fmt.Errorf("%w: %s", ErrNoStoragePolicy, policyID)
}
return nil, err
}
if _, err := s.db.Queries.GetStorageBackend(ctx, s.backendID); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, fmt.Errorf("%w: %s", ErrStorageBackendMissing, s.backendID)
}
return nil, err
}
stagingID, err := ident.NewV7()
if err != nil {
return nil, err
}
staged, err := s.store.Stage(ctx, stagingID, params.Source)
if err != nil {
return nil, err
}
now := nowMillis()
jobRef := sql.NullString{String: params.JobRef, Valid: params.JobRef != ""}
if err := s.db.WriteQueries.CreateStagingItem(ctx, database.CreateStagingItemParams{
ID: stagingID,
Origin: stagingOrigin(origin),
JobRef: jobRef,
Locator: staged.Locator,
Size: sql.NullInt64{Int64: staged.Size, Valid: true},
State: StagingStateStaged,
CreatedAt: now,
UpdatedAt: now,
}); err != nil {
_ = s.store.Remove(ctx, staged.Locator)
return nil, err
}
blob, err := s.db.Queries.GetBlob(ctx, staged.Root)
newBlob := false
newLocation := false
blobLocator := ""
switch {
case err == nil:
if blob.State != BlobStatePresent {
_ = s.store.Remove(ctx, staged.Locator)
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
return nil, fmt.Errorf("%w: %x", ErrBlobUnavailable, staged.Root)
}
if blob.Size != staged.Size {
_ = s.store.Remove(ctx, staged.Locator)
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
return nil, fmt.Errorf("%w: taille incohérente", ErrBlobUnavailable)
}
location, locationErr := s.db.Queries.GetBlobLocation(ctx, database.GetBlobLocationParams{
Root: staged.Root,
BackendID: s.backendID,
})
switch {
case locationErr == nil:
if location.State != BlobLocationPresent {
_ = s.store.Remove(ctx, staged.Locator)
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
return nil, fmt.Errorf("%w: %x", ErrBlobUnavailable, staged.Root)
}
if err := s.store.Remove(ctx, staged.Locator); err != nil {
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
return nil, err
}
case errors.Is(locationErr, sql.ErrNoRows):
blobLocator, err = s.store.Commit(ctx, staged)
if err != nil {
_ = s.store.Remove(ctx, staged.Locator)
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
return nil, err
}
newLocation = true
default:
_ = s.store.Remove(ctx, staged.Locator)
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
return nil, locationErr
}
case errors.Is(err, sql.ErrNoRows):
blobLocator, err = s.store.Commit(ctx, staged)
if err != nil {
_ = s.store.Remove(ctx, staged.Locator)
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
return nil, err
}
newBlob = true
newLocation = true
default:
_ = s.store.Remove(ctx, staged.Locator)
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
return nil, err
}
var created database.DocumentVersion
err = s.withTx(ctx, func(q *database.Queries) error {
if newBlob {
if err := q.CreateBlob(ctx, database.CreateBlobParams{
Root: staged.Root,
Size: staged.Size,
State: BlobStatePresent,
Role: BlobRoleAuthoritative,
UnitSize: blobUnitSize,
TreeState: BlobTreeStateReady,
Encryption: BlobEncryptionNone,
CreatedAt: now,
}); err != nil {
return err
}
}
if newLocation {
if err := q.CreateBlobLocation(ctx, database.CreateBlobLocationParams{
Root: staged.Root,
BackendID: s.backendID,
Locator: blobLocator,
State: BlobLocationPresent,
CreatedAt: now,
}); err != nil {
return err
}
}
seq, err := q.NextDocumentVersionSeq(ctx, documentID)
if err != nil {
return err
}
versionID, err := ident.NewV7()
if err != nil {
return err
}
created, err = q.CreateDocumentVersion(ctx, database.CreateDocumentVersionParams{
ID: versionID,
DocumentID: documentID,
Seq: seq,
ContentRoot: staged.Root,
Size: staged.Size,
Mime: sql.NullString{String: params.Mime, Valid: params.Mime != ""},
AuthorID: actorID,
DeviceID: params.DeviceID,
Origin: origin,
Message: sql.NullString{String: params.Message, Valid: params.Message != ""},
Pinned: boolToInt(params.Pinned),
CreatedAt: now,
})
if err != nil {
return err
}
rows, err := q.SetDocumentHeadVersion(ctx, database.SetDocumentHeadVersionParams{
HeadVersionID: &versionID,
UpdatedAt: now,
ID: documentID,
})
if err != nil {
return err
}
if rows == 0 {
return fmt.Errorf("%w: %s", document.ErrDocumentDeleted, documentID)
}
return q.UpdateStagingItemState(ctx, database.UpdateStagingItemStateParams{
State: StagingStateCommitted,
UpdatedAt: now,
ID: stagingID,
})
})
if err != nil {
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
return nil, err
}
return versionFromDB(created), nil
}
func (s *Service) OpenVersion(ctx context.Context, actorID, versionID ident.UUID) (io.ReadCloser, *Version, error) {
if s.store == nil {
return nil, nil, ErrStorageNotConfigured
}
version, err := s.getVersion(ctx, versionID)
if err != nil {
return nil, nil, err
}
documentRow, err := s.getDocument(ctx, version.DocumentID)
if err != nil {
return nil, nil, err
}
if documentRow.DeletedAt.Valid {
return nil, nil, fmt.Errorf("%w: %s", document.ErrDocumentDeleted, documentRow.ID)
}
if err := s.can(ctx, actorID, version.DocumentID, permission.Read); err != nil {
return nil, nil, err
}
if version.ContentPurgedAt.Valid {
return nil, nil, fmt.Errorf("%w: %s", ErrContentPurged, versionID)
}
blob, err := s.db.Queries.GetBlob(ctx, version.ContentRoot)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, nil, fmt.Errorf("%w: %s", ErrContentUnavailable, versionID)
}
return nil, nil, err
}
if blob.State != BlobStatePresent {
return nil, nil, fmt.Errorf("%w: %s", ErrContentUnavailable, versionID)
}
location, err := s.db.Queries.GetBlobLocation(ctx, database.GetBlobLocationParams{
Root: version.ContentRoot,
BackendID: s.backendID,
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, nil, fmt.Errorf("%w: %s", ErrContentUnavailable, versionID)
}
return nil, nil, err
}
if location.State != BlobLocationPresent {
return nil, nil, fmt.Errorf("%w: %s", ErrContentUnavailable, versionID)
}
reader, err := s.store.Open(ctx, location.Locator)
if err != nil {
if errors.Is(err, storage.ErrNotFound) {
return nil, nil, fmt.Errorf("%w: %s", ErrContentUnavailable, versionID)
}
return nil, nil, err
}
return reader, versionFromDB(*version), nil
}
func (s *Service) ListVersions(ctx context.Context, actorID, documentID ident.UUID) ([]Version, error) {
documentRow, err := s.getDocument(ctx, documentID)
if err != nil {
return nil, err
}
if documentRow.DeletedAt.Valid {
return nil, fmt.Errorf("%w: %s", document.ErrDocumentDeleted, documentID)
}
if err := s.can(ctx, actorID, documentID, permission.Read); err != nil {
return nil, err
}
rows, err := s.db.Queries.ListDocumentVersions(ctx, documentID)
if err != nil {
return nil, err
}
versions := make([]Version, 0, len(rows))
for _, row := range rows {
versions = append(versions, *versionFromDB(row))
}
return versions, nil
}
func boolToInt(value bool) int64 {
if value {
return 1
}
return 0
}
+198
View File
@@ -0,0 +1,198 @@
package content
import (
"bytes"
"context"
"errors"
"io"
"testing"
"time"
"mediarr/database"
"mediarr/document"
"mediarr/ident"
"mediarr/permission"
)
func TestCreateVersionStoresAndDeduplicates(t *testing.T) {
env := newTestEnv(t, allowAll())
ctx := context.Background()
payload := []byte("contenu de test")
first, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
Source: bytes.NewReader(payload),
Mime: "video/mp4",
Message: "première",
})
if err != nil {
t.Fatalf("CreateVersion : %v", err)
}
if first.Seq != 1 || first.Size != int64(len(payload)) {
t.Fatalf("version = seq %d taille %d", first.Seq, first.Size)
}
second, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
Source: bytes.NewReader(payload),
Origin: OriginMerge,
})
if err != nil {
t.Fatalf("CreateVersion(doublon) : %v", err)
}
if second.Seq != 2 {
t.Fatalf("seq = %d, attendu 2", second.Seq)
}
if !bytes.Equal(second.ContentRoot, first.ContentRoot) {
t.Fatalf("content_root = %x, attendu %x", second.ContentRoot, first.ContentRoot)
}
if second.Origin != OriginMerge {
t.Fatalf("origin = %q, attendu %q", second.Origin, OriginMerge)
}
reader, opened, err := env.service.OpenVersion(ctx, env.owner.ID, second.ID)
if err != nil {
t.Fatalf("OpenVersion : %v", err)
}
data, err := io.ReadAll(reader)
if err != nil {
_ = reader.Close()
t.Fatalf("ReadAll : %v", err)
}
if err := reader.Close(); err != nil {
t.Fatalf("Close : %v", err)
}
if !bytes.Equal(data, payload) {
t.Fatalf("contenu = %q, attendu %q", data, payload)
}
if opened.ID != second.ID {
t.Fatalf("version = %s, attendu %s", opened.ID, second.ID)
}
versions, err := env.service.ListVersions(ctx, env.owner.ID, env.videoID)
if err != nil {
t.Fatalf("ListVersions : %v", err)
}
if len(versions) != 2 || versions[0].ID != second.ID || versions[1].ID != first.ID {
t.Fatalf("versions = %+v", versions)
}
}
func TestCreateVersionRejectsContainerKind(t *testing.T) {
env := newTestEnv(t, allowAll())
_, err := env.service.CreateVersion(context.Background(), env.owner.ID, env.libraryID, CreateVersionParams{
Source: bytes.NewReader([]byte("x")),
})
if !errors.Is(err, ErrNoContentKind) {
t.Fatalf("erreur = %v, attendu ErrNoContentKind", err)
}
}
func TestCreateVersionRequiresWrite(t *testing.T) {
env := newTestEnv(t, &testAuthorizer{allowed: permission.Read})
_, err := env.service.CreateVersion(context.Background(), env.owner.ID, env.videoID, CreateVersionParams{
Source: bytes.NewReader([]byte("x")),
})
if !errors.Is(err, document.ErrPermissionDenied) {
t.Fatalf("erreur = %v, attendu ErrPermissionDenied", err)
}
}
func TestOpenVersionRequiresRead(t *testing.T) {
env := newTestEnv(t, &testAuthorizer{allowed: permission.Write})
ctx := context.Background()
version, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
Source: bytes.NewReader([]byte("x")),
})
if err != nil {
t.Fatalf("CreateVersion : %v", err)
}
if _, _, err := env.service.OpenVersion(ctx, env.owner.ID, version.ID); !errors.Is(err, document.ErrPermissionDenied) {
t.Fatalf("erreur = %v, attendu ErrPermissionDenied", err)
}
if _, err := env.service.ListVersions(ctx, env.owner.ID, env.videoID); !errors.Is(err, document.ErrPermissionDenied) {
t.Fatalf("ListVersions : erreur = %v, attendu ErrPermissionDenied", err)
}
}
func TestOpenVersionPurged(t *testing.T) {
env := newTestEnv(t, allowAll())
ctx := context.Background()
version, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
Source: bytes.NewReader([]byte("x")),
})
if err != nil {
t.Fatalf("CreateVersion : %v", err)
}
if _, err := env.db.WriteDB.ExecContext(ctx,
"UPDATE document_version SET content_purged_at = ? WHERE id = ?",
time.Now().UnixMilli(), version.ID,
); err != nil {
t.Fatalf("UPDATE content_purged_at : %v", err)
}
if _, _, err := env.service.OpenVersion(ctx, env.owner.ID, version.ID); !errors.Is(err, ErrContentPurged) {
t.Fatalf("erreur = %v, attendu ErrContentPurged", err)
}
}
func TestOpenVersionMissingBlob(t *testing.T) {
env := newTestEnv(t, allowAll())
ctx := context.Background()
version, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
Source: bytes.NewReader([]byte("x")),
})
if err != nil {
t.Fatalf("CreateVersion : %v", err)
}
location, err := env.db.Queries.GetBlobLocation(ctx, database.GetBlobLocationParams{
Root: version.ContentRoot,
BackendID: testBackendID,
})
if err != nil {
t.Fatalf("GetBlobLocation : %v", err)
}
if err := env.store.Remove(ctx, location.Locator); err != nil {
t.Fatalf("Remove : %v", err)
}
if _, _, err := env.service.OpenVersion(ctx, env.owner.ID, version.ID); !errors.Is(err, ErrContentUnavailable) {
t.Fatalf("erreur = %v, attendu ErrContentUnavailable", err)
}
}
func TestCreateVersionConfigurationErrors(t *testing.T) {
env := newTestEnv(t, allowAll())
ctx := context.Background()
if _, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{}); !errors.Is(err, ErrInvalidSource) {
t.Fatalf("sans source : erreur = %v, attendu ErrInvalidSource", err)
}
if _, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
Source: bytes.NewReader([]byte("x")),
Origin: "inconnu",
}); !errors.Is(err, ErrInvalidOrigin) {
t.Fatalf("origine invalide : erreur = %v, attendu ErrInvalidOrigin", err)
}
missingBackend := NewService(*env.db, env.store, ident.MustParse("00000000-0000-7000-8000-000000000202"), allowAll())
if _, err := missingBackend.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
Source: bytes.NewReader([]byte("x")),
}); !errors.Is(err, ErrStorageBackendMissing) {
t.Fatalf("backend manquant : erreur = %v, attendu ErrStorageBackendMissing", err)
}
withoutStore := NewService(*env.db, nil, testBackendID, allowAll())
if _, err := withoutStore.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
Source: bytes.NewReader([]byte("x")),
}); !errors.Is(err, ErrStorageNotConfigured) {
t.Fatalf("sans stockage : erreur = %v, attendu ErrStorageNotConfigured", err)
}
}