245 lines
7.6 KiB
Go
245 lines
7.6 KiB
Go
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)
|
|
}
|
|
}
|
|
|
|
func TestHeadVersion(t *testing.T) {
|
|
env := newTestEnv(t, allowAll())
|
|
ctx := context.Background()
|
|
|
|
head, err := env.service.HeadVersion(ctx, env.owner.ID, env.videoID)
|
|
if err != nil {
|
|
t.Fatalf("HeadVersion(sans version) : %v", err)
|
|
}
|
|
if head != nil {
|
|
t.Fatalf("HeadVersion(sans version) = %+v, attendu nil", head)
|
|
}
|
|
|
|
first, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
|
|
Source: bytes.NewReader([]byte("premier")),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateVersion : %v", err)
|
|
}
|
|
head, err = env.service.HeadVersion(ctx, env.owner.ID, env.videoID)
|
|
if err != nil {
|
|
t.Fatalf("HeadVersion : %v", err)
|
|
}
|
|
if head == nil || head.ID != first.ID {
|
|
t.Fatalf("HeadVersion = %+v, attendu %s", head, first.ID)
|
|
}
|
|
|
|
second, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
|
|
Source: bytes.NewReader([]byte("second")),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateVersion(second) : %v", err)
|
|
}
|
|
head, err = env.service.HeadVersion(ctx, env.owner.ID, env.videoID)
|
|
if err != nil {
|
|
t.Fatalf("HeadVersion(second) : %v", err)
|
|
}
|
|
if head == nil || head.ID != second.ID {
|
|
t.Fatalf("HeadVersion = %+v, attendu %s", head, second.ID)
|
|
}
|
|
|
|
readerOnly := NewService(*env.db, env.store, testBackendID, &testAuthorizer{allowed: permission.Write})
|
|
if _, err := readerOnly.HeadVersion(ctx, env.owner.ID, env.videoID); !errors.Is(err, document.ErrPermissionDenied) {
|
|
t.Fatalf("HeadVersion sans Read : erreur = %v, attendu ErrPermissionDenied", err)
|
|
}
|
|
}
|