Merge pull request #215 from hypercerts-org/fix/upload_limit

bitbeckers · web-flow · commit bcdb8daf7590 · 2025-01-22T11:04:40.000+01:00
Set upload limit to 11MB
diff --git a/src/controllers/UploadController.ts b/src/controllers/UploadController.ts
@@ -147,20 +147,20 @@ export class UploadController extends Controller {
     @FormField() jsonData?: string,
   ): Promise<UploadResponse> {
     try {
+      if (!files?.length) {
+        throw new NoFilesUploadedError();
+      }
+
       const storage = await StorageService.init();
 
       if (jsonData) {
         console.debug("Got JSON data for future use");
       }
 
-      const blobs = files?.map(
+      const blobs = files.map(
         (file) => new Blob([file.buffer], { type: file.mimetype }),
       );
 
-      if (!files || !blobs) {
-        throw new NoFilesUploadedError();
-      }
-
       const uploadResults = await Promise.allSettled(
         files.map(async (file, index) => {
           try {
diff --git a/src/middleware/upload.ts b/src/middleware/upload.ts
@@ -25,8 +25,13 @@ export const validateFile = async (
   req: Request,
   file: Express.Multer.File,
 ): Promise<void> => {
+  // Check if buffer exists
+  if (!file.buffer) {
+    throw new Error(FileValidationError.INVALID_TYPE);
+  }
+
   // 1. Check file size
-  if (file.size > 10 * 1024 * 1024) {
+  if (file.size > 11 * 1024 * 1024) {
     throw new Error(FileValidationError.SIZE_EXCEEDED);
   }
 
@@ -47,7 +52,7 @@ export const validateFile = async (
 // Configure multer with validation
 export const upload = multer({
   limits: {
-    fileSize: 10 * 1024 * 1024, // 10MB
+    fileSize: 11 * 1024 * 1024, // 11MB
     files: 5,
   },
   storage: multer.memoryStorage(),
diff --git a/test/api/v1/AllowlistController.test.ts b/test/api/v1/AllowlistController.test.ts
diff --git a/test/api/v1/MetadataController.test.ts b/test/api/v1/MetadataController.test.ts
diff --git a/test/api/v1/UploadController.test.ts b/test/api/v1/UploadController.test.ts
@@ -1,7 +1,8 @@
-import { describe, test, vi } from "vitest";
 import { expect } from "chai";
+import { describe, test, vi } from "vitest";
 import { mock } from "vitest-mock-extended";
 import { UploadController } from "../../../src/controllers/UploadController.js";
+import { SingleUploadFailedError } from "../../../src/lib/uploads/errors.js";
 import { StorageService } from "../../../src/services/StorageService.js";
 import { createMockFile, mockTextFile } from "../../test-utils/mockFile.js";
 
@@ -150,4 +151,49 @@ describe("File upload at v1/upload", async () => {
       { cid: "TEST_CID_2", fileName: "page.html" },
     ]);
   });
+
+  test("Handles empty file array", async () => {
+    mocks.init.mockResolvedValue(mockStorage);
+
+    const response = await controller.upload([]);
+
+    expect(response.success).to.be.false;
+    expect(response.uploadStatus).to.equal("none");
+    expect(response.message).to.equal("No files uploaded");
+  });
+
+  test("Handles file size validation", async () => {
+    mocks.init.mockResolvedValue(mockStorage);
+    mockStorage.uploadFile.mockRejectedValue(
+      new SingleUploadFailedError("large.txt", "Failed to upload large.txt"),
+    );
+
+    const largeFile = createMockFile(
+      Buffer.alloc(12 * 1024 * 1024),
+      "large.txt",
+      "text/plain",
+    );
+
+    const response = await controller.upload([largeFile]);
+
+    expect(response.success).to.be.false;
+    expect(response.uploadStatus).to.equal("none");
+    expect(response.data?.failed[0]).to.deep.equal({
+      fileName: "large.txt",
+      error: "Failed to upload large.txt",
+    });
+  });
+
+  test("Processes optional JSON metadata", async () => {
+    mocks.init.mockResolvedValue(mockStorage);
+    mockStorage.uploadFile.mockResolvedValue({ cid: "TEST_CID" });
+
+    const response = await controller.upload(
+      [mockTextFile],
+      JSON.stringify({ key: "value" }),
+    );
+
+    expect(response.success).to.be.true;
+    expect(response.data?.results[0].cid).to.equal("TEST_CID");
+  });
 });
diff --git a/test/middleware/upload.test.ts b/test/middleware/upload.test.ts
@@ -1,8 +1,13 @@
 import { describe, test, expect, vi } from "vitest";
+import { Request } from "express";
+import {
+  FileExtension,
+  fileTypeFromBuffer,
+  type FileTypeResult,
+  type MimeType,
+} from "file-type";
 import { createMockFile } from "../test-utils/mockFile";
 import { FileValidationError, validateFile } from "../../src/middleware/upload";
-import { fileTypeFromBuffer, type FileTypeResult } from "file-type";
-import { Request } from "express";
 import { mock } from "vitest-mock-extended";
 
 // Mock file-type
@@ -16,15 +21,15 @@ describe("Upload Middleware", () => {
   test("accepts valid file", async () => {
     const mockFile = createMockFile("test content", "test.txt", "text/plain");
     vi.mocked(fileTypeFromBuffer).mockResolvedValue({
-      mime: "text/plain" as const,
-      ext: "txt",
+      mime: "text/plain" as MimeType,
+      ext: "txt" as FileExtension,
     } satisfies FileTypeResult);
 
     await expect(validateFile(mockReq, mockFile)).resolves.not.toThrow();
   });
 
   test("rejects oversized file", async () => {
-    const largeContent = "x".repeat(11 * 1024 * 1024); // 11MB
+    const largeContent = "x".repeat(12 * 1024 * 1024); // 12MB
     const mockFile = createMockFile(largeContent, "large.txt", "text/plain");
 
     await expect(validateFile(mockReq, mockFile)).rejects.toThrow(
@@ -47,8 +52,8 @@ describe("Upload Middleware", () => {
   test("rejects file with mismatched content type", async () => {
     const mockFile = createMockFile("<html></html>", "fake.txt", "text/plain");
     vi.mocked(fileTypeFromBuffer).mockResolvedValue({
-      mime: "text/html" as const,
-      ext: "html",
+      mime: "text/html" as MimeType,
+      ext: "html" as FileExtension,
     } satisfies FileTypeResult);
 
     await expect(validateFile(mockReq, mockFile)).rejects.toThrow(
@@ -58,9 +63,9 @@ describe("Upload Middleware", () => {
 
   test("handles different allowed file types", async () => {
     const testCases = [
-      { content: "test", name: "test.txt", type: "text/plain" as const },
-      { content: "{}", name: "test.json", type: "application/json" as const },
-      { content: "PDF", name: "test.pdf", type: "application/pdf" as const },
+      { content: "test", name: "test.txt", type: "text/plain" as MimeType },
+      { content: "{}", name: "test.json", type: "application/json" },
+      { content: "PDF", name: "test.pdf", type: "application/pdf" as MimeType },
     ];
 
     for (const testCase of testCases) {
@@ -69,18 +74,22 @@ describe("Upload Middleware", () => {
         testCase.name,
         testCase.type,
       );
-      vi.mocked(fileTypeFromBuffer).mockResolvedValue({
-        mime: testCase.type,
-        ext: testCase.name.split(".")[1],
-      } satisfies FileTypeResult);
+      vi.mocked(fileTypeFromBuffer).mockResolvedValue(
+        testCase.type === "application/json"
+          ? undefined // JSON files typically return undefined
+          : ({
+              mime: testCase.type as MimeType,
+              ext: testCase.name.split(".")[1] as FileExtension,
+            } satisfies FileTypeResult),
+      );
 
       await expect(validateFile(mockReq, mockFile)).resolves.not.toThrow();
     }
   });
 
   test("handles null file type detection", async () => {
     const mockFile = createMockFile("test", "test.txt", "text/plain");
-    vi.mocked(fileTypeFromBuffer).mockResolvedValue(null);
+    vi.mocked(fileTypeFromBuffer).mockResolvedValue(undefined);
 
     await expect(validateFile(mockReq, mockFile)).resolves.not.toThrow();
   });
@@ -93,4 +102,66 @@ describe("Upload Middleware", () => {
 
     await expect(validateFile(mockReq, mockFile)).rejects.toThrow();
   });
+
+  test("accepts valid image files", async () => {
+    const mockFile = createMockFile(
+      "fake-image-data",
+      "photo.jpg",
+      "image/jpeg",
+    );
+    vi.mocked(fileTypeFromBuffer).mockResolvedValue({
+      mime: "image/jpeg" as MimeType,
+      ext: "jpg",
+    } satisfies FileTypeResult);
+
+    await expect(validateFile(mockReq, mockFile)).resolves.not.toThrow();
+  });
+
+  test("accepts valid JSON file", async () => {
+    const mockFile = createMockFile(
+      JSON.stringify({ test: "data" }),
+      "data.json",
+      "application/json",
+    );
+    // For JSON files, fileTypeFromBuffer typically returns undefined
+    vi.mocked(fileTypeFromBuffer).mockResolvedValue(undefined);
+
+    await expect(validateFile(mockReq, mockFile)).resolves.not.toThrow();
+  });
+
+  test("accepts file at exact size limit", async () => {
+    const content = Buffer.alloc(11 * 1024 * 1024); // Exactly 11MB
+    const mockFile = createMockFile(content, "at-limit.txt", "text/plain");
+    vi.mocked(fileTypeFromBuffer).mockResolvedValue({
+      mime: "text/plain" as MimeType,
+      ext: "txt" as FileExtension,
+    } satisfies FileTypeResult);
+
+    await expect(validateFile(mockReq, mockFile)).resolves.not.toThrow();
+  });
+
+  test("accepts empty file with valid type", async () => {
+    const mockFile = createMockFile("", "empty.txt", "text/plain");
+    vi.mocked(fileTypeFromBuffer).mockResolvedValue(undefined);
+
+    await expect(validateFile(mockReq, mockFile)).resolves.not.toThrow();
+  });
+
+  test("handles file without extension", async () => {
+    const mockFile = createMockFile("content", "readme", "text/plain");
+    vi.mocked(fileTypeFromBuffer).mockResolvedValue({
+      mime: "text/plain" as MimeType,
+      ext: "txt" as FileExtension,
+    } satisfies FileTypeResult);
+
+    await expect(validateFile(mockReq, mockFile)).resolves.not.toThrow();
+  });
+
+  test("rejects file with missing buffer", async () => {
+    const mockFile = createMockFile("test", "test.txt", "text/plain");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockFile.buffer = undefined as any;
+
+    await expect(validateFile(mockReq, mockFile)).rejects.toThrow();
+  });
 });
diff --git a/test/test-utils/mockFile.ts b/test/test-utils/mockFile.ts
@@ -2,16 +2,16 @@ import { Buffer } from "buffer";
 import { Readable } from "node:stream";
 
 export const createMockFile = (
-  content: string = "test content",
-  filename: string = "test.txt",
-  mimetype: string = "text/plain",
+  content: string | Buffer,
+  filename: string,
+  mimetype = "text/plain",
 ): Express.Multer.File => ({
-  buffer: Buffer.from(content),
-  mimetype,
+  buffer: Buffer.isBuffer(content) ? content : Buffer.from(content),
   originalname: filename,
+  mimetype,
+  size: Buffer.isBuffer(content) ? content.length : Buffer.byteLength(content),
   fieldname: "files",
   encoding: "7bit",
-  size: Buffer.from(content).length,
   stream: null as unknown as Readable,
   destination: "",
   filename: filename,
diff --git a/vitest.config.ts b/vitest.config.ts
@@ -11,10 +11,10 @@ export default defineConfig({
       // If you want a coverage reports even if your tests are failing, include the reportOnFailure option
       reportOnFailure: true,
       thresholds: {
-        lines: 17,
-        branches: 60,
-        functions: 54,
-        statements: 17,
+        lines: 20,
+        branches: 64,
+        functions: 60,
+        statements: 20,
       },
       include: ["src/**/*.ts"],
       exclude: [
