318 lines
9.2 KiB
Go
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
|
|
}
|