svrjs/tests/middleware/rewriteURL.test.js

const middleware = require("../../src/middleware/rewriteURL.js");
const createRegex = require("../../src/utils/createRegex.js");
const sanitizeURL = require("../../src/utils/urlSanitizer.js");
const parseURL = require("../../src/utils/urlParser.js");

jest.mock("fs");
jest.mock("../../src/utils/urlSanitizer.js");
jest.mock("../../src/utils/urlParser.js");
jest.mock("../../src/utils/createRegex.js");

describe("rewriteURL middleware", () => {
  let req, res, logFacilities, config, next;

  beforeEach(() => {
    jest.resetAllMocks();
    req = {
      parsedURL: {
        pathname: "/test",
        search: "",
        hash: ""
      },
      url: "/test",
      headers: {
        host: "test.com"
      },
      socket: {
        encrypted: false,
        localAddress: "127.0.0.1"
      }
    };
    res = {
      error: jest.fn()
    };
    logFacilities = {
      resmessage: jest.fn(),
      errmessage: jest.fn()
    };
    config = {
      rewriteMap: [],
      domain: "test.com",
      allowDoubleSlashes: false
    };
    next = jest.fn();

    // Make mocks call actual functions
    createRegex.mockImplementation((...params) =>
      jest.requireActual("../../src/utils/createRegex.js")(...params)
    );
    parseURL.mockImplementation((...params) =>
      jest.requireActual("../../src/utils/urlParser.js")(...params)
    );
    sanitizeURL.mockImplementation((...params) =>
      jest.requireActual("../../src/utils/urlSanitizer.js")(...params)
    );
  });

  test("should call next if URL is not rewritten", () => {
    middleware(req, res, logFacilities, config, next);
    expect(next).toHaveBeenCalled();
  });

  test("should return 400 if URL decoding fails", () => {
    req.parsedURL.pathname = "%";
    middleware(req, res, logFacilities, config, next);
    expect(res.error).toHaveBeenCalledWith(400);
  });

  test("should return 500 if rewriteURL callback returns an error", () => {
    config.rewriteMap = [
      {
        host: "test.com",
        definingRegex: "/.*/",
        replacements: [
          {
            regex: "/.*/",
            replacement: "error"
          }
        ]
      }
    ];
    createRegex.mockImplementation(() => {
      throw new Error("Test error");
    });
    middleware(req, res, logFacilities, config, next);
    expect(res.error).toHaveBeenCalledWith(500, expect.any(Error));
  });

  test("should return 400 if parsedURL is invalid", () => {
    config.rewriteMap = [
      {
        host: "test.com",
        definingRegex: "/.*/",
        replacements: [
          {
            regex: "/.*/",
            replacement: "/new"
          }
        ]
      }
    ];
    parseURL.mockImplementation(() => {
      throw new Error("Test error");
    });
    middleware(req, res, logFacilities, config, next);
    expect(res.error).toHaveBeenCalledWith(400, expect.any(Error));
  });

  test("should return 403 if URL is sanitized", () => {
    config.rewriteMap = [
      {
        host: "test.com",
        definingRegex: "/.*/",
        replacements: [
          {
            regex: "/.*/",
            replacement: "/new"
          }
        ]
      }
    ];
    sanitizeURL.mockReturnValue("/sanitized");
    middleware(req, res, logFacilities, config, next);
    expect(res.error).toHaveBeenCalledWith(403);
    expect(logFacilities.errmessage).toHaveBeenCalledWith("Content blocked.");
  });

  test("should call next if URL is rewritten successfully", () => {
    config.rewriteMap = [
      {
        host: "test.com",
        definingRegex: "/.*/",
        replacements: [
          {
            regex: "/.*/",
            replacement: "/new"
          }
        ]
      }
    ];
    middleware(req, res, logFacilities, config, next);
    expect(next).toHaveBeenCalled();
  });
});