@aurabase/aurabase-js 0.3.0 → 0.3.1

package/packages/aurabase/tests/storage-transform-e2e.test.ts

@@ -1,684 +0,0 @@
-// ---------------------------------------------------------------------------
-// E2E réel des transforms image Storage (stack live) — Lot A / Task A3 du plan
-// docs/superpowers/plans/2026-07-13-sdk-storage-transforms.md.
-//
-// Ce test ne mocke rien : il upload un VRAI PNG (généré en pur JS, aucun
-// outil système, aucune lib image tierce — voir makePng ci-dessous) contre le
-// backend aura-storage réel, puis vérifie que le rendu transformé (resize)
-// produit effectivement une image de la largeur demandée, via les deux
-// chemins qui exposent `options.transform` côté SDK :
-//   1. download(bucket, key, { transform }) — requête directe authentifiée.
-//   2. createSignedUrl(bucket, key, ttl, { transform }) puis fetch(url) —
-//      dérisquage de StorageService.createSignedUrl : les query params de
-//      transform sont appendés APRÈS réception de l'URL signée (ils sont
-//      HORS HMAC, cf. commentaire StorageService.ts). Si le backend couvrait
-//      la signature sur l'URL complète (ou sur un jeu de query params figé),
-//      un fetch de cette URL renverrait 403 — ce test le détecte et le
-//      signale explicitement (message dédié) plutôt qu'un échec opaque
-//      d'assertion sur la largeur.
-//
-// Générateur PNG (makePng) : implémentation minimale mais VALIDE du format —
-// signature PNG (8 octets) + chunk IHDR (width/height big-endian, bit depth
-// 8, color type 2 = RGB truecolor, pas de palette) + chunk IDAT (une seule
-// bande de scanlines, chacune préfixée d'un octet de filtre 0 = "None",
-// compressées avec zlib natif Node `deflateSync` — la crate `image` Rust
-// utilisée côté backend décode du zlib/DEFLATE standard, donc ce choix est
-// interopérable) + chunk IEND. Chaque chunk porte son CRC32 (implémentation
-// table-based standard, incluse ci-dessous — Node n'expose pas de crc32
-// public dans `node:zlib`). readPngWidth relit la largeur directement depuis
-// l'IHDR (octets 16-19, big-endian) de l'image reçue en retour, sans
-// dépendre d'un décodeur PNG complet.
-//
-// Gaté par RUN_E2E + credentials (identique aux autres *-e2e.test.ts) :
-// describe.runIf(RUN) SKIPPE proprement la suite entière (pas d'échec)
-// quand les variables d'env manquent — vérifié sans RUN_E2E via
-// `pnpm --filter aurabase test`.
-// ---------------------------------------------------------------------------
-
-import { describe, it, expect } from 'vitest'
-import { deflateSync } from 'node:zlib'
-import { createAdminClient } from '../src/index'
-import type { AuraResponse } from '../src/index'
-
-const URL = process.env.AURA_E2E_URL
-const PROJECT = process.env.AURA_E2E_PROJECT
-const ANON = process.env.AURA_E2E_ANON_KEY
-const SERVICE = process.env.AURA_E2E_SERVICE_KEY
-const RUN = Boolean(process.env.RUN_E2E && URL && PROJECT && ANON && SERVICE)
-
-/** Statuts transitoires observés sur la stack locale (timeout gateway→service sous charge). */
-const TRANSIENT_STATUS = new Set([408, 429, 502, 503, 504])
-
-/** Rejoue une requête (ou un builder paresseux comme BlobDownloadBuilder, tous deux
- *  PromiseLike) tant qu'elle renvoie un statut transitoire, borné (cf. auth-e2e.test.ts /
- *  readme-smoke-e2e.test.ts). */
-async function retryTransient<T>(fn: () => PromiseLike<AuraResponse<T>>): Promise<AuraResponse<T>> {
-  let res = await fn()
-  for (let i = 0; i < 10 && res.error && TRANSIENT_STATUS.has(res.error.status); i++) {
-    await new Promise((r) => setTimeout(r, 1000))
-    res = await fn()
-  }
-  return res
-}
-
-// ---------------------------------------------------------------------------
-// Générateur PNG minimal (pur JS, aucun outil système / lib image tierce).
-// ---------------------------------------------------------------------------
-
-/** Table CRC32 standard (polynôme 0xEDB88320 — identique zlib/gzip/PNG). */
-const CRC_TABLE: Uint32Array = (() => {
-  const table = new Uint32Array(256)
-  for (let n = 0; n < 256; n++) {
-    let c = n
-    for (let k = 0; k < 8; k++) {
-      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1
-    }
-    table[n] = c >>> 0
-  }
-  return table
-})()
-
-function crc32(bytes: Uint8Array): number {
-  let c = 0xffffffff
-  for (let i = 0; i < bytes.length; i++) {
-    c = CRC_TABLE[(c ^ bytes[i]) & 0xff] ^ (c >>> 8)
-  }
-  return (c ^ 0xffffffff) >>> 0
-}
-
-function u32be(n: number): Uint8Array {
-  return new Uint8Array([(n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff])
-}
-
-function concatBytes(...parts: Uint8Array[]): Uint8Array {
-  const total = parts.reduce((sum, p) => sum + p.length, 0)
-  const out = new Uint8Array(total)
-  let offset = 0
-  for (const p of parts) {
-    out.set(p, offset)
-    offset += p.length
-  }
-  return out
-}
-
-function pngChunk(type: string, data: Uint8Array): Uint8Array {
-  const typeBytes = new Uint8Array(type.split('').map((c) => c.charCodeAt(0)))
-  const crcInput = concatBytes(typeBytes, data)
-  return concatBytes(u32be(data.length), typeBytes, data, u32be(crc32(crcInput)))
-}
-
-/**
- * Génère un PNG VALIDE d'un carré uni `width`x`height`, en pur JS.
- * RGB 8 bits par canal (color type 2, pas de palette, pas d'alpha) — décodable
- * par n'importe quel décodeur PNG standard, y compris la crate `image` (Rust)
- * utilisée par le backend aura-storage pour le rendu des transforms.
- */
-function makePng(width: number, height: number): Uint8Array {
-  const SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10])
-
-  const ihdrData = concatBytes(
-    u32be(width),
-    u32be(height),
-    // bit depth 8, color type 2 (RGB truecolor), compression 0, filter 0, interlace 0
-    new Uint8Array([8, 2, 0, 0, 0]),
-  )
-  const ihdr = pngChunk('IHDR', ihdrData)
-
-  // Une bande de scanlines : 1 octet de filtre (0 = "None") + width*3 octets RGB par ligne.
-  const stride = 1 + width * 3
-  const raw = new Uint8Array(stride * height)
-  // Bruit RGB déterministe (LCG) : une image UNIE compresse identiquement en JPEG
-  // quelle que soit la qualité (rien à dégrader) → le test quality:20 vs :90 serait
-  // non-discriminant. Un contenu haute-fréquence rend l'effet de `quality` mesurable.
-  let seed = 0x12345678
-  const nextByte = () => {
-    seed = (seed * 1103515245 + 12345) & 0x7fffffff
-    return (seed >>> 16) & 0xff
-  }
-  for (let y = 0; y < height; y++) {
-    const rowStart = y * stride
-    raw[rowStart] = 0 // filtre None
-    for (let x = 0; x < width; x++) {
-      const px = rowStart + 1 + x * 3
-      raw[px] = nextByte()
-      raw[px + 1] = nextByte()
-      raw[px + 2] = nextByte()
-    }
-  }
-  const compressed = deflateSync(raw)
-  const idat = pngChunk('IDAT', new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength))
-
-  const iend = pngChunk('IEND', new Uint8Array(0))
-
-  return concatBytes(SIGNATURE, ihdr, idat, iend)
-}
-
-/** Lit la largeur d'un PNG directement depuis son IHDR (octets 16-19, big-endian). */
-function readPngWidth(bytes: Uint8Array): number {
-  return ((bytes[16] << 24) | (bytes[17] << 16) | (bytes[18] << 8) | bytes[19]) >>> 0
-}
-
-describe.runIf(RUN)('storage transforms E2E réel (stack live) — resize via download / createSignedUrl', () => {
-  it(
-    'upload PNG 200x200 → download(transform width:50) === 50 → createSignedUrl(transform width:60) → fetch === 60',
-    async () => {
-      const admin = createAdminClient(URL!, PROJECT!, SERVICE!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const bucket = `e2e-storage-transform-${suffix}`
-      const path = 'img.png'
-
-      let created = false
-      // upload() génère une clé serveur `<uuid>.<ext>` (renvoyée dans data.key) ;
-      // le `path` fourni n'est PAS la clé finale. On download/signe/supprime via cette clé.
-      let uploadedKey = path
-      try {
-        const createRes = await retryTransient(() =>
-          admin.storage.createBucket(bucket, {
-            public: false,
-            allowedMimeTypes: ['image/png', 'image/webp', 'image/jpeg'],
-          }),
-        )
-        if (createRes.error && TRANSIENT_STATUS.has(createRes.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP (infra: createBucket indisponible après retries — statut transitoire ' +
-              `${createRes.error.status} persistant) — NON un succès : assertions transform ignorées.`,
-          )
-          return
-        }
-        expect(createRes.error).toBeNull()
-        created = true
-
-        const png = makePng(200, 200)
-        const uploadRes = await admin.storage.upload(bucket, path, new Blob([png], { type: 'image/png' }), {
-          contentType: 'image/png',
-        })
-        expect(uploadRes.error).toBeNull()
-        uploadedKey = uploadRes.data?.key ?? path
-
-        // 1. download(bucket, key, { transform: { width: 50, resize: 'cover' } })
-        const downloadRes = await retryTransient(() =>
-          admin.storage.download(bucket, uploadedKey, { transform: { width: 50, resize: 'cover' } }),
-        )
-        if (downloadRes.error && TRANSIENT_STATUS.has(downloadRes.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP download transform (infra: statut transitoire ' +
-              `${downloadRes.error.status} persistant après retries).`,
-          )
-          return
-        }
-        expect(downloadRes.error).toBeNull()
-        expect(downloadRes.data).not.toBeNull()
-        const downloadedBuf = new Uint8Array(await downloadRes.data!.arrayBuffer())
-        expect(readPngWidth(downloadedBuf)).toBe(50)
-
-        // 2. createSignedUrl(bucket, key, ttl, { transform: { width: 60 } }) puis fetch réel —
-        //    dérisquage de la couverture HMAC sur les params transform.
-        const signedRes = await retryTransient(() =>
-          admin.storage.createSignedUrl(bucket, uploadedKey, 600, { transform: { width: 60 } }),
-        )
-        if (signedRes.error && TRANSIENT_STATUS.has(signedRes.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP createSignedUrl transform (infra: statut transitoire ' +
-              `${signedRes.error.status} persistant après retries).`,
-          )
-          return
-        }
-        expect(signedRes.error).toBeNull()
-        expect(signedRes.data?.url).toBeTruthy()
-
-        const signedResponse = await fetch(signedRes.data!.url)
-        if (signedResponse.status === 403) {
-          throw new Error(
-            '[storage-transform-e2e] fetch(signedUrl) → 403 : la signature HMAC ne couvre PAS les query params ' +
-              "de transform (width/height/fit/...) appendus après réception de l'URL signée (cf. StorageService." +
-              'createSignedUrl). Dérisquage NÉGATIF : la signature doit être élargie côté backend (ou générée ' +
-              'après ajout des params) avant de considérer ce flux transform+signedUrl comme utilisable.',
-          )
-        }
-        if (TRANSIENT_STATUS.has(signedResponse.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            `[storage-transform-e2e] SKIP fetch(signedUrl) (infra: statut transitoire ${signedResponse.status} sur le fetch).`,
-          )
-          return
-        }
-        expect(signedResponse.ok).toBe(true)
-        const signedBuf = new Uint8Array(await signedResponse.arrayBuffer())
-        expect(readPngWidth(signedBuf)).toBe(60)
-      } finally {
-        if (created) {
-          try {
-            await admin.storage.remove(bucket, [uploadedKey])
-          } catch {
-            // best-effort cleanup
-          }
-          try {
-            await admin.storage.deleteBucket(bucket)
-          } catch {
-            // best-effort cleanup
-          }
-        }
-      }
-    },
-    120_000,
-  )
-
-  // -------------------------------------------------------------------------
-  // Task B2 (Lot B) — durcissement backend : quality effectif, borne dimensions,
-  // flag img_transform_enabled. Étend la couverture de l'E2E réel ci-dessus
-  // après le rebuild aura-storage qui applique effectivement `quality`.
-  // -------------------------------------------------------------------------
-
-  it(
-    'download(transform quality:20 vs quality:90, format jpeg) → quality:20 nettement plus léger (quality appliqué)',
-    async () => {
-      const admin = createAdminClient(URL!, PROJECT!, SERVICE!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const bucket = `e2e-storage-transform-quality-${suffix}`
-      const path = 'img.png'
-
-      let created = false
-      let uploadedKey = path
-      try {
-        const createRes = await retryTransient(() =>
-          admin.storage.createBucket(bucket, {
-            public: false,
-            allowedMimeTypes: ['image/png', 'image/webp', 'image/jpeg'],
-          }),
-        )
-        if (createRes.error && TRANSIENT_STATUS.has(createRes.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP quality (infra: createBucket indisponible après retries — statut ' +
-              `transitoire ${createRes.error.status} persistant) — NON un succès : assertion quality ignorée.`,
-          )
-          return
-        }
-        expect(createRes.error).toBeNull()
-        created = true
-
-        const png = makePng(200, 200)
-        const uploadRes = await admin.storage.upload(bucket, path, new Blob([png], { type: 'image/png' }), {
-          contentType: 'image/png',
-        })
-        expect(uploadRes.error).toBeNull()
-        uploadedKey = uploadRes.data?.key ?? path
-
-        const res20 = await retryTransient(() =>
-          admin.storage.download(bucket, uploadedKey, { transform: { width: 150, format: 'jpeg', quality: 20 } }),
-        )
-        if (res20.error && TRANSIENT_STATUS.has(res20.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP quality (infra: statut transitoire ' +
-              `${res20.error.status} persistant sur quality:20).`,
-          )
-          return
-        }
-        expect(res20.error).toBeNull()
-        expect(res20.data).not.toBeNull()
-
-        const res90 = await retryTransient(() =>
-          admin.storage.download(bucket, uploadedKey, { transform: { width: 150, format: 'jpeg', quality: 90 } }),
-        )
-        if (res90.error && TRANSIENT_STATUS.has(res90.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP quality (infra: statut transitoire ' +
-              `${res90.error.status} persistant sur quality:90).`,
-          )
-          return
-        }
-        expect(res90.error).toBeNull()
-        expect(res90.data).not.toBeNull()
-
-        const size20 = res20.data!.size
-        const size90 = res90.data!.size
-        // "Nettement" plus léger : la quantification JPEG à quality:20 doit produire un fichier
-        // sensiblement plus petit qu'à quality:90 (même dimensions, même format de sortie).
-        // Preuve que `quality` est effectivement propagé à l'encodeur côté backend (Lot B).
-        expect(size20).toBeLessThan(size90)
-        expect(size20).toBeLessThan(size90 * 0.8)
-      } finally {
-        if (created) {
-          try {
-            await admin.storage.remove(bucket, [uploadedKey])
-          } catch {
-            // best-effort cleanup
-          }
-          try {
-            await admin.storage.deleteBucket(bucket)
-          } catch {
-            // best-effort cleanup
-          }
-        }
-      }
-    },
-    120_000,
-  )
-
-  it(
-    'download(transform width:999999) → 400 (borne MAX_TRANSFORM_DIMENSION dépassée)',
-    async () => {
-      const admin = createAdminClient(URL!, PROJECT!, SERVICE!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const bucket = `e2e-storage-transform-dims-${suffix}`
-      const path = 'img.png'
-
-      let created = false
-      let uploadedKey = path
-      try {
-        const createRes = await retryTransient(() =>
-          admin.storage.createBucket(bucket, { public: false, allowedMimeTypes: ['image/png'] }),
-        )
-        if (createRes.error && TRANSIENT_STATUS.has(createRes.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP dims (infra: createBucket indisponible après retries — statut ' +
-              `transitoire ${createRes.error.status} persistant) — NON un succès : assertion 400 ignorée.`,
-          )
-          return
-        }
-        expect(createRes.error).toBeNull()
-        created = true
-
-        const png = makePng(200, 200)
-        const uploadRes = await admin.storage.upload(bucket, path, new Blob([png], { type: 'image/png' }), {
-          contentType: 'image/png',
-        })
-        expect(uploadRes.error).toBeNull()
-        uploadedKey = uploadRes.data?.key ?? path
-
-        // width au-delà de MAX_TRANSFORM_DIMENSION (2500px, services/aura-storage/src/transform/mod.rs)
-        // doit être rejeté par `validate_dimensions` AVANT tout décodage/rescale — HTTP 400.
-        const res = await retryTransient(() =>
-          admin.storage.download(bucket, uploadedKey, { transform: { width: 999_999 } }),
-        )
-        if (res.error && TRANSIENT_STATUS.has(res.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP dims (infra: statut transitoire ' +
-              `${res.error.status} persistant sur width:999999).`,
-          )
-          return
-        }
-        expect(res.data).toBeNull()
-        expect(res.error).not.toBeNull()
-        expect(res.error!.status).toBe(400)
-      } finally {
-        if (created) {
-          try {
-            await admin.storage.remove(bucket, [uploadedKey])
-          } catch {
-            // best-effort cleanup
-          }
-          try {
-            await admin.storage.deleteBucket(bucket)
-          } catch {
-            // best-effort cleanup
-          }
-        }
-      }
-    },
-    60_000,
-  )
-
-  it(
-    'flag projet img_transform_enabled=false (PUT /v1/storage/{project}/settings, service_role) → transform 403, réactivation (best-effort)',
-    async () => {
-      const admin = createAdminClient(URL!, PROJECT!, SERVICE!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const bucket = `e2e-storage-transform-flag-${suffix}`
-      const path = 'img.png'
-      // Même préfixe que StorageService (`/v1/storage/${projectId}`) : pas de méthode SDK dédiée
-      // pour les settings storage, donc fetch direct authentifié par la service key (comme le
-      // ferait un appel admin serveur-à-serveur — cf. StorageService.ts prefix getter).
-      const settingsUrl = `${admin.baseUrl}/v1/storage/${admin.projectId}/settings`
-
-      const putImgTransformEnabled = (enabled: boolean) =>
-        fetch(settingsUrl, {
-          method: 'PUT',
-          headers: { apikey: SERVICE!, 'content-type': 'application/json' },
-          body: JSON.stringify({ img_transform_enabled: enabled }),
-        })
-
-      let created = false
-      let uploadedKey = path
-      let disabled = false
-      try {
-        const createRes = await retryTransient(() =>
-          admin.storage.createBucket(bucket, { public: false, allowedMimeTypes: ['image/png'] }),
-        )
-        if (createRes.error && TRANSIENT_STATUS.has(createRes.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP flag 403 (infra: createBucket indisponible après retries — statut ' +
-              `transitoire ${createRes.error.status} persistant).`,
-          )
-          return
-        }
-        expect(createRes.error).toBeNull()
-        created = true
-
-        const png = makePng(200, 200)
-        const uploadRes = await admin.storage.upload(bucket, path, new Blob([png], { type: 'image/png' }), {
-          contentType: 'image/png',
-        })
-        expect(uploadRes.error).toBeNull()
-        uploadedKey = uploadRes.data?.key ?? path
-
-        let disableRes: Response
-        try {
-          disableRes = await putImgTransformEnabled(false)
-        } catch (err) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] flag 403 non testé via SDK (couvert par cargo test backend) — ' +
-              `fetch PUT ${settingsUrl} a levé : ${err instanceof Error ? err.message : String(err)}.`,
-          )
-          return
-        }
-        if (!disableRes.ok) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] flag 403 non testé via SDK (couvert par cargo test backend) — ' +
-              `PUT ${settingsUrl} → ${disableRes.status} (endpoint settings non accessible proprement ` +
-              'depuis ce contexte E2E, ex. clé service_role sans les droits attendus).',
-          )
-          return
-        }
-        disabled = true
-
-        const res = await retryTransient(() =>
-          admin.storage.download(bucket, uploadedKey, { transform: { width: 100 } }),
-        )
-        if (res.error && TRANSIENT_STATUS.has(res.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP flag 403 (infra: statut transitoire ' +
-              `${res.error.status} persistant après désactivation du flag).`,
-          )
-          return
-        }
-        expect(res.data).toBeNull()
-        expect(res.error).not.toBeNull()
-        expect(res.error!.status).toBe(403)
-      } finally {
-        if (disabled) {
-          try {
-            const reenableRes = await putImgTransformEnabled(true)
-            if (!reenableRes.ok) {
-              // eslint-disable-next-line no-console
-              console.warn(
-                `[storage-transform-e2e] réactivation img_transform_enabled a échoué (${reenableRes.status}) — ` +
-                  'vérifier manuellement les settings storage du projet E2E.',
-              )
-            }
-          } catch (err) {
-            // eslint-disable-next-line no-console
-            console.warn(
-              '[storage-transform-e2e] réactivation img_transform_enabled a levé — vérifier manuellement les ' +
-                `settings storage du projet E2E : ${err instanceof Error ? err.message : String(err)}.`,
-            )
-          }
-        }
-        if (created) {
-          try {
-            await admin.storage.remove(bucket, [uploadedKey])
-          } catch {
-            // best-effort cleanup
-          }
-          try {
-            await admin.storage.deleteBucket(bucket)
-          } catch {
-            // best-effort cleanup
-          }
-        }
-      }
-    },
-    60_000,
-  )
-
-  // -------------------------------------------------------------------------
-  // Lot C — cache des dérivés (C1/C2) : le backend cache désormais les images
-  // transformées et expose `x-aura-cache: HIT|MISS` sur la branche transform.
-  // Ce test fetch RÉELLEMENT l'URL signée (le SDK download() ne donne pas
-  // accès aux headers de réponse) : 1er fetch MISS (dérivé créé), 2e fetch de
-  // la MÊME URL signée HIT (servi du cache). Si le header est absent (backend
-  // pas rebuildé), on le signale explicitement plutôt qu'un échec opaque —
-  // seul le HIT/MISS est asserté quand le header est présent.
-  // -------------------------------------------------------------------------
-
-  it(
-    "createSignedUrl(transform) → fetch 1: x-aura-cache=MISS, fetch 2 (même URL): x-aura-cache=HIT",
-    async () => {
-      const admin = createAdminClient(URL!, PROJECT!, SERVICE!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const bucket = `e2e-storage-transform-cache-${suffix}`
-      const path = 'img.png'
-
-      let created = false
-      let uploadedKey = path
-      try {
-        const createRes = await retryTransient(() =>
-          admin.storage.createBucket(bucket, {
-            public: false,
-            allowedMimeTypes: ['image/png', 'image/webp', 'image/jpeg'],
-          }),
-        )
-        if (createRes.error && TRANSIENT_STATUS.has(createRes.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP cache (infra: createBucket indisponible après retries — statut ' +
-              `transitoire ${createRes.error.status} persistant) — NON un succès : assertions cache ignorées.`,
-          )
-          return
-        }
-        expect(createRes.error).toBeNull()
-        created = true
-
-        const png = makePng(200, 200)
-        const uploadRes = await admin.storage.upload(bucket, path, new Blob([png], { type: 'image/png' }), {
-          contentType: 'image/png',
-        })
-        expect(uploadRes.error).toBeNull()
-        uploadedKey = uploadRes.data?.key ?? path
-
-        const signedRes = await retryTransient(() =>
-          admin.storage.createSignedUrl(bucket, uploadedKey, 600, {
-            // On garde le format PNG d'origine (pas de `format`) pour pouvoir relire
-            // la largeur via readPngWidth ; le cache (x-aura-cache) est indépendant du format.
-            transform: { width: 40 },
-          }),
-        )
-        if (signedRes.error && TRANSIENT_STATUS.has(signedRes.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] SKIP cache (infra: statut transitoire ' +
-              `${signedRes.error.status} persistant sur createSignedUrl).`,
-          )
-          return
-        }
-        expect(signedRes.error).toBeNull()
-        expect(signedRes.data?.url).toBeTruthy()
-        const signedUrl = signedRes.data!.url
-
-        // Fetch 1 — dérivé pas encore en cache → attendu MISS.
-        const first = await fetch(signedUrl)
-        if (TRANSIENT_STATUS.has(first.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            `[storage-transform-e2e] SKIP cache (infra: statut transitoire ${first.status} sur le 1er fetch).`,
-          )
-          return
-        }
-        expect(first.ok).toBe(true)
-        const firstCacheHeader = first.headers.get('x-aura-cache')
-        const firstBuf = new Uint8Array(await first.arrayBuffer())
-
-        if (firstCacheHeader === null) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[storage-transform-e2e] header x-aura-cache absent (backend cache non déployé ?) — ' +
-              "vérification du contenu (largeur) faite, mais l'assertion HIT/MISS est ignorée.",
-          )
-          expect(readPngWidth(firstBuf)).toBe(40)
-        } else {
-          expect(firstCacheHeader).toBe('MISS')
-          expect(readPngWidth(firstBuf)).toBe(40)
-
-          // Fetch 2 — même URL signée, dérivé désormais en cache → attendu HIT.
-          const second = await fetch(signedUrl)
-          if (TRANSIENT_STATUS.has(second.status)) {
-            // eslint-disable-next-line no-console
-            console.warn(
-              `[storage-transform-e2e] SKIP cache (infra: statut transitoire ${second.status} sur le 2e fetch).`,
-            )
-            return
-          }
-          expect(second.ok).toBe(true)
-          const secondCacheHeader = second.headers.get('x-aura-cache')
-          const secondBuf = new Uint8Array(await second.arrayBuffer())
-
-          expect(secondCacheHeader).toBe('HIT')
-          // Même contenu servi depuis le cache : largeur identique et même taille en octets.
-          expect(readPngWidth(secondBuf)).toBe(40)
-          expect(secondBuf.byteLength).toBe(firstBuf.byteLength)
-        }
-
-        // Invalidation sur delete (purge_derivatives) : couverte côté backend par cargo test —
-        // best-effort ici, on ne fait que documenter/tenter sans faire échouer le test E2E si le
-        // header est absent ou le comportement diffère.
-        const deleteRes = await admin.storage.remove(bucket, [uploadedKey])
-        if (!deleteRes.error) {
-          const afterDelete = await fetch(signedUrl)
-          if (!TRANSIENT_STATUS.has(afterDelete.status)) {
-            // eslint-disable-next-line no-console
-            console.warn(
-              '[storage-transform-e2e] best-effort post-delete : fetch(signedUrl) après remove() → ' +
-                `statut ${afterDelete.status} (invalidation cache prouvée par cargo test backend purge_derivatives, ` +
-                'non re-assertée ici).',
-            )
-          }
-        }
-      } finally {
-        if (created) {
-          try {
-            await admin.storage.remove(bucket, [uploadedKey])
-          } catch {
-            // best-effort cleanup (déjà supprimé ci-dessus dans le cas nominal)
-          }
-          try {
-            await admin.storage.deleteBucket(bucket)
-          } catch {
-            // best-effort cleanup
-          }
-        }
-      }
-    },
-    120_000,
-  )
-})