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.
164 lines
4.7 KiB
Go
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)
|
|
}
|
|
}
|