Files
Kazier/backend/service/export_test.go
T
venture 4316da578f
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
V3 S7 : preview cloud + export chiffré + release 1.2.0
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.
2026-09-26 15:08:31 +02:00

164 lines
4.7 KiB
Go

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)
}
}