@tellescope/sdk 2.0.0-beta.1 → 2.0.0-beta.3

package/src/tests/api_tests/file_download_unicode_names.test.ts

@@ -2,15 +2,17 @@ require('source-map-support').install();
 
 import axios from "axios"
 import * as buffer from 'buffer'
-import { Session } from "../../sdk"
 import {
-  assert,
-  log_header,
-} from "@tellescope/testing"
-import { setup_tests } from "../setup"
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
 /**
  * A presigned download URL signs response-content-disposition, which S3 validates: it rejects any
  * value containing a character above U+00FF with 400 InvalidArgument "Header value cannot be
@@ -20,7 +22,13 @@ const host = process.env.API_URL || 'http://localhost:8080' as const
  * S3 on every fetch.
  *
  * This test is the end-to-end check: it uploads files with those names and actually fetches the
- * returned URL, which is the only thing that exercises S3's validation.
+ * returned URL, which is the only thing that exercises S3's validation. The S3 round-trip
+ * (prepare_file_upload -> UPLOAD -> confirm_file_upload) is an environment dependency, unchanged by
+ * the move onto an isolated tenant.
+ *
+ * Runs on its own provisioned tenant and records Check[] instead of asserting: `assert` calls
+ * process.exit, which inside a pooled `run` would skip every concurrently running suite's teardown
+ * and strand its tenant permanently.
  */
 
 // Built from code points rather than written out, so that this file stays pure ASCII and so that a
@@ -68,150 +76,191 @@ const TEST_NAMES: { name: string, label: string, expectExtValue: boolean }[] = [
   },
 ]
 
-export const file_download_unicode_names_tests = async ({ sdk }: { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("File Download URL with Unicode Filenames")
+export const file_download_unicode_names_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
 
-  const fileIds: string[] = []
-
-  const uploadFile = async (name: string) => {
-    const buff = buffer.Buffer.from(`test file content for ${JSON.stringify(name)}`)
-    const { presignedUpload, file } = await sdk.api.files.prepare_file_upload({
-      name,
-      type: 'application/pdf',
-      size: buff.byteLength,
-    })
-    await sdk.UPLOAD(presignedUpload as any, buff)
-    await sdk.api.files.confirm_file_upload({ id: file.id })
-    fileIds.push(file.id)
-    return { file, contents: buff }
+  // The raw value decides the fallback, not JSON.stringify of it — JSON.stringify('') is '""',
+  // which is truthy, so a `|| fallback` on the stringified form could never fire.
+  const describe = (value: any): string => {
+    if (value === undefined || value === null) return String(value)
+    const stringified = JSON.stringify(value)
+    return stringified === undefined ? String(value) : stringified
   }
+  const errorMessage = (e: any): string => (
+    typeof e?.message === 'string' && e.message !== '' ? e.message : describe(e)
+  )
 
-  // validateStatus so that a failure reports S3's actual status and XML <Message>, rather than an
-  // opaque axios throw. That is what makes this test diagnostic instead of merely red.
-  const fetchURL = (url: string) => axios.get(url, {
-    responseType: 'arraybuffer',
-    validateStatus: () => true,
-  })
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
-    for (const { name, label, expectExtValue } of TEST_NAMES) {
-      const { file, contents } = await uploadFile(name)
+    tenant = await setup_isolated_tenant({
+      name: `File download unicode names ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    const fileIds: string[] = []
 
-      const { downloadURL, name: returnedName } = await sdk.api.files.file_download_URL({
-        secureName: file.secureName,
+    const uploadFile = async (name: string) => {
+      const buff = buffer.Buffer.from(`test file content for ${JSON.stringify(name)}`)
+      const { presignedUpload, file } = await sdk.api.files.prepare_file_upload({
+        name,
+        type: 'application/pdf',
+        size: buff.byteLength,
       })
+      await sdk.UPLOAD(presignedUpload as any, buff)
+      await sdk.api.files.confirm_file_upload({ id: file.id })
+      fileIds.push(file.id)
+      return { file, contents: buff }
+    }
 
-      assert(
-        returnedName === name,
-        `endpoint returned "${returnedName}" instead of the stored name for ${label}`,
-        `stored name round-trips for ${label}`,
-      )
+    // validateStatus so that a failure reports S3's actual status and XML <Message>, rather than an
+    // opaque axios throw. That is what makes this test diagnostic instead of merely red.
+    const fetchURL = (url: string) => axios.get(url, {
+      responseType: 'arraybuffer',
+      validateStatus: () => true,
+    })
 
-      const response = await fetchURL(downloadURL)
+    try {
+      for (const { name, label, expectExtValue } of TEST_NAMES) {
+        const { file, contents } = await uploadFile(name)
 
-      // the bug: our API returned 200, S3 returned 400 on every fetch of the URL it gave us
-      assert(
-        response.status === 200,
-        `S3 returned ${response.status} for ${label}: ${buffer.Buffer.from(response.data ?? '').toString().slice(0, 400)}`,
-        `S3 returns 200 for ${label}`,
-      )
+        const { downloadURL, name: returnedName } = await sdk.api.files.file_download_URL({
+          secureName: file.secureName,
+        })
+
+        record(
+          `stored name round-trips for ${label}`,
+          returnedName === name,
+          `endpoint returned ${describe(returnedName)} for the stored name ${describe(name)}`,
+        )
+
+        const response = await fetchURL(downloadURL)
+
+        // the bug: our API returned 200, S3 returned 400 on every fetch of the URL it gave us
+        record(
+          `S3 returns 200 for ${label}`,
+          response.status === 200,
+          `S3 returned ${response.status} for ${label}: ${buffer.Buffer.from(response.data ?? '').toString().slice(0, 400)}`,
+        )
+
+        record(
+          `downloaded bytes match for ${label}`,
+          buffer.Buffer.from(response.data ?? '').toString() === contents.toString(),
+          `downloaded ${describe(buffer.Buffer.from(response.data ?? '').toString().slice(0, 200))},`
+          + ` expected ${describe(contents.toString())}`,
+        )
+
+        const disposition = (response.headers['content-disposition'] ?? '') as string
 
-      assert(
-        buffer.Buffer.from(response.data).toString() === contents.toString(),
-        `downloaded bytes did not match for ${label}`,
-        `downloaded bytes match for ${label}`,
+        record(
+          `Content-Disposition is ASCII-only for ${label}`,
+          IS_ASCII_ONLY.test(disposition),
+          `Content-Disposition for ${label}: ${describe(disposition)}`,
+        )
+        record(
+          `disposition is attachment for ${label}`,
+          disposition.startsWith('attachment;'),
+          `expected an attachment disposition for ${label}, got: ${describe(disposition)}`,
+        )
+        record(
+          `filename* ${expectExtValue ? 'present' : 'absent'} for ${label}`,
+          expectExtValue === disposition.includes(`filename*=UTF-8''`),
+          `filename* presence for ${label}: ${describe(disposition)}`,
+        )
+      }
+
+      /* ---------------------------------------------------------------- *
+       * The download URL is cached server-side. preferInBrowser changes
+       * whether a Content-Disposition is signed into the URL at all, so it
+       * has to be part of the cache key - otherwise whichever variant is
+       * requested first is served to everyone for ~99 minutes.
+       * ---------------------------------------------------------------- */
+      const { file: cacheFile, contents: cacheContents } = await uploadFile(
+        `Cache Test${EM_DASH}Both Variants.pdf`
       )
 
-      const disposition = (response.headers['content-disposition'] ?? '') as string
+      const asAttachment = await sdk.api.files.file_download_URL({ secureName: cacheFile.secureName })
+      const inBrowser = await sdk.api.files.file_download_URL({
+        secureName: cacheFile.secureName,
+        preferInBrowser: true,
+      })
 
-      assert(
-        IS_ASCII_ONLY.test(disposition),
-        `Content-Disposition was not ASCII-only for ${label}: ${disposition}`,
-        `Content-Disposition is ASCII-only for ${label}`,
+      record(
+        'preferInBrowser is cached separately from the attachment URL',
+        asAttachment.downloadURL !== inBrowser.downloadURL,
+        'preferInBrowser returned the cached attachment URL, so the cache key ignores it',
       )
-      assert(
-        disposition.startsWith('attachment;'),
-        `expected an attachment disposition for ${label}, got: ${disposition}`,
-        `disposition is attachment for ${label}`,
+      record(
+        'the default URL signs a content disposition',
+        asAttachment.downloadURL.includes('response-content-disposition'),
+        'the default URL was signed without a content disposition',
       )
-      assert(
-        expectExtValue === disposition.includes(`filename*=UTF-8''`),
-        `filename* presence was wrong for ${label}: ${disposition}`,
-        `filename* ${expectExtValue ? 'present' : 'absent'} for ${label}`,
+      record(
+        'the preferInBrowser URL omits the content disposition',
+        !inBrowser.downloadURL.includes('response-content-disposition'),
+        'the preferInBrowser URL was signed with a content disposition',
       )
-    }
 
-    /* ---------------------------------------------------------------- *
-     * The download URL is cached server-side. preferInBrowser changes
-     * whether a Content-Disposition is signed into the URL at all, so it
-     * has to be part of the cache key - otherwise whichever variant is
-     * requested first is served to everyone for ~99 minutes.
-     * ---------------------------------------------------------------- */
-    const { file: cacheFile, contents: cacheContents } = await uploadFile(
-      `Cache Test${EM_DASH}Both Variants.pdf`
-    )
-
-    const asAttachment = await sdk.api.files.file_download_URL({ secureName: cacheFile.secureName })
-    const inBrowser = await sdk.api.files.file_download_URL({
-      secureName: cacheFile.secureName,
-      preferInBrowser: true,
-    })
+      for (const [variant, { downloadURL }] of [['attachment', asAttachment], ['inBrowser', inBrowser]] as const) {
+        const response = await fetchURL(downloadURL)
+        record(
+          `S3 returns 200 for the ${variant} URL`,
+          response.status === 200,
+          `S3 returned ${response.status} for the ${variant} URL: ${buffer.Buffer.from(response.data ?? '').toString().slice(0, 400)}`,
+        )
+        record(
+          `downloaded bytes match for the ${variant} URL`,
+          buffer.Buffer.from(response.data ?? '').toString() === cacheContents.toString(),
+          `downloaded ${describe(buffer.Buffer.from(response.data ?? '').toString().slice(0, 200))},`
+          + ` expected ${describe(cacheContents.toString())}`,
+        )
+      }
 
-    assert(
-      asAttachment.downloadURL !== inBrowser.downloadURL,
-      'preferInBrowser returned the cached attachment URL, so the cache key ignores it',
-      'preferInBrowser is cached separately from the attachment URL',
-    )
-    assert(
-      asAttachment.downloadURL.includes('response-content-disposition'),
-      'the default URL was signed without a content disposition',
-      'the default URL signs a content disposition',
-    )
-    assert(
-      !inBrowser.downloadURL.includes('response-content-disposition'),
-      'the preferInBrowser URL was signed with a content disposition',
-      'the preferInBrowser URL omits the content disposition',
-    )
-
-    for (const [variant, { downloadURL }] of [['attachment', asAttachment], ['inBrowser', inBrowser]] as const) {
-      const response = await fetchURL(downloadURL)
-      assert(
-        response.status === 200,
-        `S3 returned ${response.status} for the ${variant} URL: ${buffer.Buffer.from(response.data ?? '').toString().slice(0, 400)}`,
-        `S3 returns 200 for the ${variant} URL`,
-      )
-      assert(
-        buffer.Buffer.from(response.data).toString() === cacheContents.toString(),
-        `downloaded bytes did not match for the ${variant} URL`,
-        `downloaded bytes match for the ${variant} URL`,
+      // a repeat request with identical arguments must still hit the cache
+      const repeated = await sdk.api.files.file_download_URL({ secureName: cacheFile.secureName })
+      record(
+        'an identical repeat request hits the cache',
+        repeated.downloadURL === asAttachment.downloadURL,
+        'an identical repeat request did not hit the cache',
       )
+    } catch (e: any) {
+      // An upload or a download-URL call outside a check threw. Record it rather than letting it
+      // escape `run`, which would fail every other suite in the batch instead of just this one.
+      record('File download unicode names suite ran to completion', false, `threw: ${errorMessage(e)}`)
+    } finally {
+      // Unlike every other record this suite creates, an uploaded file has an S3 object behind it,
+      // which tearing the tenant down does not remove — so the deletes stay.
+      for (const id of fileIds) {
+        await sdk.api.files.deleteOne(id).catch(() => {})
+      }
     }
-
-    // a repeat request with identical arguments must still hit the cache
-    const repeated = await sdk.api.files.file_download_URL({ secureName: cacheFile.secureName })
-    assert(
-      repeated.downloadURL === asAttachment.downloadURL,
-      'an identical repeat request did not hit the cache',
-      'an identical repeat request hits the cache',
-    )
   } finally {
-    for (const id of fileIds) {
-      await sdk.api.files.deleteOne(id).catch(() => {})
+    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
+    if (tenant) {
+      try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) }
     }
   }
+
+  return checks
 }
 
-if (require.main === module) {
-  console.log(`Using API URL: ${host}`)
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
+/** Asserting wrapper, for standalone runs. */
+export const file_download_unicode_names_tests = async () => {
+  assert_checks('File download unicode names', await file_download_unicode_names_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await file_download_unicode_names_tests({ sdk, sdkNonAdmin })
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'File download unicode names',
+  run: file_download_unicode_names_checks,
+}
 
-  runTests()
+if (require.main === module) {
+  console.log(`Using API URL: ${host}`)
+  file_download_unicode_names_tests()
     .then(() => {
       console.log("File download unicode names test suite completed successfully")
       process.exit(0)