added tests

Author: larryrider

src/utils/webdav.utils.ts

@@ -36,7 +36,9 @@ export class WebDavUtils {
     }
     const decodedUrl = decodeURIComponent(requestUrl);
     const parsedPath = path.parse(decodedUrl);
-    const parentPath = `/${path.dirname(decodedUrl).replace(/^(\/)|(\/)$/g, '')}/`.replaceAll('//', '/');
+    let parentPath = path.dirname(decodedUrl);
+    if (!parentPath.startsWith('/')) parentPath = '/'.concat(parentPath);
+    if (!parentPath.endsWith('/')) parentPath = parentPath.concat('/');
 
     const isFolder = requestUrl.endsWith('/');
 

src/webdav/handlers/PUT.handler.ts

@@ -55,12 +55,12 @@ export class PUTRequestHandler implements WebDavMethodHandler {
       })) as DriveFileItem;
       if (driveFileItem && driveFileItem.status === 'EXISTS') {
         webdavLogger.info(`File '${resource.name}' already exists in '${resource.path.dir}', trashing it before PUT`);
+        await driveDatabaseManager.deleteFileById(driveFileItem.id);
         await trashService.trashItems({
           items: [{ type: resource.type, uuid: driveFileItem.uuid }],
         });
-        await driveDatabaseManager.deleteFileById(driveFileItem.id);
       }
-    } catch (_) {
+    } catch {
       //noop
     }
 

test/fixtures/drive-database.fixture.ts

@@ -4,46 +4,41 @@ import { DriveFolder } from '../../src/services/database/drive-folder/drive-fold
 import { DriveDatabaseManager } from '../../src/services/database/drive-database-manager.service';
 import { DriveFileRepository } from '../../src/services/database/drive-file/drive-file.repository';
 import { DriveFolderRepository } from '../../src/services/database/drive-folder/drive-folder.repository';
+import { randomInt, randomUUID } from 'crypto';
 
-export const getDriveFileDatabaseFixture = (payload: Partial<DriveFile> = {}): DriveFile => {
-  // @ts-expect-error - We only mock the properties we need
-  const object: DriveFile = {
-    id: new Date().getTime(),
+export const getDriveFileDatabaseFixture = (): DriveFile => {
+  const object: DriveFile = new DriveFile({
+    id: randomInt(2000),
     name: `file_${new Date().getTime().toString()}`,
-    uuid: `uuid_${new Date().getTime().toString()}`,
-    relativePath: '',
+    uuid: randomUUID(),
+    relativePath: `file_${new Date().getTime().toString()}.txt`,
     createdAt: new Date(),
     updatedAt: new Date(),
     status: 'EXISTS',
     fileId: `file_id_${new Date().getTime().toString()}`,
-    folderId: 0,
+    folderId: randomInt(2000),
     bucket: new Date().getTime().toString(),
-    size: 0,
-  };
-
-  // @ts-expect-error - We only mock the properties we need
-  return {
-    ...object,
-    ...payload,
-  };
+    size: randomInt(2000),
+    folderUuid: randomUUID(),
+    type: 'txt',
+  });
+  return object;
 };
 
-export const getDriveFolderDatabaseFixture = (payload: Partial<DriveFolder> = {}): DriveFolder => {
-  // @ts-expect-error - We only mock the properties we need
-  const object: DriveFolder = {
-    id: new Date().getTime(),
+export const getDriveFolderDatabaseFixture = (): DriveFolder => {
+  const object: DriveFolder = new DriveFolder({
+    id: randomInt(2000),
     name: `folder_${new Date().getTime().toString()}`,
-    uuid: `uuid_${new Date().getTime().toString()}`,
+    uuid: randomUUID(),
     relativePath: '',
     createdAt: new Date(),
     updatedAt: new Date(),
-  };
+    parentId: randomInt(2000),
+    parentUuid: randomUUID(),
+    status: 'EXISTS',
+  });
 
-  // @ts-expect-error - We only mock the properties we need
-  return {
-    ...object,
-    ...payload,
-  };
+  return object;
 };
 
 export const getDriveDatabaseManager = (): DriveDatabaseManager => {

test/services/config.service.test.ts

@@ -1,10 +1,10 @@
 import { expect } from 'chai';
-import crypto, { randomUUID } from 'crypto';
+import crypto, { randomInt, randomUUID } from 'crypto';
 import Sinon, { SinonSandbox } from 'sinon';
 import fs from 'fs/promises';
 import { ConfigService } from '../../src/services/config.service';
 import { CryptoService } from '../../src/services/crypto.service';
-import { CLICredentials, LoginCredentials } from '../../src/types/command.types';
+import { CLICredentials, LoginCredentials, WebdavConfig } from '../../src/types/command.types';
 import { UserFixture } from '../fixtures/auth.fixture';
 
 import { config } from 'dotenv';
@@ -154,4 +154,66 @@ describe('Config service', () => {
 
     expect(stubMkdir).to.be.calledOnceWith(ConfigService.WEBDAV_SSL_CERTS_DIR);
   });
+
+  it('When webdav config options are saved, then they are written to a file', async () => {
+    const webdavConfig: WebdavConfig = {
+      port: String(randomInt(65000)),
+      protocol: 'https',
+    };
+    const stringConfig = JSON.stringify(webdavConfig);
+
+    const fsStub = configServiceSandbox
+      .stub(fs, 'writeFile')
+      .withArgs(ConfigService.WEBDAV_CONFIGS_FILE, stringConfig)
+      .resolves();
+
+    await ConfigService.instance.saveWebdavConfig(webdavConfig);
+    expect(fsStub).to.be.calledWith(ConfigService.WEBDAV_CONFIGS_FILE, stringConfig);
+  });
+
+  it('When webdav config options are read and exist, then they are read from a file', async () => {
+    const webdavConfig: WebdavConfig = {
+      port: String(randomInt(65000)),
+      protocol: 'http',
+    };
+    const stringConfig = JSON.stringify(webdavConfig);
+
+    const fsStub = configServiceSandbox
+      .stub(fs, 'readFile')
+      .withArgs(ConfigService.WEBDAV_CONFIGS_FILE)
+      .resolves(stringConfig);
+
+    const webdavConfigResult = await ConfigService.instance.readWebdavConfig();
+    expect(webdavConfigResult).to.be.eql(webdavConfig);
+    expect(fsStub).to.be.calledWith(ConfigService.WEBDAV_CONFIGS_FILE);
+  });
+
+  it('When webdav config options are read but not exist, then they are returned from defaults', async () => {
+    const defaultWebdavConfig: WebdavConfig = {
+      port: ConfigService.WEBDAV_DEFAULT_PORT,
+      protocol: ConfigService.WEBDAV_DEFAULT_PROTOCOL,
+    };
+
+    const fsStub = configServiceSandbox
+      .stub(fs, 'readFile')
+      .withArgs(ConfigService.WEBDAV_CONFIGS_FILE)
+      .resolves(undefined);
+
+    const webdavConfigResult = await ConfigService.instance.readWebdavConfig();
+    expect(webdavConfigResult).to.be.eql(defaultWebdavConfig);
+    expect(fsStub).to.be.calledWith(ConfigService.WEBDAV_CONFIGS_FILE);
+  });
+
+  it('When webdav config options are read but an error is thrown, then they are returned from defaults', async () => {
+    const defaultWebdavConfig: WebdavConfig = {
+      port: ConfigService.WEBDAV_DEFAULT_PORT,
+      protocol: ConfigService.WEBDAV_DEFAULT_PROTOCOL,
+    };
+
+    const fsStub = configServiceSandbox.stub(fs, 'readFile').withArgs(ConfigService.WEBDAV_CONFIGS_FILE).rejects();
+
+    const webdavConfigResult = await ConfigService.instance.readWebdavConfig();
+    expect(webdavConfigResult).to.be.eql(defaultWebdavConfig);
+    expect(fsStub).to.be.calledWith(ConfigService.WEBDAV_CONFIGS_FILE);
+  });
 });