V3 S7 : preview cloud + export chiffré + release 1.2.0
Release / release-apk (push) Successful in 8m58s
Release / release-docker (push) Successful in 3m47s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m44s
CI / lint-mobile (push) Failing after 18m59s
CI / test-backend (push) Successful in 2m12s
CI / test-mobile (push) Successful in 8m50s
CI / build-backend (push) Successful in 45s

Backend : resource_previews (000024), GET /files/:id/preview (JPEG
512, images pur Go, PDF page 1 via pdftoppm + poppler au Dockerfile,
cache régénéré sur changement, 404 NO_PREVIEW sinon), POST /export
{password 8+} -> zip AES-256 streamé (fichiers vifs possédés +
manifest.json avec faits, metadata-only sans octets). Deps :
alexmullins/zip, x/image directs. Tests service + handlers + migrations.

Mobile : vignettes distantes (une requête/session puis cache WebP
versionné, garde tried, icône sinon), FileThumbnail cloud-only,
export (mot de passe jamais persisté, cache + partage FileProvider),
bouton Partager ACTION_SEND. Impression papier reportée V4. FR/EN.

Contrat docs/api-v1.md, V3.md (S7 livré, V3 close), AGENTS.md,
VERSION 1.2.0 + CHANGELOG.
This commit is contained in:
venture
2026-09-26 15:08:31 +02:00
parent 1e38e6e4ee
commit 4316da578f
56 changed files with 2004 additions and 37 deletions
+155
View File
@@ -0,0 +1,155 @@
package service
import (
"encoding/json"
"fmt"
"io"
"log"
"os"
"time"
"github.com/alexmullins/zip"
)
// Export password floor (V3 S7 C3) : un backup chiffré avec "1234" est un
// placebo — même seuil que les mots de passe compte (8).
const exportMinPasswordLength = 8
// ExportMaxResources bounds a full export (V3 S7 C3) : au-delà, l'export est
// tronqué honnêtement (manifest.truncated = true) plutôt que de gonfler sans
// fin la mémoire/temps d'une requête HTTP.
const ExportMaxResources = 20000
// ExportManifestFile is the encrypted manifest inside the zip.
type ExportManifestFile struct {
Version int `json:"version"`
ExportedAt string `json:"exportedAt"`
UserID string `json:"userId"`
Truncated bool `json:"truncated"`
Folders []ExportFolderEntry `json:"folders"`
Files []ExportFileEntry `json:"files"`
}
// ExportFolderEntry mirrors a live folder (tree rebuilt via parentId).
type ExportFolderEntry struct {
ID string `json:"id"`
Name string `json:"name"`
ParentID string `json:"parentId,omitempty"`
}
// ExportFileEntry mirrors a live file (+ extracted knowledge for re-import).
type ExportFileEntry struct {
ID string `json:"id"`
Name string `json:"name"`
ParentID string `json:"parentId,omitempty"`
Size int64 `json:"size"`
MimeType string `json:"mimeType,omitempty"`
Extension string `json:"extension,omitempty"`
Hash string `json:"hash,omitempty"`
OcrText string `json:"ocrText,omitempty"`
Facts []FactDTO `json:"facts,omitempty"`
Path string `json:"path,omitempty"` // files/<id>.<ext> — absent si metadata-only
HasBytes bool `json:"hasBytes"`
}
// Export streams an AES-256 encrypted zip of the account (V3 S7 C3) : every
// entry — files AND manifest — is encrypted with password (WinZip AES, cf.
// alexmullins/zip). Scope : own live resources only (ni trashés, ni
// partagés d'autrui). Metadata-only files appear in the manifest without
// bytes (Path vide, HasBytes false). Password < 8 → error (400 côté handler).
func (s *Resources) Export(w io.Writer, ownerID, password string) error {
if len(password) < exportMinPasswordLength {
return fmt.Errorf("export password must be at least %d characters", exportMinPasswordLength)
}
folders, err := s.Repo.ExportFolders(ownerID, ExportMaxResources)
if err != nil {
return err
}
files, err := s.Repo.ExportFiles(ownerID, ExportMaxResources)
if err != nil {
return err
}
truncated := len(folders) == ExportMaxResources || len(files) == ExportMaxResources
manifest := ExportManifestFile{
Version: 1, ExportedAt: time.Now().UTC().Format(time.RFC3339),
UserID: ownerID, Truncated: truncated,
Folders: make([]ExportFolderEntry, 0, len(folders)),
Files: make([]ExportFileEntry, 0, len(files)),
}
for _, f := range folders {
manifest.Folders = append(manifest.Folders, ExportFolderEntry{
ID: f.ID, Name: f.Name, ParentID: f.ParentID,
})
}
zw := zip.NewWriter(w)
writeEncrypted := func(name string, data []byte) error {
fh := &zip.FileHeader{Name: name, Method: zip.Deflate}
fh.SetPassword(password)
fw, err := zw.CreateHeader(fh)
if err != nil {
return err
}
_, err = fw.Write(data)
return err
}
for _, f := range files {
entry := ExportFileEntry{
ID: f.ID, Name: f.Name, ParentID: f.ParentID, Size: f.Size,
MimeType: f.MimeType, Extension: f.Extension, Hash: f.Hash,
OcrText: f.OcrText,
}
// Faits joints (auto + corrections — la connaissance voyage avec).
if facts, ferr := s.Repository.Resources.ListFacts(f.ID); ferr == nil {
for _, fact := range facts {
entry.Facts = append(entry.Facts, FactDTO{
FactType: fact.Type, ValueText: fact.ValueText,
ValueNum: fact.ValueNum, ValueDate: derefString(fact.ValueDate),
Confidence: fact.Confidence, Origin: fact.Origin,
})
}
}
src, serr := s.resolvePhysical(ownerID, f.ID)
if serr != nil {
entry.HasBytes = false
manifest.Files = append(manifest.Files, entry)
continue
}
zipName := "files/" + f.ID
if f.Extension != "" {
zipName += "." + f.Extension
}
entry.Path = zipName
entry.HasBytes = true
manifest.Files = append(manifest.Files, entry)
in, err := os.Open(src)
if err != nil {
log.Printf("export: open %s: %v", f.ID, err)
continue
}
fh := &zip.FileHeader{Name: zipName, Method: zip.Deflate}
fh.SetPassword(password)
fw, err := zw.CreateHeader(fh)
if err != nil {
in.Close()
return err
}
if _, err := io.Copy(fw, in); err != nil {
in.Close()
return err
}
in.Close()
}
raw, err := json.MarshalIndent(manifest, "", " ")
if err != nil {
return err
}
if err := writeEncrypted("manifest.json", raw); err != nil {
return err
}
return zw.Close()
}
+163
View File
@@ -0,0 +1,163 @@
package service
import (
"archive/zip"
"bytes"
"encoding/json"
"testing"
azip "github.com/alexmullins/zip"
"github.com/kazier/backend/repository"
)
// TestExportRoundTrip : zip déchiffrable avec le mot de passe, manifest
// cohérent (fichiers + faits + dossiers), octets intacts, trashés exclus.
func TestExportRoundTrip(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "export-roundtrip")
folderID := repository.NewID()
if err := s.Repository.Resources.InsertFolder(userID, folderID, "Papiers", ""); err != nil {
t.Fatalf("insert folder: %v", err)
}
a, err := s.Upload(userID, multipartFileHeader(t, "a.txt", []byte("contenu-a")), folderID, "")
if err != nil {
t.Fatalf("upload a: %v", err)
}
b, err := s.Upload(userID, multipartFileHeader(t, "b.txt", []byte("contenu-b")), "", "")
if err != nil {
t.Fatalf("upload b: %v", err)
}
// Trashé : exclu de l'export.
if _, err := s.Trash(userID, b.ID); err != nil {
t.Fatalf("trash: %v", err)
}
// Metadata-only (jamais uploadé) : manifest sans octets.
metaID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, metaID, "fantome.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert meta: %v", err)
}
var buf bytes.Buffer
if err := s.Export(&buf, userID, "motdepasse-8"); err != nil {
t.Fatalf("export: %v", err)
}
if buf.Len() == 0 {
t.Fatal("zip vide")
}
// Lecture avec le bon mot de passe (lib standard : échoue sur AES —
// on relit avec la même lib, comme un outil compatible WinZip AES).
zr, err := azip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("open zip: %v", err)
}
names := map[string]bool{}
var manifestRaw []byte
for _, f := range zr.File {
names[f.Name] = true
if !f.IsEncrypted() {
t.Errorf("entrée non chiffrée: %s", f.Name)
}
f.SetPassword("motdepasse-8")
rc, err := f.Open()
if err != nil {
t.Fatalf("open %s: %v", f.Name, err)
}
var content bytes.Buffer
if _, err := content.ReadFrom(rc); err != nil {
rc.Close()
t.Fatalf("read %s: %v", f.Name, err)
}
rc.Close()
switch {
case f.Name == "manifest.json":
manifestRaw = content.Bytes()
case len(content.Bytes()) > 0 && f.Name != "manifest.json":
_ = content
}
}
var manifest ExportManifestFile
if err := json.Unmarshal(manifestRaw, &manifest); err != nil {
t.Fatalf("manifest: %v", err)
}
if manifest.Version != 1 || manifest.UserID != userID || manifest.Truncated {
t.Fatalf("manifest inattendu: %+v", manifest)
}
if len(manifest.Folders) != 1 || manifest.Folders[0].Name != "Papiers" {
t.Fatalf("dossiers: %+v", manifest.Folders)
}
if len(manifest.Files) != 2 {
t.Fatalf("fichiers manifest: %+v (attendu a + fantome, b trashé exclu)", manifest.Files)
}
byID := map[string]ExportFileEntry{}
for _, f := range manifest.Files {
byID[f.ID] = f
}
if byID[a.ID].Path == "" || !byID[a.ID].HasBytes {
t.Errorf("a doit avoir des octets: %+v", byID[a.ID])
}
if byID[metaID].Path != "" || byID[metaID].HasBytes {
t.Errorf("fantome sans octets: %+v", byID[metaID])
}
if !names["manifest.json"] || !names[byID[a.ID].Path] {
t.Fatalf("entrées zip manquantes: %v", names)
}
// Contenu chiffré : illisible sans mot de passe (lib standard échoue),
// et mauvais mot de passe refusé.
stdReader, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("open std: %v", err)
}
for _, f := range stdReader.File {
rc, err := f.Open()
if err == nil {
var tmp bytes.Buffer
_, copyErr := tmp.ReadFrom(rc)
rc.Close()
if copyErr == nil && tmp.Len() > 0 {
t.Errorf("contenu lisible sans mot de passe: %s", f.Name)
}
}
}
zr2, err := azip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("reopen: %v", err)
}
for _, f := range zr2.File {
if f.Name != "manifest.json" {
continue
}
f.SetPassword("mauvais-mot-de-passe")
rc, err := f.Open()
if err == nil {
var tmp bytes.Buffer
_, copyErr := tmp.ReadFrom(rc)
rc.Close()
if copyErr == nil {
t.Error("manifest déchiffré avec un mauvais mot de passe")
}
}
}
}
func TestExportPasswordFloor(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "export-pw")
var buf bytes.Buffer
if err := s.Export(&buf, userID, "court"); err == nil {
t.Fatal("mot de passe court accepté")
}
// Compte vide : zip valide avec manifest seul.
if err := s.Export(&buf, userID, "motdepasse-8"); err != nil {
t.Fatalf("export vide: %v", err)
}
zr, err := azip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("open: %v", err)
}
if len(zr.File) != 1 || zr.File[0].Name != "manifest.json" {
t.Fatalf("export vide inattendu: %v", zr.File)
}
}
+21 -11
View File
@@ -129,6 +129,26 @@ var ErrInvalidLinkType = errors.New("invalid link type or pair")
// hashPhysical computes the SHA-256 of the live bytes (safe resolution,
// same pattern as OpenContent). Absent → ErrNotFound.
func (s *Resources) hashPhysical(ownerID, resourceID string) (string, error) {
resolved, err := s.resolvePhysical(ownerID, resourceID)
if err != nil {
return "", err
}
f, err := os.Open(resolved)
if err != nil {
return "", err
}
defer f.Close()
h := sha256.New()
if _, err := io.Copy(h, f); err != nil {
return "", err
}
return hex.EncodeToString(h.Sum(nil)), nil
}
// resolvePhysical returns the absolute path of the live bytes (safe :
// 32-hex only, regular file, symlink contained in UploadDir).
// Absent → repository.ErrNotFound.
func (s *Resources) resolvePhysical(ownerID, resourceID string) (string, error) {
if !idPattern.MatchString(ownerID) || !idPattern.MatchString(resourceID) {
return "", repository.ErrNotFound
}
@@ -156,17 +176,7 @@ func (s *Resources) hashPhysical(ownerID, resourceID string) (string, error) {
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
continue
}
f, err := os.Open(resolved)
if err != nil {
return "", err
}
h := sha256.New()
if _, err := io.Copy(h, f); err != nil {
f.Close()
return "", err
}
f.Close()
return hex.EncodeToString(h.Sum(nil)), nil
return resolved, nil
}
return "", repository.ErrNotFound
}
+220
View File
@@ -0,0 +1,220 @@
package service
import (
"bytes"
"context"
"errors"
"fmt"
"image"
"image/gif"
"image/jpeg"
"image/png"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"strings"
"time"
"golang.org/x/image/draw"
"golang.org/x/image/webp"
)
// ErrNoPreview signale qu'aucune vignette n'est possible (type non supporté,
// outil absent, octets illisibles). Handlers → 404 NO_PREVIEW (l'UI montre
// l'icône de catégorie au lieu de réessayer).
var ErrNoPreview = errors.New("no preview available")
// MaxPreviewEdge borne la vignette (miroir ThumbnailStore mobile, 512 px).
const MaxPreviewEdge = 512
// previewJPEGQuality compresse les vignettes (galerie rapide, artefacts invisibles à 512 px).
const previewJPEGQuality = 80
// pdftoppmTimeout borne le rendu PDF (binaire externe, jamais bloquant).
const pdftoppmTimeout = 30 * time.Second
// OpenPreview résout la vignette JPEG d'un fichier visible (viewer+, own ou
// shared) : cache `.previews/<resource_id>.jpg` régénéré quand la source a
// changé (taille ou updated_at), sinon servi tel quel. Images : pur Go.
// PDF page 1 : `pdftoppm` (poppler, cf. Dockerfile) ; absent → ErrNoPreview.
func (s *Resources) OpenPreview(userID, resourceID string) (string, error) {
row, err := s.Repo.GetFileVisible(userID, resourceID)
if err != nil {
return "", err
}
dir := filepath.Join(s.UploadDir, ".previews")
cached := filepath.Join(dir, resourceID+".jpg")
if prev, err := s.Repo.GetPreview(resourceID); err == nil {
if prev.SrcSize == row.Size && prev.SrcUpdatedAt.Equal(row.UpdatedAt) {
if fi, serr := os.Stat(cached); serr == nil && fi.Mode().IsRegular() {
return cached, nil
}
}
}
info, err := s.OpenContent(userID, resourceID)
if err != nil {
return "", err
}
kind := previewKind(row.MimeType, info.Path)
var data []byte
switch kind {
case "image":
data, err = renderImagePreview(info.Path)
case "pdf":
data, err = renderPDFPreview(info.Path)
default:
return "", ErrNoPreview
}
if err != nil {
return "", err
}
if err := os.MkdirAll(dir, 0o700); err != nil {
return "", fmt.Errorf("preview dir: %w", err)
}
tmp, err := os.CreateTemp(dir, ".tmp-"+resourceID+".*.jpg")
if err != nil {
return "", fmt.Errorf("preview tmp: %w", err)
}
tmpName := tmp.Name()
if _, err := tmp.Write(data); err != nil {
tmp.Close()
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview write: %w", err)
}
if err := tmp.Close(); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview close: %w", err)
}
if err := os.Chmod(tmpName, 0o600); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview chmod: %w", err)
}
if err := os.Rename(tmpName, cached); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview commit: %w", err)
}
if err := s.Repo.UpsertPreview(resourceID, row.Size, row.UpdatedAt); err != nil {
log.Printf("preview: upsert(%s): %v", resourceID, err)
}
return cached, nil
}
// previewKind classe la source : images décodables Go vs PDF vs le reste.
func previewKind(mimeType, path string) string {
mime := strings.ToLower(mimeType)
if strings.HasPrefix(mime, "image/") {
return "image"
}
ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(path), "."))
switch ext {
case "jpg", "jpeg", "png", "gif", "webp", "bmp":
return "image"
case "pdf":
return "pdf"
}
if mime == "application/pdf" {
return "pdf"
}
return ""
}
// renderImagePreview décode (jpeg/png/gif/webp) et réduit au plus grand côté
// MaxPreviewEdge, sortie JPEG. Source déjà à taille → ré-encodée telle quelle
// (uniformité du cache, coût négligeable à cette échelle).
func renderImagePreview(path string) ([]byte, error) {
f, err := os.Open(path)
if err != nil {
return nil, ErrNoPreview
}
defer f.Close()
var img image.Image
lower := strings.ToLower(path)
switch {
case strings.HasSuffix(lower, ".png"):
img, err = png.Decode(f)
case strings.HasSuffix(lower, ".gif"):
img, err = gif.Decode(f)
case strings.HasSuffix(lower, ".webp"):
img, err = webp.Decode(f)
default:
img, err = jpeg.Decode(f)
if err != nil {
// Extension menteuse (ex. .jpg contenant du PNG) : tente le PNG.
if _, serr := f.Seek(0, io.SeekStart); serr == nil {
img, err = png.Decode(f)
}
}
}
if err != nil {
return nil, ErrNoPreview
}
return encodeScaled(img)
}
// renderPDFPreview rend la page 1 via `pdftoppm` (poppler) puis réduit.
// Binaire absent ou PDF illisible → ErrNoPreview (jamais 500).
func renderPDFPreview(path string) ([]byte, error) {
if _, err := exec.LookPath("pdftoppm"); err != nil {
return nil, ErrNoPreview
}
dir, err := os.MkdirTemp("", "kazier-preview-*")
if err != nil {
return nil, fmt.Errorf("preview tmpdir: %w", err)
}
defer os.RemoveAll(dir)
prefix := filepath.Join(dir, "page")
ctx, cancel := context.WithTimeout(context.Background(), pdftoppmTimeout)
defer cancel()
// -r 50 : assez pour 512 px après réduction, sans pic mémoire.
cmd := exec.CommandContext(ctx, "pdftoppm", "-jpeg", "-r", "50", "-f", "1", "-l", "1", "-singlefile", path, prefix)
if out, err := cmd.CombinedOutput(); err != nil {
log.Printf("preview: pdftoppm: %v (%s)", err, strings.TrimSpace(string(out)))
return nil, ErrNoPreview
}
rendered := prefix + ".jpg"
f, err := os.Open(rendered)
if err != nil {
return nil, ErrNoPreview
}
defer f.Close()
img, err := jpeg.Decode(f)
if err != nil {
return nil, ErrNoPreview
}
return encodeScaled(img)
}
// encodeScaled réduit au plus grand côté MaxPreviewEdge (ratio préservé) et
// encode en JPEG. Images déjà petites : recopiées à l'identique.
func encodeScaled(img image.Image) ([]byte, error) {
bounds := img.Bounds()
w, h := bounds.Dx(), bounds.Dy()
if w <= 0 || h <= 0 {
return nil, ErrNoPreview
}
scaled := img
max := w
if h > max {
max = h
}
if max > MaxPreviewEdge {
ratio := float64(MaxPreviewEdge) / float64(max)
nw, nh := int(float64(w)*ratio+0.5), int(float64(h)*ratio+0.5)
if nw < 1 {
nw = 1
}
if nh < 1 {
nh = 1
}
dst := image.NewRGBA(image.Rect(0, 0, nw, nh))
draw.CatmullRom.Scale(dst, dst.Bounds(), img, bounds, draw.Over, nil)
scaled = dst
}
var buf bytes.Buffer
if err := jpeg.Encode(&buf, scaled, &jpeg.Options{Quality: previewJPEGQuality}); err != nil {
return nil, fmt.Errorf("preview encode: %w", err)
}
return buf.Bytes(), nil
}
+160
View File
@@ -0,0 +1,160 @@
package service
import (
"bytes"
"image"
"image/color"
"image/jpeg"
"image/png"
"os"
"os/exec"
"path/filepath"
"testing"
"github.com/kazier/backend/dbtest"
"github.com/kazier/backend/repository"
)
// newPreviewStore : comme newServiceStore mais avec un quota d'upload réaliste
// (les images de test dépassent les 100 octets du store par défaut).
func newPreviewStore(t *testing.T) *Resources {
t.Helper()
conn := dbtest.OpenTestDatabase(t, serviceTestURL)
repo := repository.NewRepository(conn)
return NewResources(repo, t.TempDir(), 10<<20)
}
// testImageBytes génère un JPEG 800x600 uni (décodable sans fixture).
func testImageBytes(t *testing.T) []byte {
t.Helper()
img := image.NewRGBA(image.Rect(0, 0, 800, 600))
for y := 0; y < 600; y++ {
for x := 0; x < 800; x++ {
img.Set(x, y, color.RGBA{uint8(x % 256), uint8(y % 256), 128, 255})
}
}
var buf bytes.Buffer
if err := jpeg.Encode(&buf, img, nil); err != nil {
t.Fatal(err)
}
return buf.Bytes()
}
func TestOpenPreviewImage(t *testing.T) {
s := newPreviewStore(t)
userID := mustCreateUser(t, s.Repository, "preview-img")
dto, err := s.Upload(userID, multipartFileHeader(t, "photo.jpg", testImageBytes(t)), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
path, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview: %v", err)
}
f, err := os.Open(path)
if err != nil {
t.Fatalf("open preview: %v", err)
}
defer f.Close()
img, err := jpeg.Decode(f)
if err != nil {
t.Fatalf("preview n'est pas un JPEG: %v", err)
}
b := img.Bounds()
if b.Dx() > MaxPreviewEdge || b.Dy() > MaxPreviewEdge {
t.Fatalf("vignette trop grande: %dx%d", b.Dx(), b.Dy())
}
if b.Dx() != MaxPreviewEdge {
t.Fatalf("plus grand côté = %d, attendu %d", b.Dx(), MaxPreviewEdge)
}
// Second appel : cache (même fichier, pas de régénération).
fi1, _ := os.Stat(path)
path2, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview 2: %v", err)
}
fi2, _ := os.Stat(path2)
if !os.SameFile(fi1, fi2) {
t.Fatal("le cache aurait dû être servi")
}
// Overwrite → la vignette suit les nouveaux octets.
dto2, err := s.Upload(userID, multipartFileHeader(t, "photo.jpg", testImageBytes(t)), "", dto.ID)
if err != nil {
t.Fatalf("overwrite: %v", err)
}
_ = dto2
path3, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview 3: %v", err)
}
fi3, _ := os.Stat(path3)
if os.SameFile(fi2, fi3) {
t.Fatal("la vignette aurait dû être régénérée après overwrite")
}
}
func TestOpenPreviewUnsupported(t *testing.T) {
s := newPreviewStore(t)
userID := mustCreateUser(t, s.Repository, "preview-no")
dto, err := s.Upload(userID, multipartFileHeader(t, "notes.txt", []byte("hello")), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
if _, err := s.OpenPreview(userID, dto.ID); err != ErrNoPreview {
t.Fatalf("txt : attendu ErrNoPreview, got %v", err)
}
// Trashé → NOT_FOUND (pas NO_PREVIEW : invisible d'abord).
if _, err := s.Trash(userID, dto.ID); err != nil {
t.Fatalf("trash: %v", err)
}
if _, err := s.OpenPreview(userID, dto.ID); err != repository.ErrNotFound {
t.Fatalf("trashé : attendu NOT_FOUND, got %v", err)
}
// Étranger → NOT_FOUND.
other := mustCreateUser(t, s.Repository, "preview-no-x")
dto2, err := s.Upload(other, multipartFileHeader(t, "img.png", testPNGBytes(t)), "", "")
if err != nil {
t.Fatalf("upload other: %v", err)
}
if _, err := s.OpenPreview(userID, dto2.ID); err != repository.ErrNotFound {
t.Fatalf("étranger : attendu NOT_FOUND, got %v", err)
}
}
func testPNGBytes(t *testing.T) []byte {
t.Helper()
img := image.NewRGBA(image.Rect(0, 0, 100, 100))
var buf bytes.Buffer
if err := png.Encode(&buf, img); err != nil {
t.Fatal(err)
}
return buf.Bytes()
}
func TestOpenPreviewPDF(t *testing.T) {
if _, err := exec.LookPath("pdftoppm"); err != nil {
t.Skip("pdftoppm absent (hors Docker) — rendu PDF non testé ici")
}
s := newPreviewStore(t)
userID := mustCreateUser(t, s.Repository, "preview-pdf")
pdf := []byte("%PDF-1.4\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj\n3 0 obj<</Type/Page/Parent 2 0 R/MediaBox[0 0 200 200]>>endobj\ntrailer<</Root 1 0 R>>\n")
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.pdf", pdf), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
path, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview pdf: %v", err)
}
if fi, err := os.Stat(path); err != nil || fi.Size() == 0 {
t.Fatalf("vignette pdf absente: %v", err)
}
_ = filepath.Separator
}