fix(*): write tests for service and fix revealed bugs

Also:

-   Add `MemoryRepository` (basically an in-memory db) to support tests
-   Test the entire Uploads public API surface area
-   Fix revealed bugs from tests
-   Actually delete on update (to mimc file move)
-   Install memfs in order to use a memory disk for testing
-   Use process.hrtime for generation of filenames to get unique timestamps even in the same tick

Author: bericp1

README.md

@@ -24,11 +24,13 @@ TODO
 
 -   [ ] Usage docs
 -   [ ] Detailed API docs
+-   [ ] More tests:
+    -   Test errors when bad `defaultGeneratePath` and/or `defaultSanitizeFilename` are provided.
 -   [ ] Do URL generation for publicly available disks.
--   [ ] Support deleting files was @carimus/node-disks supports it
 -   [ ] Support temporary URLs (e.g. presigned URLs for S3 buckets) for disks that support it
 -   [ ] Support transfer logic for transferring single uploads from one disk to another and in bulk.
 -   [ ] Support `getTemporaryFile` to copy an upload file to the local filesystem tmp directory for direct manipulation
+-   [ ] Instead of using an `Upload` type that is `any`, we should use generics
 
 ## Development
 

package.json

@@ -54,6 +54,7 @@
         "husky": "^1.3.1",
         "jest": "^24.5.0",
         "lint-staged": "^8.1.5",
+        "memfs": "^2.15.2",
         "npm-watch": "^0.6.0",
         "prettier": "1.16.4",
         "semantic-release": "^15.13.3",

src/index.ts

@@ -5,3 +5,4 @@ export * from './types';
 export * from './lib/Uploads';
 export * from './lib/defaults';
 export * from './errors';
+export * from './support'

src/lib/Uploads.test.ts

@@ -0,0 +1,260 @@
+import { DiskDriver, DiskManager } from '@carimus/node-disks';
+import { MemoryRepository } from '../support';
+import { Uploads } from './Uploads';
+import { UploadMeta } from '../types';
+
+const disks = {
+    default: 'memory',
+    memory: {
+        driver: DiskDriver.Memory,
+    },
+};
+
+function setup(): {
+    diskManager: DiskManager;
+    repository: MemoryRepository;
+    uploads: Uploads;
+} {
+    const diskManager = new DiskManager(disks);
+    const repository = new MemoryRepository();
+    return {
+        diskManager,
+        repository,
+        uploads: new Uploads({
+            disks: diskManager,
+            repository,
+        }),
+    };
+}
+
+const files: {
+    [key: string]: { uploadedAs: string; data: Buffer; meta: UploadMeta };
+} = {
+    normal: {
+        uploadedAs: 'foo.txt',
+        data: Buffer.from('This is a normal text test file.\n', 'utf8'),
+        meta: { context: 'test', isFoo: true },
+    },
+    image: {
+        uploadedAs: 'black-1x1.png',
+        data: Buffer.from(
+            'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
+            'base64',
+        ),
+        meta: { context: 'test', isFoo: false, isImage: true },
+    },
+    weirdName: {
+        uploadedAs: '.~my~cool~data~&^%$*(¶•ª•.csv',
+        data: Buffer.from('a,b,c\nfoo,bar,baz\n1,2,3\n', 'utf8'),
+        meta: { context: 'test', isFoo: false, isImage: true },
+    },
+};
+
+test('Uploads service can upload and persist to repository.', async () => {
+    const { diskManager, repository, uploads } = setup();
+
+    // Upload all the files
+    const normalUpload = await uploads.upload(
+        files.normal.data,
+        files.normal.uploadedAs,
+        files.normal.meta,
+    );
+    const imageUpload = await uploads.upload(
+        files.image.data,
+        files.image.uploadedAs,
+        files.image.meta,
+    );
+    const weirdNameUpload = await uploads.upload(
+        files.weirdName.data,
+        files.weirdName.uploadedAs,
+        files.weirdName.meta,
+    );
+
+    // Check the repository for the file data
+    const normalFileInfo = await repository.getUploadedFileInfo(normalUpload);
+    const imageFileInfo = await repository.getUploadedFileInfo(imageUpload);
+    const weirdNameFileInfo = await repository.getUploadedFileInfo(
+        weirdNameUpload,
+    );
+    expect(normalFileInfo).toBeTruthy();
+    expect(typeof normalFileInfo).toBe('object');
+    expect(imageFileInfo).toBeTruthy();
+    expect(typeof imageFileInfo).toBe('object');
+    expect(weirdNameFileInfo).toBeTruthy();
+    expect(typeof weirdNameFileInfo).toBe('object');
+
+    // Check the disk for disk data
+    const normalDiskData = await diskManager
+        .getDisk(normalFileInfo.disk)
+        .read(normalFileInfo.path);
+    const imageDiskData = await diskManager
+        .getDisk(imageFileInfo.disk)
+        .read(imageFileInfo.path);
+    const weirdNameDiskData = await diskManager
+        .getDisk(weirdNameFileInfo.disk)
+        .read(weirdNameFileInfo.path);
+    expect(normalDiskData.toString('base64')).toBe(
+        files.normal.data.toString('base64'),
+    );
+    expect(imageDiskData.toString('base64')).toBe(
+        files.image.data.toString('base64'),
+    );
+    expect(weirdNameDiskData.toString('base64')).toBe(
+        files.weirdName.data.toString('base64'),
+    );
+});
+
+test('Uploads service can duplicate an upload, creating a new repository record for it.', async () => {
+    const { diskManager, repository, uploads } = setup();
+
+    // Upload a file and then duplicate it with new metadata (and also with no new meta)
+    const original = await uploads.upload(
+        files.normal.data,
+        files.normal.uploadedAs,
+        files.normal.meta,
+    );
+    const duplicateMeta = { ...files.normal.meta, isDup: true };
+    const duplicate = await uploads.duplicate(original, duplicateMeta);
+    const duplicateOldMeta = await uploads.duplicate(original);
+
+    // Check the repository for the original file data and the new file data
+    const originalFileRecord = await repository.find(original.id);
+    const duplicateFileRecord = await repository.find(duplicate.id);
+    const duplicateOldMetaFileRecord = await repository.find(
+        duplicateOldMeta.id,
+    );
+    expect(originalFileRecord.meta).toMatchObject(files.normal.meta);
+    expect(duplicateFileRecord.meta).toMatchObject(duplicateMeta);
+    expect(originalFileRecord).not.toMatchObject(duplicateFileRecord);
+    expect(duplicateOldMetaFileRecord.meta).toMatchObject(files.normal.meta);
+
+    // Check the disk for the original file and the new file
+    const originalFileInfo = await repository.getUploadedFileInfo(original.id);
+    const duplicateFileInfo = await repository.getUploadedFileInfo(
+        duplicate.id,
+    );
+    const originalFileData = await diskManager
+        .getDisk(originalFileInfo.disk)
+        .read(originalFileInfo.path);
+    const duplicateFileData = await diskManager
+        .getDisk(duplicateFileInfo.disk)
+        .read(duplicateFileInfo.path);
+    expect(originalFileData.toString('base64')).toBe(
+        files.normal.data.toString('base64'),
+    );
+    expect(duplicateFileData.toString('base64')).toBe(
+        files.normal.data.toString('base64'),
+    );
+});
+
+test('Uploads service can update, updating existing repository records and deleting old files.', async () => {
+    const { diskManager, repository, uploads } = setup();
+
+    // Upload a file and check to ensure it was created on the disk
+    const original = await uploads.upload(
+        files.normal.data,
+        files.normal.uploadedAs,
+        files.normal.meta,
+    );
+    const originalFileInfo = await repository.getUploadedFileInfo(original);
+    await expect(
+        diskManager.getDisk(originalFileInfo.disk).read(originalFileInfo.path),
+    ).resolves.toBeTruthy();
+
+    // Update the file, get its new info, ensure the new file exists and that the old one was deleted.
+    const updatedNewMeta = await uploads.update(
+        original,
+        files.image.data,
+        files.image.uploadedAs,
+        files.image.meta,
+    );
+    const updatedNewMetaFileInfo = await repository.getUploadedFileInfo(
+        updatedNewMeta,
+    );
+    expect(original.id).toBe(updatedNewMeta.id);
+    await expect(
+        diskManager.getDisk(originalFileInfo.disk).read(originalFileInfo.path),
+    ).rejects.toBeTruthy();
+    await expect(
+        diskManager
+            .getDisk(updatedNewMetaFileInfo.disk)
+            .read(updatedNewMetaFileInfo.path),
+    ).resolves.toBeTruthy();
+    expect(await repository.getMeta(updatedNewMeta)).toMatchObject(
+        files.image.meta,
+    );
+
+    // Let's also ensure that meta is preserved if we don't pass any new meta
+    const updatedOldMeta = await uploads.update(
+        updatedNewMeta,
+        files.weirdName.data,
+        files.weirdName.uploadedAs,
+    );
+    const updatedOldMetaFileInfo = await repository.getUploadedFileInfo(
+        updatedOldMeta,
+    );
+    await expect(
+        diskManager.getDisk(originalFileInfo.disk).read(originalFileInfo.path),
+    ).rejects.toBeTruthy();
+    await expect(
+        diskManager
+            .getDisk(updatedNewMetaFileInfo.disk)
+            .read(updatedNewMetaFileInfo.path),
+    ).rejects.toBeTruthy();
+    await expect(
+        diskManager
+            .getDisk(updatedOldMetaFileInfo.disk)
+            .read(updatedOldMetaFileInfo.path),
+    ).resolves.toBeTruthy();
+    expect(await repository.getMeta(updatedOldMeta)).toMatchObject(
+        files.image.meta,
+    );
+});
+
+test('Uploads service can delete', async () => {
+    const { diskManager, repository, uploads } = setup();
+
+    // Upload a file and check to ensure it was created on the disk
+    const upload = await uploads.upload(
+        files.normal.data,
+        files.normal.uploadedAs,
+        files.normal.meta,
+    );
+    const fileInfo = await repository.getUploadedFileInfo(upload);
+    await expect(repository.getMeta(upload)).resolves.toBeTruthy();
+    await expect(
+        diskManager.getDisk(fileInfo.disk).read(fileInfo.path),
+    ).resolves.toBeTruthy();
+
+    // Delete the upload and ensure it was deleted both from the disk and the repository.
+    await uploads.delete(upload);
+    await expect(repository.getUploadedFileInfo(upload)).rejects.toBeTruthy();
+    await expect(repository.getMeta(upload)).rejects.toBeTruthy();
+    await expect(
+        diskManager.getDisk(fileInfo.disk).read(fileInfo.path),
+    ).rejects.toBeTruthy();
+});
+
+test('Uploads service can delete only the file', async () => {
+    const { diskManager, repository, uploads } = setup();
+
+    // Upload a file and check to ensure it was created on the disk
+    const upload = await uploads.upload(
+        files.normal.data,
+        files.normal.uploadedAs,
+        files.normal.meta,
+    );
+    const fileInfo = await repository.getUploadedFileInfo(upload);
+    await expect(repository.getMeta(upload)).resolves.toBeTruthy();
+    await expect(
+        diskManager.getDisk(fileInfo.disk).read(fileInfo.path),
+    ).resolves.toBeTruthy();
+
+    // Delete the upload and ensure it was deleted from the disk but **NOT** the repository
+    await uploads.delete(upload, true);
+    await expect(repository.getUploadedFileInfo(upload)).resolves.toBeTruthy();
+    await expect(repository.getMeta(upload)).resolves.toBeTruthy();
+    await expect(
+        diskManager.getDisk(fileInfo.disk).read(fileInfo.path),
+    ).rejects.toBeTruthy();
+});