@openneuro/server 4.20.5 → 4.20.6-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openneuro/server",
-  "version": "4.20.5",
+  "version": "4.20.6-alpha.3",
   "description": "Core service for the OpenNeuro platform.",
   "license": "MIT",
   "main": "src/server.js",
@@ -21,7 +21,7 @@
     "@elastic/elasticsearch": "7.15.0",
     "@graphql-tools/schema": "^10.0.0",
     "@keyv/redis": "^2.7.0",
-    "@openneuro/search": "^4.20.5",
+    "@openneuro/search": "^4.20.6-alpha.3",
     "@passport-next/passport-google-oauth2": "^1.0.0",
     "@sentry/node": "^4.5.3",
     "base64url": "^3.0.0",
@@ -32,12 +32,10 @@
     "draft-js-export-html": "^1.4.1",
     "elastic-apm-node": "3.49.1",
     "express": "4.18.2",
-    "graphql": "16.6.0",
+    "graphql": "16.8.1",
     "graphql-bigint": "^1.0.0",
     "graphql-compose": "9.0.10",
     "graphql-iso-date": "^3.6.1",
-    "graphql-redis-subscriptions": "2.1.0",
-    "graphql-subscriptions": "^1.1.0",
     "graphql-tools": "9.0.0",
     "immutable": "^3.8.2",
     "ioredis": "4.17.3",
@@ -87,5 +85,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d397dba94af3bf8482b8a082b8f8d28a79232488"
+  "gitHead": "74d0a6d75494f382655482c563a52d6ed82477ec"
 }

package/src/__mocks__/{config.js → config.ts}

@@ -1,24 +1,24 @@
 const config = {
   auth: {
     jwt: {
-      secret: '123456',
+      secret: "123456",
     },
   },
   datalad: {
-    uri: 'datalad',
+    uri: "datalad",
     workers: 4,
   },
   mongo: {
-    url: 'mongodb://',
+    url: "mongodb://",
   },
   notifications: {
     email: {
-      from: 'notifications@example.com',
+      from: "notifications@example.com",
     },
   },
   elasticsearch: {},
   doi: {
-    username: '',
+    username: "",
   },
 }
 

package/src/app.ts

@@ -4,29 +4,29 @@
 /**
  * Express app setup
  */
-import { createServer } from 'http'
-import cors from 'cors'
-import express, { urlencoded, json } from 'express'
-import passport from 'passport'
-import config from './config'
-import routes from './routes'
-import morgan from 'morgan'
-import schema from './graphql/schema'
-import { ApolloServer } from '@apollo/server'
-import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default'
-import { expressMiddleware } from '@apollo/server/express4'
-import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer'
-import { KeyvAdapter } from '@apollo/utils.keyvadapter'
-import Keyv from 'keyv'
-import KeyvRedis from '@keyv/redis'
-import cookieParser from 'cookie-parser'
-import * as jwt from './libs/authentication/jwt'
-import * as auth from './libs/authentication/states.js'
-import { sitemapHandler } from './handlers/sitemap.js'
-import { setupPassportAuth } from './libs/authentication/passport.js'
-import { redis } from './libs/redis'
-import { version } from './lerna.json'
-export { Express } from 'express-serve-static-core'
+import { createServer } from "http"
+import cors from "cors"
+import express, { json, urlencoded } from "express"
+import passport from "passport"
+import config from "./config"
+import routes from "./routes"
+import morgan from "morgan"
+import schema from "./graphql/schema"
+import { ApolloServer } from "@apollo/server"
+import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin/landingPage/default"
+import { expressMiddleware } from "@apollo/server/express4"
+import { ApolloServerPluginDrainHttpServer } from "@apollo/server/plugin/drainHttpServer"
+import { KeyvAdapter } from "@apollo/utils.keyvadapter"
+import Keyv from "keyv"
+import KeyvRedis from "@keyv/redis"
+import cookieParser from "cookie-parser"
+import * as jwt from "./libs/authentication/jwt"
+import * as auth from "./libs/authentication/states"
+import { sitemapHandler } from "./handlers/sitemap"
+import { setupPassportAuth } from "./libs/authentication/passport"
+import { redis } from "./libs/redis"
+import { version } from "./lerna.json"
+export { Express } from "express-serve-static-core"
 
 interface OpenNeuroRequestContext {
   user: string
@@ -47,17 +47,18 @@ export async function expressApolloSetup() {
 
   app.use((req, res, next) => {
     res.set(config.headers)
-    res.type('application/json')
+    res.type("application/json")
     next()
   })
-  app.use(morgan('short'))
+  app.use(morgan("short"))
   app.use(cookieParser())
-  app.use(urlencoded({ extended: false, limit: '50mb' }))
-  app.use(json({ limit: '50mb' }))
+  app.use(urlencoded({ extended: false, limit: "50mb" }))
+  app.use(json({ limit: "50mb" }))
 
   // routing ---------------------------------------------------------
-  app.use('/sitemap.xml', sitemapHandler)
+  app.use("/sitemap.xml", sitemapHandler)
   app.use(config.apiPrefix, routes)
+  app.use("/api/", routes)
 
   const httpServer = createServer(app)
 
@@ -78,8 +79,8 @@ export async function expressApolloSetup() {
             async willSendResponse(requestContext) {
               const { response } = requestContext
               if (
-                response.body.kind === 'single' &&
-                'data' in response.body.singleResult
+                response.body.kind === "single" &&
+                "data" in response.body.singleResult
               ) {
                 response.body.singleResult.extensions = {
                   ...response.body.singleResult.extensions,
@@ -98,7 +99,7 @@ export async function expressApolloSetup() {
 
   // Setup GraphQL middleware
   app.use(
-    ['/graphql', '/crn/graphql'],
+    ["/graphql", "/crn/graphql", "/api/graphql"],
     cors<cors.CorsRequest>(),
     jwt.authenticate,
     auth.optional,

package/src/cache/item.ts

@@ -1,8 +1,8 @@
-import { Redis } from 'ioredis'
-import * as zlib from 'zlib'
-import { promisify } from 'util'
-import { CacheType } from './types'
-export { CacheType } from './types'
+import { Redis } from "ioredis"
+import * as zlib from "zlib"
+import { promisify } from "util"
+import { CacheType } from "./types"
+export { CacheType } from "./types"
 
 const compress = promisify(zlib.gzip)
 const decompress = promisify(zlib.gunzip)
@@ -15,7 +15,7 @@ export function cacheKey(
   type: CacheType,
   compositeKeys: Array<string>,
 ): string {
-  return `${type.toString()}:${compositeKeys.join(':')}`
+  return `${type.toString()}:${compositeKeys.join(":")}`
 }
 
 /**
@@ -27,7 +27,6 @@ class CacheItem {
   expiration = 0
   private redis: Redis
   /**
-   *
    * @param redis ioredis client
    * @param type A CacheType value
    * @param compositeKeys Values identifying this cache key

package/src/cache/types.ts

@@ -4,12 +4,12 @@
  * Use short names here, particularly for keys with many values
  */
 export enum CacheType {
-  datasetsConnection = 'connection',
-  datasetDescription = 'description',
-  commitFiles = 'files',
-  readme = 'readme',
-  snapshot = 'snapshot',
-  snapshotIndex = 'snapshotIndex',
-  participantCount = 'participantCount',
-  snapshotDownload = 'download',
+  datasetsConnection = "connection",
+  datasetDescription = "description",
+  commitFiles = "files",
+  readme = "readme",
+  snapshot = "snapshot",
+  snapshotIndex = "snapshotIndex",
+  participantCount = "participantCount",
+  snapshotDownload = "download",
 }

package/src/{config.js → config.ts}

@@ -1,12 +1,12 @@
 const config = {
   url: process.env.CRN_SERVER_URL,
   port: 8111,
-  apiPrefix: '/crn/',
-  location: '/srv',
+  apiPrefix: "/crn/",
+  location: "/srv",
   headers: {
-    'Access-Control-Allow-Origin': '*',
-    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS, PUT, PATCH, DELETE',
-    'Access-Control-Allow-Headers': 'content-type, Authorization',
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS, PUT, PATCH, DELETE",
+    "Access-Control-Allow-Headers": "content-type, Authorization",
   },
   analysis: {
     enabled: process.env.ANALYSIS_ENABLED,
@@ -33,7 +33,7 @@ const config = {
   },
   mongo: {
     url: process.env.MONGO_URL,
-    dbName: 'crn',
+    dbName: "crn",
     connectTimeoutMS: 1000,
   },
   redis: {

package/src/datalad/__tests__/changelog.spec.ts

@@ -0,0 +1,83 @@
+import { vi } from "vitest"
+import * as changelog from "../changelog"
+
+vi.mock("ioredis")
+vi.mock("../../config.ts")
+
+describe("changelog editing tools", () => {
+  describe("findVersion()", () => {
+    it("finds the version bounds for a single entry", () => {
+      const newChanges = ["1.0.0 2019-01-01", "  - Initial version"]
+      expect(changelog.findVersion(newChanges, "1.0.0")).toEqual([0, 2])
+    })
+    it("returns an empty array when no matching version is found", () => {
+      const newChanges = ["1.0.0 2019-01-01", "  - Initial version"]
+      expect(changelog.findVersion(newChanges, "1.0.1")).toEqual([])
+    })
+    it("returns the correct offset for a change in the middle of others", () => {
+      const newChanges = [
+        "2.0.0 2019-02-02",
+        "  - New derivatives",
+        "1.1.0 2019-02-01",
+        "  - Added subjects",
+        "  - Fixed metadata",
+        "1.0.0 2019-01-01",
+        "  - Initial version",
+      ]
+      expect(changelog.findVersion(newChanges, "1.1.0")).toEqual([2, 3])
+    })
+    it("works with fuzzy data", () => {
+      const newChanges = ["I", "am", "a", "banana"]
+      expect(changelog.findVersion(newChanges, "1.0.0")).toEqual([])
+    })
+  })
+  describe("spliceChangelog()", () => {
+    it("splices in changes to an existing changelog", () => {
+      const original = "1.0.0 2019-01-01\n  - Initial version\n"
+      const changes = ["Some new change", "Another new change"]
+      const tag = "1.0.0"
+      expect(
+        changelog.spliceChangelog(original, tag, "2019-02-01", changes),
+      ).toEqual(
+        "1.0.0 2019-02-01\n  - Some new change\n  - Another new change\n",
+      )
+    })
+    it("splices correctly when no matching version is found", () => {
+      const original = "1.0.0 2019-01-01\n  - Initial version\n"
+      const changes = ["Some new change"]
+      const tag = "1.0.1"
+      expect(
+        changelog.spliceChangelog(original, tag, "2019-02-01", changes),
+      ).toEqual(
+        "1.0.1 2019-02-01\n  - Some new change\n1.0.0 2019-01-01\n  - Initial version\n",
+      )
+    })
+    it("handles fuzzy data", () => {
+      const original = "abc 123 not a changelog\nnope"
+      const changes = ["Fixed up data"]
+      const tag = "1.0.0"
+      expect(
+        changelog.spliceChangelog(original, tag, "2019-02-01", changes),
+      ).toEqual(
+        "1.0.0 2019-02-01\n  - Fixed up data\nabc 123 not a changelog\nnope\n",
+      )
+    })
+    it("works with legacy versions", () => {
+      const original = "00001 1999-12-31\n  - Partying"
+      const changes = ["Bringing dataset into the present day"]
+      const tag = "1.0.0"
+      expect(
+        changelog.spliceChangelog(original, tag, "2019-02-01", changes),
+      ).toEqual(
+        "1.0.0 2019-02-01\n  - Bringing dataset into the present day\n00001 1999-12-31\n  - Partying\n",
+      )
+    })
+    it("works if no CHANGES are provided", () => {
+      expect(
+        changelog.spliceChangelog("", "1.0.0", "2019-03-04", [
+          "Initial snapshot",
+        ]),
+      ).toEqual("1.0.0 2019-03-04\n  - Initial snapshot\n")
+    })
+  })
+})

package/src/datalad/__tests__/dataset.spec.ts

@@ -0,0 +1,109 @@
+import { vi } from "vitest"
+import request from "superagent"
+import { createDataset, datasetsFilter, testBlacklist } from "../dataset"
+import { getDatasetWorker } from "../../libs/datalad-service"
+import { connect } from "mongoose"
+
+// Mock requests to Datalad service
+vi.mock("superagent")
+vi.mock("ioredis")
+vi.mock("../../libs/redis")
+vi.mock("../../config.ts")
+vi.mock("../../libs/notifications")
+
+describe("dataset model operations", () => {
+  describe("createDataset()", () => {
+    beforeAll(() => {
+      // Setup MongoDB with mongodb-memory-server
+      connect(globalThis.__MONGO_URI__)
+    })
+    it("resolves to dataset id string", async () => {
+      const user = { id: "1234" }
+      const { id: dsId } = await createDataset(user.id, user, {
+        affirmedDefaced: true,
+        affirmedConsent: true,
+      })
+      expect(dsId).toHaveLength(8)
+      expect(dsId.slice(0, 2)).toBe("ds")
+    })
+    it("posts to the DataLad /datasets/{dsId} endpoint", async () => {
+      const user = { id: "1234" }
+      // Reset call count for request.post
+      request.post.mockClear()
+      const { id: dsId } = await createDataset(user.id, user, {
+        affirmedDefaced: true,
+        affirmedConsent: true,
+      })
+      expect(request.post).toHaveBeenCalledTimes(1)
+      expect(request.post).toHaveBeenCalledWith(
+        expect.stringContaining(`${getDatasetWorker(dsId)}/datasets/`),
+      )
+    })
+  })
+  describe("datasetsFilter()", () => {
+    describe("filterBy: {all: true} ", () => {
+      it("returns the specified match for regular users", () => {
+        const testMatch = { test: "match" }
+        expect(
+          datasetsFilter({
+            userId: "1234",
+            admin: false,
+            filterBy: { all: true },
+          })(testMatch)[0].$match,
+        ).toBe(testMatch)
+      })
+      it("excludes match argument for admins", () => {
+        const testMatch = { test: "match" }
+        expect(
+          datasetsFilter({
+            userId: "5678",
+            admin: true,
+            filterBy: { all: true },
+          })(testMatch),
+        ).not.toBe(testMatch)
+      })
+    })
+    describe("filterBy: {invalid: true}", () => {
+      it("returns the correct number of stages", () => {
+        expect(
+          datasetsFilter({ filterBy: { invalid: true } })({}),
+        ).toHaveLength(4)
+      })
+    })
+    describe("filterBy: {invalid: true, public: true}", () => {
+      it("returns the same number of stages as invalid: true", () => {
+        expect(
+          datasetsFilter({ filterBy: { invalid: true, public: true } })({}),
+        ).toHaveLength(4)
+      })
+      it("returns one less stage for admins with all", () => {
+        expect(
+          datasetsFilter({
+            admin: true,
+            filterBy: { invalid: true, public: true, all: true },
+          })({}),
+        ).toHaveLength(3)
+      })
+    })
+    describe("testBlacklist", () => {
+      it("returns false for .bidsignore", () => {
+        expect(testBlacklist("", ".bidsignore")).toBe(false)
+      })
+      it("returns true for .git paths", () => {
+        expect(testBlacklist(".git", "HEAD")).toBe(true)
+      })
+      it("returns true for root level .DS_Store files", () => {
+        expect(testBlacklist("", ".DS_Store")).toBe(true)
+      })
+      it("returns true for nested .DS_Store files", () => {
+        expect(testBlacklist("sub-01/anat/", ".DS_Store")).toBe(true)
+      })
+      // https://github.com/OpenNeuroOrg/openneuro/issues/2519
+      it("skips ._ prefixed files created by macOS", () => {
+        expect(testBlacklist("", "._.DS_Store")).toBe(true)
+        expect(testBlacklist("stimuli/", "._1002.png")).toBe(true)
+        expect(testBlacklist("stimuli/", "test._1002.png")).toBe(false)
+      })
+    })
+  })
+})

package/src/datalad/__tests__/description.spec.ts

@@ -0,0 +1,141 @@
+import { vi } from "vitest"
+import {
+  appendSeniorAuthor,
+  getDescriptionObject,
+  repairDescriptionTypes,
+} from "../description"
+
+// Mock requests to Datalad service
+vi.mock("ioredis")
+vi.mock("../../config.ts")
+
+describe("datalad dataset descriptions", () => {
+  describe("appendSeniorAuthor", () => {
+    it("returns author out of several", () => {
+      expect(
+        appendSeniorAuthor({
+          Authors: ["A. Bee", "C. Dee", "E. Eff"],
+          Name: "test dataset",
+        }),
+      ).toHaveProperty("SeniorAuthor", "E. Eff")
+    })
+    it("returns a description when no Authors array is provided", () => {
+      expect(
+        appendSeniorAuthor({ Authors: null, Name: "test dataset" }),
+      ).toHaveProperty("Name", "test dataset")
+    })
+    it("returns a description when no Authors array is empty", () => {
+      expect(
+        appendSeniorAuthor({ Authors: [], Name: "test dataset" }),
+      ).toHaveProperty("Name", "test dataset")
+    })
+  })
+  describe("repairDescriptionTypes", () => {
+    it("converts strings to one element arrays for array fields", () => {
+      const description = {
+        Authors: "Not, An Array",
+        BIDSVersion: "1.2.0",
+        ReferencesAndLinks: "https://openneuro.org",
+        Funding: ["This one", "is correct"],
+        EthicsApprovals: "Also, Not, Array",
+      }
+      const repaired = repairDescriptionTypes(description)
+      // Check for discarded fields
+      expect(repaired.BIDSVersion).toBe(description.BIDSVersion)
+      // Check for extra fields
+      expect(repaired.DatasetDOI).toBe(undefined)
+      // Test each repaired field for type correct value
+      expect(Array.isArray(repaired.Authors)).toBe(true)
+      expect(Array.isArray(repaired.ReferencesAndLinks)).toBe(true)
+      expect(Array.isArray(repaired.Funding)).toBe(true)
+      expect(Array.isArray(repaired.EthicsApprovals)).toBe(true)
+    })
+    it("converts any invalid value to string values for string fields", () => {
+      const description = {
+        BIDSVersion: "1.2.0",
+        Name: 1.5,
+        DatasetDOI: ["Should", "not", "be", "an", "array"],
+        Acknowledgements: ["Should not be an array"],
+        HowToAcknowledge: Symbol(), // This can't serialize but just in case
+      }
+      const repaired = repairDescriptionTypes(description)
+      // Check for discarded fields
+      expect(repaired.BIDSVersion).toBe(description.BIDSVersion)
+      // Check for extra fields
+      expect(repaired.Authors).toBe(undefined)
+      // Check converted types
+      expect(typeof repaired.Name).toBe("string")
+      expect(typeof repaired.DatasetDOI).toBe("string")
+      expect(typeof repaired.Acknowledgements).toBe("string")
+      expect(typeof repaired.HowToAcknowledge).toBe("string")
+    })
+    it("returns correct types for empty strings", () => {
+      const description = {
+        Name: "Classification learning",
+        License:
+          "This dataset is made available under the Public Domain Dedication and License \nv1.0, whose full text can be found at \nhttp://www.opendatacommons.org/licenses/pddl/1.0/. \nWe hope that all users will follow the ODC Attribution/Share-Alike \nCommunity Norms (http://www.opendatacommons.org/norms/odc-by-sa/); \nin particular, while not legally required, we hope that all users \nof the data will acknowledge the OpenfMRI project and NSF Grant \nOCI-1131441 (R. Poldrack, PI) in any publications.",
+        Authors: "",
+        Acknowledgements: "",
+        HowToAcknowledge: "",
+        Funding: "",
+        ReferencesAndLinks: "",
+        DatasetDOI: "",
+        BIDSVersion: "1.0.0",
+      }
+      const repaired = repairDescriptionTypes(description)
+      expect(Array.isArray(repaired.Authors)).toBe(true)
+      expect(Array.isArray(repaired.ReferencesAndLinks)).toBe(true)
+      expect(Array.isArray(repaired.Funding)).toBe(true)
+    })
+  })
+  describe("getDescriptionObject()", () => {
+    beforeAll(() => {
+      global.fetch = vi.fn()
+    })
+    it("returns the parsed dataset_description.json object", async () => {
+      // @ts-expect-error Fetch mock includes mockResolvedValue
+      fetch.mockResolvedValue({
+        json: () =>
+          Promise.resolve({ Name: "Balloon Analog Risk-taking Task" }),
+        headers: {
+          get: () => "application/json",
+        },
+        status: 200,
+      })
+      const description = await getDescriptionObject("ds000001", "1.0.0")
+      expect(description).toEqual({ Name: "Balloon Analog Risk-taking Task" })
+    })
+    it("handles a corrupted response", async () => {
+      global.fetch = vi.fn()
+      // @ts-expect-error Fetch mock includes mockResolvedValue
+      fetch.mockResolvedValue({
+        json: () => Promise.reject("JSON could not be parsed"),
+        headers: {
+          get: () => "application/json",
+        },
+        status: 400,
+      })
+      await expect(getDescriptionObject("ds000001", "1.0.0")).rejects.toEqual(
+        Error(
+          "Backend request failed, dataset_description.json may not exist or may be non-JSON (type: application/json, status: 400)",
+        ),
+      )
+    })
+    it("throws an error when nothing is returned", async () => {
+      global.fetch = vi.fn()
+      // @ts-expect-error Fetch mock includes mockResolvedValue
+      fetch.mockResolvedValue({
+        json: () => Promise.reject("JSON could not be parsed"),
+        headers: {
+          get: () => "application/json",
+        },
+        status: 404,
+      })
+      await expect(getDescriptionObject("ds000001", "1.0.0")).rejects.toEqual(
+        Error(
+          "Backend request failed, dataset_description.json may not exist or may be non-JSON (type: application/json, status: 404)",
+        ),
+      )
+    })
+  })
+})

package/src/datalad/__tests__/files.spec.ts

@@ -0,0 +1,77 @@
+import { vi } from "vitest"
+import {
+  computeTotalSize,
+  decodeFilePath,
+  encodeFilePath,
+  fileUrl,
+} from "../files"
+
+vi.mock("ioredis")
+vi.mock("../../config.ts")
+
+const filename = "sub-01/anat/sub-01_T1w.nii.gz"
+
+const mockRootFiles = [
+  { filename: "README" },
+  { filename: "dataset_description.json" },
+]
+const mockSub01 = [
+  { filename: "sub-01/anat/sub-01_T1w.nii.gz" },
+  { filename: "sub-01/func/sub-01_task-onebacktask_run-01_bold.nii.gz" },
+]
+const mockSub02 = [
+  { filename: "sub-02/anat/sub-02_T1w.nii.gz" },
+  { filename: "sub-02/func/sub-02_task-onebacktask_run-01_bold.nii.gz" },
+]
+const mockSub03 = [
+  { filename: "sub-03/anat/sub-03_T1w.nii.gz" },
+  { filename: "sub-03/func/sub-03_task-onebacktask_run-01_bold.nii.gz" },
+]
+const mockDerivatives = [{ filename: "derivatives/groundbreaking_output.html" }]
+const mockFiles = [
+  ...mockRootFiles,
+  ...mockSub01,
+  ...mockSub02,
+  ...mockSub03,
+  ...mockDerivatives,
+]
+
+describe("datalad files", () => {
+  describe("encodeFilePath()", () => {
+    it("should encode a nested path", () => {
+      expect(encodeFilePath(filename)).toBe("sub-01:anat:sub-01_T1w.nii.gz")
+    })
+  })
+  describe("decodeFilePath()", () => {
+    it("decodes a file path", () => {
+      expect(decodeFilePath("sub-01:anat:sub-01_T1w.nii.gz")).toBe(filename)
+    })
+  })
+  describe("fileUrl()", () => {
+    it("returns a working URL", () => {
+      expect(fileUrl("ds000001", "", filename)).toBe(
+        "http://datalad-0/datasets/ds000001/files/sub-01:anat:sub-01_T1w.nii.gz",
+      )
+    })
+    it("handles path nesting", () => {
+      expect(fileUrl("ds000001", "sub-01/anat", "sub-01_T1w.nii.gz")).toBe(
+        "http://datalad-0/datasets/ds000001/files/sub-01:anat:sub-01_T1w.nii.gz",
+      )
+    })
+  })
+  describe("computeTotalSize()", () => {
+    it("computes the size correctly", () => {
+      const mockFileSizes = [
+        { filename: "README", size: 234 },
+        { filename: "dataset_description.json", size: 432 },
+        { filename: "sub-01/anat/sub-01_T1w.nii.gz", size: 10858 },
+        {
+          filename: "sub-01/func/sub-01_task-onebacktask_run-01_bold.nii.gz",
+          size: 1945682,
+        },
+      ]
+      // @ts-expect-error Test is mocking this
+      expect(computeTotalSize(mockFileSizes)).toBe(1957206)
+    })
+  })
+})