implemented HEAD operation

Author: larryrider

src/webdav/handlers/HEAD.handler.ts

@@ -1,9 +1,51 @@
-import { WebDavMethodHandler } from '../../types/webdav.types';
 import { Request, Response } from 'express';
+import { WebDavMethodHandler } from '../../types/webdav.types';
+import { WebDavUtils } from '../../utils/webdav.utils';
+import { webdavLogger } from '../../utils/logger.utils';
+import { DriveFileService } from '../../services/drive/drive-file.service';
+import { DriveDatabaseManager } from '../../services/database/drive-database-manager.service';
+import { DriveFileItem } from '../../types/drive.types';
+import { NetworkUtils } from '../../utils/network.utils';
 
 export class HEADRequestHandler implements WebDavMethodHandler {
-  handle = async (_: Request, res: Response) => {
-    // This is a NOOP request handler, clients like CyberDuck uses this.
-    res.status(405).send();
+  constructor(
+    private readonly dependencies: {
+      driveFileService: DriveFileService;
+      driveDatabaseManager: DriveDatabaseManager;
+    },
+  ) {}
+
+  handle = async (req: Request, res: Response) => {
+    const { driveDatabaseManager, driveFileService } = this.dependencies;
+    const resource = await WebDavUtils.getRequestedResource(req);
+
+    if (resource.type === 'folder') {
+      res.status(200).send();
+      return;
+    }
+
+    webdavLogger.info(`[HEAD] Request received for ${resource.type} at ${resource.url}`);
+    const driveFile = (await WebDavUtils.getAndSearchItemFromResource({
+      resource,
+      driveDatabaseManager,
+      driveFileService,
+    })) as DriveFileItem;
+
+    webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
+
+    const range = req.headers['range'];
+    const rangeOptions = NetworkUtils.parseRangeHeader({
+      range,
+      totalFileSize: driveFile.size,
+    });
+    let contentLength = driveFile.size;
+    if (rangeOptions) {
+      webdavLogger.info(`[HEAD] [${driveFile.uuid}] Range request received:`, { rangeOptions });
+      contentLength = rangeOptions.rangeSize;
+    }
+
+    res.header('Content-Type', 'application/octet-stream');
+    res.header('Content-length', contentLength.toString());
+    res.status(200).send();
   };
 }

test/webdav/handlers/HEAD.handler.test.ts

@@ -1,23 +1,115 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { HEADRequestHandler } from '../../../src/webdav/handlers/HEAD.handler';
-import { createWebDavRequestFixture, createWebDavResponseFixture } from '../../fixtures/webdav.fixture';
+import {
+  createWebDavRequestFixture,
+  createWebDavResponseFixture,
+  getRequestedFileResource,
+  getRequestedFolderResource,
+} from '../../fixtures/webdav.fixture';
+import { DriveFileService } from '../../../src/services/drive/drive-file.service';
+import { getDriveDatabaseManager } from '../../fixtures/drive-database.fixture';
+import { WebDavRequestedResource } from '../../../src/types/webdav.types';
+import { newFileItem } from '../../fixtures/drive.fixture';
+import { WebDavUtils } from '../../../src/utils/webdav.utils';
+import { randomInt } from 'crypto';
 
 describe('HEAD request handler', () => {
   beforeEach(() => {
     vi.restoreAllMocks();
   });
 
-  it('When a WebDav client sends a HEAD request, it should reply with a 405', async () => {
-    const requestHandler = new HEADRequestHandler();
+  it('When a folder is requested, it should reply with a 200', async () => {
+    const requestHandler = new HEADRequestHandler({
+      driveDatabaseManager: getDriveDatabaseManager(),
+      driveFileService: DriveFileService.instance,
+    });
+
+    const requestedFolderResource: WebDavRequestedResource = getRequestedFolderResource();
+
+    const request = createWebDavRequestFixture({
+      method: 'HEAD',
+      url: requestedFolderResource.url,
+      headers: {},
+    });
+    const response = createWebDavResponseFixture({
+      status: vi.fn().mockReturnValue({ send: vi.fn() }),
+    });
+
+    await requestHandler.handle(request, response);
+    expect(response.status).toHaveBeenCalledWith(200);
+  });
+
+  it('When a file is requested, it should reply with a 200 with the correct headers', async () => {
+    const requestHandler = new HEADRequestHandler({
+      driveDatabaseManager: getDriveDatabaseManager(),
+      driveFileService: DriveFileService.instance,
+    });
+
+    const requestedFileResource: WebDavRequestedResource = getRequestedFileResource();
+
+    const request = createWebDavRequestFixture({
+      method: 'HEAD',
+      url: requestedFileResource.url,
+      headers: {},
+    });
+    const response = createWebDavResponseFixture({
+      status: vi.fn().mockReturnValue({ send: vi.fn() }),
+      header: vi.fn(),
+    });
+
+    const mockFile = newFileItem();
+
+    const getRequestedResourceStub = vi
+      .spyOn(WebDavUtils, 'getRequestedResource')
+      .mockResolvedValue(requestedFileResource);
+    const getAndSearchItemFromResourceStub = vi
+      .spyOn(WebDavUtils, 'getAndSearchItemFromResource')
+      .mockResolvedValue(mockFile);
+
+    await requestHandler.handle(request, response);
+    expect(response.status).toHaveBeenCalledWith(200);
+    expect(response.header).toHaveBeenCalledWith('Content-Type', 'application/octet-stream');
+    expect(response.header).toHaveBeenCalledWith('Content-length', mockFile.size.toString());
+    expect(getRequestedResourceStub).toHaveBeenCalledOnce();
+    expect(getAndSearchItemFromResourceStub).toHaveBeenCalledOnce();
+  });
+
+  it('When a file is requested with range-request, it should reply with a 200 with the correct headers', async () => {
+    const requestHandler = new HEADRequestHandler({
+      driveDatabaseManager: getDriveDatabaseManager(),
+      driveFileService: DriveFileService.instance,
+    });
+
+    const requestedFileResource: WebDavRequestedResource = getRequestedFileResource();
+
+    const mockSize = randomInt(500, 10000);
+    const mockFile = newFileItem({ size: mockSize });
+    const rangeStart = randomInt(0, 450);
 
     const request = createWebDavRequestFixture({
       method: 'HEAD',
+      url: requestedFileResource.url,
+      headers: {
+        range: `bytes=${rangeStart}-${mockSize}`,
+      },
     });
     const response = createWebDavResponseFixture({
       status: vi.fn().mockReturnValue({ send: vi.fn() }),
+      header: vi.fn(),
     });
 
+    const getRequestedResourceStub = vi
+      .spyOn(WebDavUtils, 'getRequestedResource')
+      .mockResolvedValue(requestedFileResource);
+    const getAndSearchItemFromResourceStub = vi
+      .spyOn(WebDavUtils, 'getAndSearchItemFromResource')
+      .mockResolvedValue(mockFile);
+
     await requestHandler.handle(request, response);
-    expect(response.status).toHaveBeenCalledWith(405);
+    expect(response.status).toHaveBeenCalledWith(200);
+    expect(response.header).toHaveBeenCalledWith('Content-length', (mockSize - rangeStart).toString());
+    expect(response.header).toHaveBeenCalledWith('Content-Type', 'application/octet-stream');
+    expect(getRequestedResourceStub).toHaveBeenCalledOnce();
+    expect(getAndSearchItemFromResourceStub).toHaveBeenCalledOnce();
   });
 });