@proteinjs/db-file-storage-driver-gcs 1.4.32 → 1.5.0

package/test/GoogleCloudStorageDriverObjectPrefix.test.ts

@@ -0,0 +1,128 @@
+import { GoogleCloudStorageDriver } from '../src/GoogleCloudStorageDriver';
+
+type StoredObject = { bytes: Buffer; generation: number; metadata: Record<string, any> };
+
+/**
+ * An in-memory bucket keyed by OBJECT NAME — the one fact this suite is about. Every storage call
+ * the driver makes goes through `bucket.file(name)`, so whatever name the driver decides is the
+ * key an object is stored, read, signed and deleted under here.
+ */
+const objects = new Map<string, StoredObject>();
+let nextGeneration = 1;
+
+const fileMock = jest.fn((name: string) => ({
+  save: async (bytes: Buffer, options?: { metadata?: Record<string, any> }) => {
+    objects.set(name, { bytes, generation: nextGeneration++, metadata: { ...(options?.metadata ?? {}) } });
+  },
+  download: async () => {
+    const existing = objects.get(name);
+    if (!existing) {
+      throw Object.assign(new Error(`No such object: ${name}`), { code: 404 });
+    }
+    return [existing.bytes];
+  },
+  getMetadata: async () => {
+    const existing = objects.get(name);
+    if (!existing) {
+      throw Object.assign(new Error(`No such object: ${name}`), { code: 404 });
+    }
+    return [{ ...existing.metadata, generation: String(existing.generation) }, {}];
+  },
+  setMetadata: async (metadata: Record<string, any>) => {
+    const existing = objects.get(name);
+    if (!existing) {
+      throw Object.assign(new Error(`No such object: ${name}`), { code: 404 });
+    }
+    existing.metadata = { ...existing.metadata, ...metadata };
+  },
+  getSignedUrl: async () => [`https://storage.example/test-bucket/${name}?signed`],
+  delete: async () => {
+    objects.delete(name);
+  },
+}));
+const bucketMock = jest.fn(() => ({ file: fileMock }));
+
+jest.mock('@google-cloud/storage', () => ({
+  Storage: jest.fn(() => ({ bucket: bucketMock })),
+}));
+
+/**
+ * One bucket can hold the files of several independent deployments of an application — each a
+ * driver with its own `objectPrefix`. The prefix is only worth having if EVERY operation honours
+ * it: an object written under a prefix and read, signed or deleted by its bare id is a file that
+ * cannot be found, and a deployment's files could not be listed or removed as a group.
+ */
+describe('GoogleCloudStorageDriver objectPrefix', () => {
+  const bytes = Buffer.from('the bytes of a picture');
+  const picture = (id: string) => ({ id, name: 'holiday.jpg', type: 'image/jpeg', size: bytes.length }) as never;
+
+  beforeEach(() => {
+    objects.clear();
+    nextGeneration = 1;
+  });
+
+  it('stores a file under the prefix, never under its bare id', async () => {
+    const driver = new GoogleCloudStorageDriver({
+      projectId: 'test-project',
+      bucketName: 'test-bucket',
+      objectPrefix: 'deployment-a/',
+    });
+
+    await driver.createFile(picture('file-1'), bytes.toString('base64'));
+
+    expect(Array.from(objects.keys())).toEqual(['deployment-a/file-1']);
+    // The file's own id is what the object says about itself — the prefix names where, not what.
+    expect(objects.get('deployment-a/file-1')!.metadata.metadata.fileId).toBe('file-1');
+  });
+
+  it('every operation reaches the object it wrote: read, overwrite, describe, sign, delete', async () => {
+    const driver = new GoogleCloudStorageDriver({
+      projectId: 'test-project',
+      bucketName: 'test-bucket',
+      objectPrefix: 'deployment-a/',
+    });
+    await driver.createFile(picture('file-1'), bytes.toString('base64'));
+
+    expect(await driver.getFileData('file-1')).toBe(bytes.toString('base64'));
+
+    const rewritten = Buffer.from('the same picture, rewritten');
+    await driver.updateFileData('file-1', rewritten.toString('base64'));
+    expect(objects.get('deployment-a/file-1')!.bytes.equals(rewritten)).toBe(true);
+
+    await driver.updateFile({ id: 'file-1', name: 'renamed.jpg', type: 'image/jpeg', size: rewritten.length } as never);
+    expect(objects.get('deployment-a/file-1')!.metadata.metadata.fileName).toBe('renamed.jpg');
+
+    expect(await driver.getSignedUrl('file-1')).toBe('https://storage.example/test-bucket/deployment-a/file-1?signed');
+
+    await driver.deleteFile('file-1');
+    expect(Array.from(objects.keys())).toEqual([]);
+  });
+
+  it('two prefixes in one bucket never reach each other’s files', async () => {
+    const a = new GoogleCloudStorageDriver({
+      projectId: 'test-project',
+      bucketName: 'test-bucket',
+      objectPrefix: 'deployment-a/',
+    });
+    const b = new GoogleCloudStorageDriver({
+      projectId: 'test-project',
+      bucketName: 'test-bucket',
+      objectPrefix: 'deployment-b/',
+    });
+    await a.createFile(picture('file-1'), bytes.toString('base64'));
+
+    await expect(b.getFileData('file-1')).rejects.toMatchObject({ code: 'not-found' });
+    await b.deleteFile('file-1');
+
+    expect(Array.from(objects.keys())).toEqual(['deployment-a/file-1']);
+  });
+
+  it('with no prefix configured an object is named by the file id alone', async () => {
+    const driver = new GoogleCloudStorageDriver({ projectId: 'test-project', bucketName: 'test-bucket' });
+
+    await driver.createFile(picture('file-1'), bytes.toString('base64'));
+
+    expect(Array.from(objects.keys())).toEqual(['file-1']);
+    expect(await driver.getFileData('file-1')).toBe(bytes.toString('base64'));
+  });
+});

package/test/GoogleCloudStorageDriverOverwriteMetadata.test.ts

@@ -0,0 +1,146 @@
+import { GoogleCloudStorageDriver } from '../src/GoogleCloudStorageDriver';
+
+type StoredObject = {
+  bytes: Buffer;
+  generation: number;
+  metadata: Record<string, any>;
+};
+
+/**
+ * A small in-memory stand-in for the storage SDK that keeps the one service behaviour this suite
+ * is about: writing an object's bytes creates a NEW GENERATION, and a new generation holds only
+ * the metadata sent with that write — nothing of the previous generation's content type or custom
+ * metadata survives by itself. With no content type sent, the SDK can only infer one from the
+ * object name's extension; the driver names objects by file id, so there is none and the service
+ * falls back to `application/octet-stream`.
+ */
+const objects = new Map<string, StoredObject>();
+let nextGeneration = 1;
+let afterMetadataRead: ((name: string) => void) | undefined;
+
+const fileMock = jest.fn((name: string) => ({
+  save: async (bytes: Buffer, options?: { metadata?: Record<string, any>; preconditionOpts?: Record<string, any> }) => {
+    const existing = objects.get(name);
+    const expectedGeneration = options?.preconditionOpts?.ifGenerationMatch;
+    if (expectedGeneration !== undefined && String(existing?.generation ?? 0) !== String(expectedGeneration)) {
+      throw Object.assign(new Error('conditionNotMet'), { code: 412 });
+    }
+
+    const sent = options?.metadata ?? {};
+    objects.set(name, {
+      bytes,
+      generation: nextGeneration++,
+      metadata: { ...sent, contentType: sent.contentType ?? 'application/octet-stream' },
+    });
+  },
+  getMetadata: async () => {
+    const existing = objects.get(name);
+    if (!existing) {
+      throw Object.assign(new Error(`No such object: ${name}`), { code: 404 });
+    }
+
+    const snapshot = { ...existing.metadata, generation: String(existing.generation) };
+    afterMetadataRead?.(name);
+    return [snapshot, {}];
+  },
+}));
+const bucketMock = jest.fn(() => ({ file: fileMock }));
+
+jest.mock('@google-cloud/storage', () => ({
+  Storage: jest.fn(() => ({ bucket: bucketMock })),
+}));
+
+/**
+ * `GET /file/:id` redirects the browser to the object itself, so the object's own content type is
+ * what the browser is told. A byte overwrite that loses it turns every rewritten picture and clip
+ * into an `application/octet-stream` download. The driver is the only party that talks to the
+ * store, so the overwrite restates what the object already says about itself.
+ */
+describe('GoogleCloudStorageDriver.updateFileData keeps the object metadata', () => {
+  const driver = new GoogleCloudStorageDriver({ projectId: 'test-project', bucketName: 'test-bucket' });
+  const firstBytes = Buffer.from('first bytes of the picture');
+  const nextBytes = Buffer.from('the same picture, rewritten smaller');
+
+  beforeEach(() => {
+    objects.clear();
+    nextGeneration = 1;
+    afterMetadataRead = undefined;
+  });
+
+  async function createPicture(id: string) {
+    await driver.createFile(
+      { id, name: 'holiday.jpg', type: 'image/jpeg', size: firstBytes.length } as never,
+      firstBytes.toString('base64')
+    );
+  }
+
+  it('an overwritten object keeps its content type', async () => {
+    await createPicture('0b9c6d1e-object-id-without-extension');
+    const before = objects.get('0b9c6d1e-object-id-without-extension')!.metadata.contentType;
+
+    await driver.updateFileData('0b9c6d1e-object-id-without-extension', nextBytes.toString('base64'));
+
+    const after = objects.get('0b9c6d1e-object-id-without-extension')!;
+    expect(before).toEqual('image/jpeg');
+    expect(after.metadata.contentType).toEqual('image/jpeg');
+    expect(Buffer.compare(after.bytes, nextBytes)).toBe(0);
+  });
+
+  it('an overwritten object keeps its custom metadata, with the size restated for the new bytes', async () => {
+    await createPicture('file-2');
+
+    await driver.updateFileData('file-2', nextBytes.toString('base64'));
+
+    expect(objects.get('file-2')!.metadata.metadata).toEqual({
+      fileId: 'file-2',
+      fileName: 'holiday.jpg',
+      fileSize: nextBytes.length.toString(),
+    });
+  });
+
+  it('an overwritten object keeps its cache, disposition and language headers', async () => {
+    await createPicture('file-3');
+    Object.assign(objects.get('file-3')!.metadata, {
+      cacheControl: 'private, max-age=3600',
+      contentDisposition: 'inline',
+      contentLanguage: 'en',
+    });
+
+    await driver.updateFileData('file-3', nextBytes.toString('base64'));
+
+    expect(objects.get('file-3')!.metadata).toMatchObject({
+      contentType: 'image/jpeg',
+      cacheControl: 'private, max-age=3600',
+      contentDisposition: 'inline',
+      contentLanguage: 'en',
+    });
+  });
+
+  it('an overwrite that raced another writer fails loudly and leaves the other write in place', async () => {
+    await createPicture('file-4');
+    const otherWritersBytes = Buffer.from('another writer got there first');
+    afterMetadataRead = (name) => {
+      afterMetadataRead = undefined;
+      const current = objects.get(name)!;
+      objects.set(name, { ...current, bytes: otherWritersBytes, generation: nextGeneration++ });
+    };
+
+    await expect(driver.updateFileData('file-4', nextBytes.toString('base64'))).rejects.toMatchObject({
+      name: 'FileStorageError',
+      code: 'precondition-failed',
+      status: 412,
+    });
+
+    expect(Buffer.compare(objects.get('file-4')!.bytes, otherWritersBytes)).toBe(0);
+  });
+
+  it('overwriting an object that does not exist fails loudly and creates nothing', async () => {
+    await expect(driver.updateFileData('file-5', nextBytes.toString('base64'))).rejects.toMatchObject({
+      name: 'FileStorageError',
+      code: 'not-found',
+      status: 404,
+    });
+
+    expect(objects.has('file-5')).toBe(false);
+  });
+});