Files
Mediarr/node/node_ingest_test.go
2026-11-16 11:31:37 +01:00

318 lines
9.2 KiB
Go

package node
import (
"context"
"errors"
"os"
"path/filepath"
"strings"
"testing"
"mediarr/content"
"mediarr/document"
"mediarr/ident"
"mediarr/identity"
"mediarr/ingest"
)
func TestNodeIngestScan(t *testing.T) {
t.Chdir(t.TempDir())
err, node := NewNode(NewNodeParams{DatabaseName: "ingest", StoragePath: "store"})
if err != nil {
t.Fatalf("NewNode : %v", err)
}
t.Cleanup(func() {
if err := node.Close(); err != nil {
t.Errorf("Close : %v", err)
}
})
if err := node.Up(); err != nil {
t.Fatalf("Up : %v", err)
}
ctx := context.Background()
owner, err := node.Identity().CreatePrincipal(ctx, identity.CreatePrincipalParams{
Kind: identity.KindUser,
Name: "owner",
})
if err != nil {
t.Fatalf("CreatePrincipal(owner) : %v", err)
}
other, err := node.Identity().CreatePrincipal(ctx, identity.CreatePrincipalParams{
Kind: identity.KindUser,
Name: "other",
})
if err != nil {
t.Fatalf("CreatePrincipal(other) : %v", err)
}
library, err := node.Documents().CreateLibrary(ctx, owner.ID, document.CreateLibraryParams{
OwnerID: owner.ID,
CreatedBy: owner.ID,
Name: "Films",
PolicyID: ident.MustParse("00000000-0000-7000-8000-000000000101"),
})
if err != nil {
t.Fatalf("CreateLibrary : %v", err)
}
source := filepath.Join(t.TempDir(), "library")
if err := os.MkdirAll(filepath.Join(source, "Season 1"), 0o755); err != nil {
t.Fatalf("MkdirAll : %v", err)
}
writeNodeTestFile(t, filepath.Join(source, "film.mkv"), "film")
writeNodeTestFile(t, filepath.Join(source, "notes.txt"), "notes")
writeNodeTestFile(t, filepath.Join(source, "Season 1", "episode.srt"), "subs")
result, err := node.Ingest().Scan(ctx, owner.ID, library.ID, source)
if err != nil {
t.Fatalf("Scan : %v", err)
}
if result.HasErrors() {
t.Fatalf("Scan erreurs : %v", result.Errors)
}
if result.Files != 3 || result.Directories != 1 || result.Created != 4 || result.Updated != 0 || result.Unchanged != 0 {
t.Fatalf("résultat scan = %+v", result)
}
children, err := node.Documents().ListChildren(ctx, owner.ID, library.ID)
if err != nil {
t.Fatalf("ListChildren(library) : %v", err)
}
film := findNodeTestChild(t, children, "film.mkv")
notes := findNodeTestChild(t, children, "notes.txt")
season := findNodeTestChild(t, children, "Season 1")
if film.Kind != document.KindVideo {
t.Fatalf("kind film = %q, attendu %q", film.Kind, document.KindVideo)
}
if notes.Kind != document.KindFile {
t.Fatalf("kind notes = %q, attendu %q", notes.Kind, document.KindFile)
}
if season.Kind != document.KindFolder {
t.Fatalf("kind saison = %q, attendu %q", season.Kind, document.KindFolder)
}
if !strings.Contains(film.Metadata, `"source_path":"film.mkv"`) {
t.Fatalf("metadata film = %q", film.Metadata)
}
seasonChildren, err := node.Documents().ListChildren(ctx, owner.ID, season.ID)
if err != nil {
t.Fatalf("ListChildren(saison) : %v", err)
}
episode := findNodeTestChild(t, seasonChildren, "episode.srt")
if episode.Kind != document.KindSubtitle {
t.Fatalf("kind épisode = %q, attendu %q", episode.Kind, document.KindSubtitle)
}
versions, err := node.Content().ListVersions(ctx, owner.ID, film.ID)
if err != nil {
t.Fatalf("ListVersions(film) : %v", err)
}
if len(versions) != 1 {
t.Fatalf("versions film = %d, attendu 1", len(versions))
}
if versions[0].Seq != 1 || versions[0].Origin != content.OriginImport {
t.Fatalf("version film = %+v", versions[0])
}
head, err := node.Content().HeadVersion(ctx, owner.ID, film.ID)
if err != nil {
t.Fatalf("HeadVersion(film) : %v", err)
}
if head == nil || head.ID != versions[0].ID {
t.Fatalf("head film = %+v, attendu %s", head, versions[0].ID)
}
result, err = node.Ingest().Scan(ctx, owner.ID, library.ID, source)
if err != nil {
t.Fatalf("Scan(rescan) : %v", err)
}
if result.HasErrors() {
t.Fatalf("Scan(rescan) erreurs : %v", result.Errors)
}
if result.Created != 0 || result.Updated != 0 || result.Unchanged != 3 {
t.Fatalf("résultat rescan = %+v", result)
}
versions, err = node.Content().ListVersions(ctx, owner.ID, film.ID)
if err != nil {
t.Fatalf("ListVersions(film après rescan) : %v", err)
}
if len(versions) != 1 {
t.Fatalf("versions film après rescan = %d, attendu 1", len(versions))
}
writeNodeTestFile(t, filepath.Join(source, "film.mkv"), "film v2")
result, err = node.Ingest().Scan(ctx, owner.ID, library.ID, source)
if err != nil {
t.Fatalf("Scan(modifié) : %v", err)
}
if result.HasErrors() {
t.Fatalf("Scan(modifié) erreurs : %v", result.Errors)
}
if result.Created != 0 || result.Updated != 1 || result.Unchanged != 2 {
t.Fatalf("résultat scan modifié = %+v", result)
}
versions, err = node.Content().ListVersions(ctx, owner.ID, film.ID)
if err != nil {
t.Fatalf("ListVersions(film modifié) : %v", err)
}
if len(versions) != 2 {
t.Fatalf("versions film modifié = %d, attendu 2", len(versions))
}
if versions[0].Seq != 2 || versions[0].Origin != content.OriginImport {
t.Fatalf("nouvelle version = %+v", versions[0])
}
if _, err := node.Ingest().Scan(ctx, other.ID, library.ID, source); !errors.Is(err, document.ErrPermissionDenied) {
t.Fatalf("Scan sans Read : erreur = %v, attendu ErrPermissionDenied", err)
}
}
func writeNodeTestFile(t *testing.T, path, content string) {
t.Helper()
if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
t.Fatalf("WriteFile(%s) : %v", path, err)
}
}
func findNodeTestChild(t *testing.T, children []document.Document, name string) *document.Document {
t.Helper()
for i := range children {
if children[i].Name == name {
return &children[i]
}
}
t.Fatalf("enfant %q introuvable dans %+v", name, children)
return nil
}
func TestNodeIngestImportAndPrune(t *testing.T) {
t.Chdir(t.TempDir())
err, node := NewNode(NewNodeParams{DatabaseName: "ingest_prune", StoragePath: "store"})
if err != nil {
t.Fatalf("NewNode : %v", err)
}
t.Cleanup(func() {
if err := node.Close(); err != nil {
t.Errorf("Close : %v", err)
}
})
if err := node.Up(); err != nil {
t.Fatalf("Up : %v", err)
}
ctx := context.Background()
owner, err := node.Identity().CreatePrincipal(ctx, identity.CreatePrincipalParams{
Kind: identity.KindUser,
Name: "owner",
})
if err != nil {
t.Fatalf("CreatePrincipal(owner) : %v", err)
}
library, err := node.Documents().CreateLibrary(ctx, owner.ID, document.CreateLibraryParams{
OwnerID: owner.ID,
CreatedBy: owner.ID,
Name: "Films",
PolicyID: ident.MustParse("00000000-0000-7000-8000-000000000101"),
})
if err != nil {
t.Fatalf("CreateLibrary : %v", err)
}
source := filepath.Join(t.TempDir(), "library")
if err := os.MkdirAll(source, 0o755); err != nil {
t.Fatalf("MkdirAll : %v", err)
}
writeNodeTestFile(t, filepath.Join(source, "keep.mkv"), "keep")
writeNodeTestFile(t, filepath.Join(source, "remove.txt"), "remove")
if _, err := node.Ingest().Scan(ctx, owner.ID, library.ID, source); err != nil {
t.Fatalf("Scan : %v", err)
}
if _, err := node.Documents().CreateChild(ctx, owner.ID, document.CreateChildParams{
Kind: document.KindFile,
OwnerID: owner.ID,
CreatedBy: owner.ID,
ParentID: library.ID,
Name: "manual.txt",
}); err != nil {
t.Fatalf("CreateChild(manual) : %v", err)
}
extra := filepath.Join(t.TempDir(), "extra.jpg")
writeNodeTestFile(t, extra, "extra")
imported, err := node.Ingest().Import(ctx, owner.ID, library.ID, extra)
if err != nil {
t.Fatalf("Import : %v", err)
}
if imported.Files != 1 || imported.Created != 1 || imported.Updated != 0 || imported.Unchanged != 0 {
t.Fatalf("résultat import = %+v", imported)
}
imported, err = node.Ingest().Import(ctx, owner.ID, library.ID, extra)
if err != nil {
t.Fatalf("Import(doublon) : %v", err)
}
if imported.Files != 1 || imported.Created != 0 || imported.Updated != 0 || imported.Unchanged != 1 {
t.Fatalf("résultat import doublon = %+v", imported)
}
imported, err = node.Ingest().Import(ctx, owner.ID, library.ID, source)
if err != nil {
t.Fatalf("Import(dossier) : %v", err)
}
if imported.Files != 2 || imported.Created != 0 || imported.Updated != 0 || imported.Unchanged != 2 {
t.Fatalf("résultat import dossier = %+v", imported)
}
if err := os.Remove(filepath.Join(source, "remove.txt")); err != nil {
t.Fatalf("Remove : %v", err)
}
result, err := node.Ingest().ScanWithOptions(ctx, owner.ID, library.ID, source, ingest.ScanOptions{Prune: true})
if err != nil {
t.Fatalf("ScanWithOptions : %v", err)
}
if result.HasErrors() {
t.Fatalf("ScanWithOptions erreurs : %v", result.Errors)
}
if result.Pruned != 1 {
t.Fatalf("pruned = %d, attendu 1", result.Pruned)
}
children, err := node.Documents().ListChildren(ctx, owner.ID, library.ID)
if err != nil {
t.Fatalf("ListChildren : %v", err)
}
if hasNodeTestChild(children, "remove.txt") {
t.Fatal("remove.txt toujours présent après prune")
}
if !hasNodeTestChild(children, "keep.mkv") {
t.Fatal("keep.mkv absent après prune")
}
if !hasNodeTestChild(children, "manual.txt") {
t.Fatal("manual.txt supprimé alors qu'il n'est pas issu du scan")
}
if !hasNodeTestChild(children, "extra.jpg") {
t.Fatal("extra.jpg supprimé alors qu'il vient d'une autre racine")
}
}
func hasNodeTestChild(children []document.Document, name string) bool {
for i := range children {
if children[i].Name == name {
return true
}
}
return false
}