feat(files): add support manage video/files

Author: MatthewPattell

microservices/files/__tests__/services/file/any-file-test.ts

@@ -0,0 +1,115 @@
+import { RemoteConfig } from '@lomray/microservice-helpers';
+import { TypeormMock } from '@lomray/microservice-helpers/mocks';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { getRepository } from 'typeorm';
+import { bucketNameMock } from '@__mocks__/common';
+import FileType from '@constants/file-type';
+import CONST from '@constants/index';
+import File from '@entities/file';
+import type { IRemoteConfig } from '@interfaces/remote-config';
+import AnyFile from '@services/file/any-file';
+import StorageFactory from '@services/storage/factory';
+
+describe('services/file/any-file', () => {
+  const sandbox = sinon.createSandbox();
+  const fileData = getRepository(File).create({
+    id: 'file_id',
+  });
+  const processingConfig: IRemoteConfig = {
+    storagePathPrefix: CONST.STORAGE_PATH_PREFIX,
+  };
+
+  beforeEach(() => {
+    TypeormMock.sandbox.reset();
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('should successfully save file', async () => {
+    TypeormMock.entityManager.save.resolves(fileData);
+    sandbox.stub(RemoteConfig, 'get').resolves({ s3: { bucketName: bucketNameMock } });
+
+    const storage = await StorageFactory.create();
+    const service = new AnyFile(
+      FileType.file,
+      TypeormMock.entityManager,
+      storage,
+      processingConfig,
+    );
+
+    sandbox.stub(service, <any>'composeData').resolves({
+      fileData: { url: 'url', type: FileType.file },
+      fileBuffer: undefined,
+    });
+
+    sandbox.stub(service, <any>'uploadFile');
+
+    const entity = await service.save('file', 'user_id');
+
+    const [, file] = TypeormMock.entityManager.save.firstCall.args;
+
+    expect(entity).to.deep.equal(fileData);
+    expect(file).to.deep.equal({
+      userId: 'user_id',
+      url: '/',
+      type: FileType.file,
+    });
+  });
+
+  it('should successfully remove file', async () => {
+    sandbox.stub(RemoteConfig, 'get').resolves({ s3: { bucketName: bucketNameMock } });
+
+    const storage = await StorageFactory.create();
+    const service = new AnyFile(
+      FileType.file,
+      TypeormMock.entityManager,
+      storage,
+      processingConfig,
+    );
+
+    sandbox.stub(storage, 'delete');
+
+    const isRemoved = await service.remove(fileData);
+
+    const [, file] = TypeormMock.entityManager.remove.firstCall.args;
+
+    expect(isRemoved).to.ok;
+    expect(file).to.deep.equal(fileData);
+  });
+
+  it('should successfully update file', async () => {
+    TypeormMock.entityManager.save.resolves(fileData);
+    sandbox.stub(RemoteConfig, 'get').resolves({ s3: { bucketName: bucketNameMock } });
+
+    const storage = await StorageFactory.create();
+    const service = new AnyFile(
+      FileType.file,
+      TypeormMock.entityManager,
+      storage,
+      processingConfig,
+    );
+
+    sandbox.stub(service, <any>'composeData').resolves({
+      fileData: { url: 'url', type: FileType.file },
+      fileBuffer: undefined,
+    });
+
+    sandbox.stub(service, <any>'uploadFile');
+
+    sandbox.stub(storage, 'delete');
+
+    const entity = await service.update(fileData, 'file');
+
+    const [, fileEntity] = TypeormMock.entityManager.save.firstCall.args;
+
+    expect(entity).to.deep.equal(fileData);
+    expect(fileEntity).to.deep.equal({
+      id: 'file_id',
+      url: 'url',
+      type: FileType.file,
+    });
+  });
+});

microservices/files/__tests__/services/file/factory-test.ts

@@ -1,10 +1,9 @@
 import { RemoteConfig } from '@lomray/microservice-helpers';
 import { TypeormMock } from '@lomray/microservice-helpers/mocks';
-import { waitResult } from '@lomray/microservice-helpers/test-helpers';
 import { expect } from 'chai';
 import sinon from 'sinon';
-import { bucketNameMock } from '@__mocks__/common';
 import FileType from '@constants/file-type';
+import AnyFile from '@services/file/any-file';
 import Factory from '@services/file/factory';
 import Image from '@services/file/image';
 import StorageFactory from '@services/storage/factory';
@@ -25,11 +24,21 @@ describe('services/file/factory', () => {
     expect(service).instanceof(Image);
   });
 
-  it('should throw error: Not implemented', async () => {
-    sandbox.stub(RemoteConfig, 'get').resolves({ s3: { bucketName: bucketNameMock } });
-    // @ts-ignore
-    const service = Factory.create('unknown', TypeormMock.entityManager);
+  it('should successful create AnyFile instance', async () => {
+    sandbox.stub(RemoteConfig, 'get').resolves({});
+    sandbox.stub(StorageFactory, 'create');
+
+    const service = await Factory.create(FileType.file, TypeormMock.entityManager);
+
+    expect(service).instanceof(AnyFile);
+  });
+
+  it('should successful create AnyFile instance for video', async () => {
+    sandbox.stub(RemoteConfig, 'get').resolves({});
+    sandbox.stub(StorageFactory, 'create');
+
+    const service = await Factory.create(FileType.video, TypeormMock.entityManager);
 
-    expect(await waitResult(service)).to.throw('Not implemented');
+    expect(service).instanceof(AnyFile);
   });
 });

microservices/files/__tests__/services/file/image-test.ts

@@ -21,6 +21,10 @@ describe('services/file/image', () => {
     storagePathPrefix: CONST.STORAGE_PATH_PREFIX,
   };
 
+  beforeEach(() => {
+    TypeormMock.sandbox.reset();
+  });
+
   afterEach(() => {
     sandbox.restore();
   });
@@ -89,8 +93,8 @@ describe('services/file/image', () => {
 
     expect(entity).to.deep.equal(fileData);
     expect(fileEntity).to.deep.equal({
-      userId: 'user_id',
-      url: '/',
+      id: 'file_id',
+      url: 'url',
       type: FileType.image,
     });
   });