chore(express-partial-content): integrate tests and convert to vitest

packages/express-partial-content/src/createPartialContentHandler.spec.ts

@@ -0,0 +1,181 @@
+import * as utils from "./utils.js";
+import * as ParseRangeHeaderExports from "./parseRangeHeader.js";
+import { ContentDoesNotExistError } from "./ContentDoesNotExistError.js";
+import { createPartialContentHandler } from "./createPartialContentHandler.js";
+import type { ContentProvider } from "./ContentProvider.js";
+import type { Logger } from "./Logger.js";
+import type { Request, Response } from "express";
+import type { Content } from "./Content.js";
+import { Stream } from "stream";
+import type { Range } from "./Range.js";
+import type { MockInstance } from "vitest";
+
+describe("createPartialContentHandler tests", () => {
+  let logger: Logger;
+  beforeEach(() => {
+    logger = {
+      debug: vi.fn() as (message: string, extra?: any) => void
+    };
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+  it("returns a handler", () => {
+    const contentProvider = vi.fn().mockResolvedValue({}) as ContentProvider;
+    const handler = createPartialContentHandler(contentProvider, logger);
+    expect(typeof handler === "function");
+  });
+
+  describe("handler tests", () => {
+    let req: Request;
+    let res: Response;
+    let statusSpy: MockInstance;
+    let sendSpy: MockInstance;
+    let sendStatusSpy: MockInstance;
+    beforeEach(() => {
+      req = {} as Request;
+      res = {
+        status: (code: number) => res,
+        send: (message: string) => res,
+        sendStatus: (code: number) => res,
+        setHeader: vi.fn() as (name: string, value: string) => void
+      } as Response;
+      statusSpy = vi.spyOn(res, "status");
+      sendSpy = vi.spyOn(res, "send");
+      sendStatusSpy = vi.spyOn(res, "sendStatus");
+    });
+    it("invokes contentProvider with the specified request", async () => {
+      const contentProvider = vi.fn().mockResolvedValue({}) as ContentProvider;
+      const handler = createPartialContentHandler(contentProvider, logger);
+      try {
+        await handler(req, res);
+      } catch {}
+      expect(contentProvider).toHaveBeenCalledExactlyOnceWith(req);
+    });
+    it("returns 404 if contentProvider throws ContentDoesNotExistError error", async () => {
+      const error = new ContentDoesNotExistError("404-File not found!");
+      const contentProvider = vi.fn().mockRejectedValue(error) as ContentProvider;
+      const handler = createPartialContentHandler(contentProvider, logger);
+      try {
+        await handler(req, res);
+        expect(statusSpy).toHaveBeenCalledExactlyOnceWith(404);
+        expect(sendSpy).toHaveBeenCalledExactlyOnceWith(error.message);
+      } catch {
+        expect(false);
+      }
+    });
+    it("returns 500 if contentProvider throws any other error", async () => {
+      const error = new Error("Something went wrong!");
+      const contentProvider = vi.fn().mockRejectedValue(error) as ContentProvider;
+      const handler = createPartialContentHandler(contentProvider, logger);
+      try {
+        await handler(req, res);
+        expect(sendStatusSpy).toHaveBeenCalledExactlyOnceWith(500);
+      } catch {
+        expect(false);
+      }
+    });
+    it("returns 416 if parseRangeHeader throws RangeParserError error", async () => {
+      const contentProvider = vi.fn().mockResolvedValue({}) as ContentProvider;
+      const handler = createPartialContentHandler(contentProvider, logger);
+      req.headers = { range: "bytes=30-10" };
+      try {
+        await handler(req, res);
+        expect(statusSpy).toHaveBeenCalledExactlyOnceWith(416);
+      } catch {
+        expect(false);
+      }
+    });
+    it("returns 500 if parseRangeHeader throws other errors", async () => {
+      const parseRangeHeaderStub = vi
+        .spyOn(ParseRangeHeaderExports, "parseRangeHeader")
+        .mockImplementation(() => {
+            throw new Error("Something went wrong!")
+        });
+      const contentProvider = vi.fn().mockResolvedValue({}) as ContentProvider;
+      const handler = createPartialContentHandler(contentProvider, logger);
+      try {
+        await handler(req, res);
+        expect(sendStatusSpy).toHaveBeenCalledExactlyOnceWith(500);
+      } catch {
+        expect(false);
+      }
+    });
+    it("returns correct response if range is not specified", async () => {
+      const result = ({
+        pipe() {
+          return result;
+        }
+      } as any) as Stream;
+      const content: Content = {
+        fileName: "file.txt",
+        totalSize: 10,
+        mimeType: "text/plain",
+        getStream(range?: Range) {
+          return result;
+        }
+      };
+      const pipeSpy = vi.spyOn(result, "pipe");
+      const getStreamSpy = vi.spyOn(content, "getStream");
+      const contentProvider = vi.fn().mockResolvedValue(content) as ContentProvider;
+      const handler = createPartialContentHandler(contentProvider, logger);
+      const setContentTypeHeaderSpy = vi.spyOn(utils, "setContentTypeHeader");
+      const setContentDispositionHeaderSpy = vi.spyOn(utils, "setContentDispositionHeader");
+      const setAcceptRangesHeaderSpy = vi.spyOn(utils, "setAcceptRangesHeader");
+      const setContentLengthHeaderSpy = vi.spyOn(utils, "setContentLengthHeader");
+      const setContentRangeHeaderSpy = vi.spyOn(utils, "setContentRangeHeader");
+      try {
+        await handler(req, res);
+        expect(setContentTypeHeaderSpy).toHaveBeenCalledExactlyOnceWith(content.mimeType, res);
+        expect(setContentDispositionHeaderSpy).toHaveBeenCalledExactlyOnceWith(content.fileName, res);
+        expect(setAcceptRangesHeaderSpy).toHaveBeenCalledExactlyOnceWith(res);
+        expect(setContentLengthHeaderSpy).toHaveBeenCalledExactlyOnceWith(content.totalSize, res);
+        expect(getStreamSpy).toHaveBeenCalledExactlyOnceWith();
+        expect(pipeSpy).toHaveBeenCalledExactlyOnceWith(res);
+        expect(setContentRangeHeaderSpy).not.toHaveBeenCalled();
+      } catch {
+        expect(false);
+      }
+    });
+    it("returns correct partial response if range is specified", async () => {
+      req.headers = {
+        range: "bytes=0-5"
+      };
+      const result = ({
+        pipe() {
+          return result;
+        }
+      } as any) as Stream;
+      const content: Content = {
+        fileName: "file.txt",
+        totalSize: 10,
+        mimeType: "text/plain",
+        getStream(range?: Range) {
+          return result;
+        }
+      };
+      const range = { start: 0, end: 5 };
+      const pipeSpy = vi.spyOn(result, "pipe");
+      const getStreamSpy = vi.spyOn(content, "getStream");
+      const contentProvider = vi.fn().mockResolvedValue(content) as ContentProvider;
+      const handler = createPartialContentHandler(contentProvider, logger);
+      const setContentTypeHeaderSpy = vi.spyOn(utils, "setContentTypeHeader");
+      const setContentDispositionHeaderSpy = vi.spyOn(utils, "setContentDispositionHeader");
+      const setAcceptRangesHeaderSpy = vi.spyOn(utils, "setAcceptRangesHeader");
+      const setContentLengthHeaderSpy = vi.spyOn(utils, "setContentLengthHeader");
+      const setContentRangeHeaderSpy = vi.spyOn(utils, "setContentRangeHeader");
+      try {
+        await handler(req, res);
+        expect(setContentTypeHeaderSpy).toHaveBeenCalledExactlyOnceWith(content.mimeType, res);
+        expect(setContentDispositionHeaderSpy).toHaveBeenCalledExactlyOnceWith(content.fileName, res);
+        expect(setAcceptRangesHeaderSpy).toHaveBeenCalledExactlyOnceWith(res);
+        expect(setContentRangeHeaderSpy).toHaveBeenCalledExactlyOnceWith(range, content.totalSize, res);
+        expect(setContentLengthHeaderSpy).toHaveBeenCalledExactlyOnceWith(6, res);
+        expect(getStreamSpy).toHaveBeenCalledExactlyOnceWith(range);
+        expect(pipeSpy).toHaveBeenCalledExactlyOnceWith(res);
+      } catch {
+        expect(false);
+      }
+    });
+  });
+});

packages/express-partial-content/src/parseRangeHeader.spec.ts

@@ -0,0 +1,54 @@
+import { parseRangeHeader } from "./parseRangeHeader.js";
+import type { Logger } from "./Logger.js";
+import { RangeParserError } from "./RangeParserError.js";
+
+describe("parseRangeHeader tests", () => {
+  let logger: Logger;
+  beforeEach(() => {
+    logger = {
+      debug: vi.fn() as (message: string, extra?: any) => void
+    };
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+  it("returns null if range is not specified", () => {
+    let value = parseRangeHeader("", 10, logger);
+    expect(value).to.be.equal(null);
+    value = parseRangeHeader(null, 10, logger);
+    expect(value).to.be.equal(null);
+  });
+  it("returns null if total size is zero", () => {
+    let value = parseRangeHeader("bytes=0-5", 0, logger);
+    expect(value).to.be.equal(null);
+  });
+  it("if end is not provided, sets end to the last byte (totalSize - 1).", () => {
+    let value = parseRangeHeader("bytes=0-", 10, logger);
+    expect(value).to.be.deep.equal({ start: 0, end: 9 });
+  });
+  it('if start is not provided, set it to the offset of last "end" bytes from the end of the file.', () => {
+    let value = parseRangeHeader("bytes=-5", 10, logger);
+    expect(value).to.be.deep.equal({ start: 5, end: 9 });
+  });
+  it("handles invalid ranges", () => {
+    try {
+      parseRangeHeader("bytes=6-5", 10, logger);
+    } catch (error) {
+      expect(error).that.be.instanceOf(RangeParserError);
+    }
+    try {
+      parseRangeHeader("bytes=6-7", 10, logger);
+    } catch (error) {
+      expect(error).that.be.instanceOf(RangeParserError);
+    }
+    try {
+      parseRangeHeader("bytes=6-11", 10, logger);
+    } catch (error) {
+      expect(error).that.be.instanceOf(RangeParserError);
+    }
+  });
+  it("returns a valid parsed range.", () => {
+    let value = parseRangeHeader("bytes=0-5", 10, logger);
+    expect(value).to.be.deep.equal({ start: 0, end: 5 });
+  });
+});

packages/express-partial-content/src/utils.spec.ts

@@ -0,0 +1,111 @@
+import type { Request, Response } from "express";
+import { expect, type Mock } from "vitest";
+
+import {
+  getHeader,
+  setHeader,
+  getRangeHeader,
+  setContentTypeHeader,
+  setContentLengthHeader,
+  setAcceptRangesHeader,
+  setContentDispositionHeader,
+  setContentRangeHeader,
+  setCacheControlHeaderNoCache
+} from "./utils.js";
+
+describe("utils tests", () => {
+  let req: Request;
+  let res: Response;
+  beforeEach(() => {
+    req = {
+      headers: {
+        "content-type": "application/octet-stream",
+        range: "*"
+      }
+    } as Request;
+    res = {
+      setHeader: vi.fn() as (name: string, value: string) => void
+    } as Response;
+  });
+  describe("getHeader tests", () => {
+    it("gets the specified header value if present", () => {
+      const value = getHeader("content-type", req);
+      expect(value).to.equal("application/octet-stream");
+    });
+    it("returns undefined if the specified header value is absent", () => {
+      const value = getHeader("mime-type", req);
+      expect(value).to.be.undefined;
+    });
+  });
+  describe("setHeader tests", () => {
+    it("invokes res.setHeader API with the specified name and value args", () => {
+      const name = "Content-Type";
+      const value = "application/octet-stream";
+      setHeader(name, value, res);
+      expect(res.setHeader).toHaveBeenCalledExactlyOnceWith(name, value);
+    });
+  });
+  describe("getRangeHeader tests", () => {
+    it("gets range header value", () => {
+      const value = getRangeHeader(req);
+      expect(value).to.equal("*");
+    });
+  });
+  describe("setContentTypeHeader tests", () => {
+    it("sets Content-Type header with specified value", () => {
+      const value = "application/octet-stream";
+      setContentTypeHeader(value, res);
+      expect(res.setHeader).toHaveBeenCalledExactlyOnceWith("Content-Type", value);
+    });
+  });
+  describe("setContentLengthHeader tests", () => {
+    it("sets Content-Length header with specified value", () => {
+      const value = "100";
+      setContentLengthHeader(value, res);
+      expect(res.setHeader).toHaveBeenCalledExactlyOnceWith("Content-Length", value);
+    });
+  });
+  describe("setAcceptRangesHeader tests", () => {
+    it("sets Accept-Ranges header with specified value", () => {
+      const value = "bytes";
+      setAcceptRangesHeader(res);
+      expect(res.setHeader).toHaveBeenCalledExactlyOnceWith("Accept-Ranges", value);
+    });
+  });
+  describe("setContentRangeHeader tests", () => {
+    it("sets Content-Range header with specified value", () => {
+      let range: { start: number, end: number } | null = { start: 10, end: 100 };
+      const size = 1000;
+      let value = `bytes ${range.start}-${range.end}/${size}`;
+      setContentRangeHeader(range, size, res);
+      expect(res.setHeader).toHaveBeenCalledExactlyOnceWith("Content-Range", value);
+      (res.setHeader as Mock).mockReset();
+
+      range = null;
+      value = `bytes */${size}`;
+      setContentRangeHeader(range, size, res);
+      expect(res.setHeader).toHaveBeenCalledExactlyOnceWith("Content-Range", value);
+    });
+  });
+  describe("setContentDispositionHeader tests", () => {
+    it("sets Content-Disposition header with specified value", () => {
+      const fileName = "file.txt";
+      const value = `attachment; filename*=utf-8''${fileName}`;
+      setContentDispositionHeader(fileName, res);
+      expect(res.setHeader).toHaveBeenCalledExactlyOnceWith("Content-Disposition", value);
+    });
+    it("sets Content-Disposition header with specified unicode", () => {
+      const fileName = "file.txt";
+      const value = `attachment; filename*=utf-8''${encodeURIComponent(fileName)}`;
+      setContentDispositionHeader(fileName, res);
+      expect(res.setHeader).toHaveBeenCalledExactlyOnceWith("Content-Disposition", value);
+    });
+  });
+  describe("setCacheControlHeaderNoCache tests", () => {
+    it("sets Cache-Control header with specified value", () => {
+      const value = "no-cache";
+      setCacheControlHeaderNoCache(res);
+      expect(res.setHeader).toHaveBeenCalledExactlyOnceWith("Cache-Control", value);
+    });
+  });
+});

packages/express-partial-content/tsconfig.json

@@ -5,6 +5,9 @@
   "references": [
     {
       "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
     }
   ]
 }

packages/express-partial-content/tsconfig.lib.json

@@ -6,8 +6,26 @@
     "outDir": "dist",
     "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
     "emitDeclarationOnly": false,
-    "types": ["node"]
+    "types": [
+      "node"
+    ]
   },
-  "include": ["src/**/*.ts"],
-  "references": []
+  "include": [
+    "src/**/*.ts"
+  ],
+  "references": [],
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx"
+  ]
 }

packages/express-partial-content/tsconfig.spec.json

@@ -0,0 +1,29 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./out-tsc/vitest",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts",
+    "src/**/*.ts"
+  ]
+}

packages/express-partial-content/vite.config.ts

@@ -0,0 +1,23 @@
+/// <reference types='vitest' />
+import { defineConfig } from 'vite';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../node_modules/.vite/packages/express-partial-content',
+  plugins: [],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //  plugins: [ nxViteTsPaths() ],
+  // },
+  test: {
+    watch: false,
+    globals: true,
+    environment: 'jsdom',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: './test-output/vitest/coverage',
+      provider: 'v8' as const,
+    }
+  },
+}));