@oneuptime/common 11.6.0 → 11.6.2

package/Tests/Server/Utils/FileAttachmentMarkdownUtil.test.ts

@@ -0,0 +1,225 @@
+import ObjectID from "../../../Types/ObjectID";
+import File from "../../../Models/DatabaseModels/File";
+
+/*
+ * FileService reaches Postgres, so it is faked. The behaviour worth pinning is
+ * the util's own bookkeeping: it de-duplicates ids before querying, but then
+ * renders from the ORIGINAL id list, so a duplicated id renders twice. The
+ * tests below state that explicitly rather than leaving it to be discovered.
+ */
+const findByMock: jest.Mock = jest.fn();
+
+jest.mock("../../../Server/Services/FileService", () => {
+  return {
+    __esModule: true,
+    default: {
+      findBy: (...args: Array<unknown>) => {
+        return findByMock(...args);
+      },
+    },
+  };
+});
+
+import FileAttachmentMarkdownUtil from "../../../Server/Utils/FileAttachmentMarkdownUtil";
+
+type MakeFileFunction = (data: { id: string; name?: string }) => File;
+
+const makeFile: MakeFileFunction = (data: {
+  id: string;
+  name?: string;
+}): File => {
+  const file: File = new File();
+  file._id = data.id;
+
+  if (data.name !== undefined) {
+    file.name = data.name;
+  }
+
+  return file;
+};
+
+describe("FileAttachmentMarkdownUtil.buildAttachmentMarkdown", () => {
+  const modelId: ObjectID = ObjectID.generate();
+  const attachmentApiPath: string = "/incident/attachment";
+
+  beforeEach(() => {
+    findByMock.mockReset();
+  });
+
+  test("should return an empty string when there are no attachment ids", async () => {
+    expect(
+      await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+        modelId,
+        attachmentIds: [],
+        attachmentApiPath,
+      }),
+    ).toEqual("");
+
+    expect(findByMock).not.toHaveBeenCalled();
+  });
+
+  test("should return an empty string when there is no model id", async () => {
+    expect(
+      await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+        modelId: undefined as unknown as ObjectID,
+        attachmentIds: [ObjectID.generate()],
+        attachmentApiPath,
+      }),
+    ).toEqual("");
+
+    expect(findByMock).not.toHaveBeenCalled();
+  });
+
+  test("should return an empty string when no files are found", async () => {
+    findByMock.mockResolvedValue([]);
+
+    expect(
+      await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+        modelId,
+        attachmentIds: [ObjectID.generate()],
+        attachmentApiPath,
+      }),
+    ).toEqual("");
+  });
+
+  test("should render a markdown link per file", async () => {
+    const first: ObjectID = ObjectID.generate();
+    const second: ObjectID = ObjectID.generate();
+
+    findByMock.mockResolvedValue([
+      makeFile({ id: first.toString(), name: "runbook.pdf" }),
+      makeFile({ id: second.toString(), name: "screenshot.png" }),
+    ]);
+
+    const markdown: string =
+      await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+        modelId,
+        attachmentIds: [first, second],
+        attachmentApiPath,
+      });
+
+    expect(markdown).toContain("**Attachments:**");
+    expect(markdown).toContain(`[runbook.pdf](`);
+    expect(markdown).toContain(`[screenshot.png](`);
+    expect(markdown).toContain(`${modelId.toString()}/${first.toString()}`);
+    expect(markdown).toContain(`${modelId.toString()}/${second.toString()}`);
+  });
+
+  test("should render links in the order the ids were given, not the order they were found", async () => {
+    const first: ObjectID = ObjectID.generate();
+    const second: ObjectID = ObjectID.generate();
+
+    // The database returns them the other way round.
+    findByMock.mockResolvedValue([
+      makeFile({ id: second.toString(), name: "second.txt" }),
+      makeFile({ id: first.toString(), name: "first.txt" }),
+    ]);
+
+    const markdown: string =
+      await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+        modelId,
+        attachmentIds: [first, second],
+        attachmentApiPath,
+      });
+
+    expect(markdown.indexOf("first.txt")).toBeLessThan(
+      markdown.indexOf("second.txt"),
+    );
+  });
+
+  test("should skip ids that have no matching file", async () => {
+    const found: ObjectID = ObjectID.generate();
+    const missing: ObjectID = ObjectID.generate();
+
+    findByMock.mockResolvedValue([
+      makeFile({ id: found.toString(), name: "found.txt" }),
+    ]);
+
+    const markdown: string =
+      await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+        modelId,
+        attachmentIds: [found, missing],
+        attachmentApiPath,
+      });
+
+    expect(markdown).toContain("found.txt");
+    expect(markdown).not.toContain(missing.toString());
+    expect(markdown.split("\n- ").length - 1).toEqual(1);
+  });
+
+  test("should query each distinct id only once", async () => {
+    const id: ObjectID = ObjectID.generate();
+
+    findByMock.mockResolvedValue([
+      makeFile({ id: id.toString(), name: "a.txt" }),
+    ]);
+
+    await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+      modelId,
+      attachmentIds: [id, id, id],
+      attachmentApiPath,
+    });
+
+    const query: Record<string, unknown> = (
+      findByMock.mock.calls[0]![0] as Record<string, Record<string, unknown>>
+    )["query"]!;
+
+    expect(JSON.stringify(query)).toContain(id.toString());
+    // De-duplicated: the id must appear exactly once in the query.
+    expect(JSON.stringify(query).split(id.toString()).length - 1).toEqual(1);
+  });
+
+  test("should still render a duplicated id once per occurrence", async () => {
+    /*
+     * De-duplication happens for the lookup only; rendering walks the original
+     * attachmentIds array. Pinning current behaviour so a change here is a
+     * deliberate one.
+     */
+    const id: ObjectID = ObjectID.generate();
+
+    findByMock.mockResolvedValue([
+      makeFile({ id: id.toString(), name: "a.txt" }),
+    ]);
+
+    const markdown: string =
+      await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+        modelId,
+        attachmentIds: [id, id],
+        attachmentApiPath,
+      });
+
+    expect(markdown.split("a.txt").length - 1).toEqual(2);
+  });
+
+  test("should fall back to 'Attachment' when a file has no name", async () => {
+    const id: ObjectID = ObjectID.generate();
+
+    findByMock.mockResolvedValue([makeFile({ id: id.toString() })]);
+
+    const markdown: string =
+      await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+        modelId,
+        attachmentIds: [id],
+        attachmentApiPath,
+      });
+
+    expect(markdown).toContain("[Attachment](");
+  });
+
+  test("should build the route from the given api path", async () => {
+    const id: ObjectID = ObjectID.generate();
+
+    findByMock.mockResolvedValue([
+      makeFile({ id: id.toString(), name: "a.txt" }),
+    ]);
+
+    const markdown: string =
+      await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+        modelId,
+        attachmentIds: [id],
+        attachmentApiPath: "/alert/attachment",
+      });
+
+    expect(markdown).toContain("/alert/attachment/");
+  });
+});

package/Tests/Server/Utils/JsonWebToken.test.ts

@@ -0,0 +1,175 @@
+import JSONWebToken from "../../../Server/Utils/JsonWebToken";
+import { EncryptionSecret } from "../../../Server/EnvironmentConfig";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import Email from "../../../Types/Email";
+import { JSONObject } from "../../../Types/JSON";
+import JSONWebTokenData from "../../../Types/JsonWebTokenData";
+import Name from "../../../Types/Name";
+import ObjectID from "../../../Types/ObjectID";
+import Timezone from "../../../Types/Timezone";
+import jwt from "jsonwebtoken";
+import { generateKeyPairSync } from "crypto";
+
+describe("JSONWebToken", () => {
+  const userId: ObjectID = ObjectID.generate();
+  const sessionId: ObjectID = ObjectID.generate();
+  const email: Email = new Email("jwt-test@oneuptime.com");
+
+  describe("signJsonPayload / decodeJsonPayload", () => {
+    test("should round trip a json payload", () => {
+      const token: string = JSONWebToken.signJsonPayload(
+        { hello: "world" },
+        300,
+      );
+
+      const decoded: JSONObject = JSONWebToken.decodeJsonPayload(token);
+
+      expect(decoded["hello"]).toEqual("world");
+    });
+
+    test("should set an expiry claim on the token", () => {
+      const token: string = JSONWebToken.signJsonPayload(
+        { hello: "world" },
+        300,
+      );
+
+      const decoded: JSONObject = JSONWebToken.decodeJsonPayload(token);
+
+      expect(decoded["exp"]).toBeDefined();
+      expect(decoded["iat"]).toBeDefined();
+      expect((decoded["exp"] as number) - (decoded["iat"] as number)).toEqual(
+        300,
+      );
+    });
+
+    test("should throw when the token was signed with a different secret", () => {
+      const token: string = jwt.sign({ hello: "world" }, "some-other-secret", {
+        expiresIn: 300,
+      });
+
+      expect(() => {
+        return JSONWebToken.decodeJsonPayload(token);
+      }).toThrow();
+    });
+  });
+
+  describe("signUserLoginToken / decode", () => {
+    test("should round trip user login token data", () => {
+      const token: string = JSONWebToken.signUserLoginToken({
+        tokenData: {
+          userId: userId,
+          email: email,
+          name: new Name("Test User"),
+          timezone: Timezone.AsiaKolkata,
+          isMasterAdmin: true,
+          isGlobalLogin: true,
+          sessionId: sessionId,
+        },
+        expiresInSeconds: 300,
+      });
+
+      const decoded: JSONWebTokenData = JSONWebToken.decode(token);
+
+      expect(decoded.userId.toString()).toEqual(userId.toString());
+      expect(decoded.email.toString()).toEqual(email.toString());
+      expect(decoded.name?.toString()).toEqual("Test User");
+      expect(decoded.isMasterAdmin).toBe(true);
+      expect(decoded.isGlobalLogin).toBe(true);
+      expect(decoded.sessionId?.toString()).toEqual(sessionId.toString());
+    });
+
+    test("should leave sessionId undefined when it was not signed", () => {
+      const token: string = JSONWebToken.sign({
+        data: {
+          userId: userId,
+          email: email,
+          name: new Name("Test User"),
+          isMasterAdmin: false,
+          isGlobalLogin: false,
+        } as JSONWebTokenData,
+        expiresInSeconds: 300,
+      });
+
+      const decoded: JSONWebTokenData = JSONWebToken.decode(token);
+
+      expect(decoded.sessionId).toBeUndefined();
+      expect(decoded.isMasterAdmin).toBe(false);
+    });
+
+    test("should decode a status page private user token", () => {
+      const statusPageId: ObjectID = ObjectID.generate();
+
+      const token: string = JSONWebToken.signJsonPayload(
+        {
+          userId: userId.toString(),
+          email: email.toString(),
+          statusPageId: statusPageId.toString(),
+        },
+        300,
+      );
+
+      const decoded: JSONWebTokenData = JSONWebToken.decode(token);
+
+      expect(decoded.statusPageId?.toString()).toEqual(statusPageId.toString());
+      // Status page users are never master admins.
+      expect(decoded.isMasterAdmin).toBe(false);
+      expect(decoded.name?.toString()).toEqual("User");
+    });
+
+    test("should throw BadDataException for a malformed token", () => {
+      expect(() => {
+        return JSONWebToken.decode("not-a-token");
+      }).toThrow(BadDataException);
+    });
+
+    test("should throw BadDataException for an expired token", () => {
+      const expiredToken: string = jwt.sign(
+        { userId: userId.toString(), email: email.toString() },
+        EncryptionSecret.toString(),
+        { expiresIn: -10 },
+      );
+
+      expect(() => {
+        return JSONWebToken.decode(expiredToken);
+      }).toThrow(BadDataException);
+    });
+  });
+
+  describe("sign", () => {
+    test("should wrap a plain string payload under a data claim", () => {
+      const token: string = JSONWebToken.sign({
+        data: "just-a-string",
+        expiresInSeconds: 300,
+      });
+
+      expect(JSONWebToken.decodeJsonPayload(token)["data"]).toEqual(
+        "just-a-string",
+      );
+    });
+  });
+
+  describe("signWithPrivateKey", () => {
+    test("should sign with RS256 and be verifiable with the public key", () => {
+      const { privateKey, publicKey } = generateKeyPairSync("rsa", {
+        modulusLength: 2048,
+        publicKeyEncoding: { type: "spki", format: "pem" },
+        privateKeyEncoding: { type: "pkcs8", format: "pem" },
+      });
+
+      const token: string = JSONWebToken.signWithPrivateKey(
+        { sub: "oauth-subject" },
+        privateKey,
+      );
+
+      const header: JSONObject = JSON.parse(
+        Buffer.from(token.split(".")[0]!, "base64").toString("utf8"),
+      );
+      expect(header["alg"]).toEqual("RS256");
+
+      const verified: JSONObject = jwt.verify(token, publicKey, {
+        algorithms: ["RS256"],
+      }) as JSONObject;
+      expect(verified["sub"]).toEqual("oauth-subject");
+    });
+  });
+});

package/Tests/Server/Utils/LocalFile.test.ts

@@ -0,0 +1,258 @@
+import LocalFile from "../../../Server/Utils/LocalFile";
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+/*
+ * These run against a real temp directory rather than a mocked `fs`: the
+ * behaviour worth pinning down here is what the wrappers do with the
+ * filesystem's own answers — ENOENT resolving to false instead of throwing,
+ * delete being a no-op on a missing path, directory-vs-file discrimination —
+ * and a mock would just re-state the implementation.
+ */
+describe("LocalFile", () => {
+  let workDir: string = "";
+
+  beforeEach(async () => {
+    workDir = await fs.promises.mkdtemp(
+      path.join(os.tmpdir(), "oneuptime-localfile-test-"),
+    );
+  });
+
+  afterEach(async () => {
+    await fs.promises.rm(workDir, { recursive: true, force: true });
+  });
+
+  describe("sanitizeFilePath", () => {
+    test("should collapse double slashes", () => {
+      expect(LocalFile.sanitizeFilePath("/a//b//c.txt")).toEqual("/a/b/c.txt");
+    });
+
+    test("should leave a clean path untouched", () => {
+      expect(LocalFile.sanitizeFilePath("/a/b/c.txt")).toEqual("/a/b/c.txt");
+    });
+
+    test("should not touch the scheme separator of a url-like path", () => {
+      // Only "//" is collapsed, so "://" becomes ":/" — pinning current behaviour.
+      expect(LocalFile.sanitizeFilePath("https://example.com/a")).toEqual(
+        "https:/example.com/a",
+      );
+    });
+  });
+
+  describe("getFileExtension", () => {
+    test("should return the lowercased extension", () => {
+      expect(LocalFile.getFileExtension("/tmp/report.PDF")).toEqual("pdf");
+      expect(LocalFile.getFileExtension("archive.tar.gz")).toEqual("gz");
+    });
+
+    test("should return the whole name when there is no dot", () => {
+      // No dot means split() yields one segment, which is the name itself.
+      expect(LocalFile.getFileExtension("Makefile")).toEqual("makefile");
+    });
+
+    test("should return an empty string for a trailing dot", () => {
+      expect(LocalFile.getFileExtension("weird.")).toEqual("");
+    });
+  });
+
+  describe("write / read", () => {
+    test("should round trip file contents", async () => {
+      const filePath: string = path.join(workDir, "note.txt");
+
+      await LocalFile.write(filePath, "hello world");
+
+      expect(await LocalFile.read(filePath)).toEqual("hello world");
+    });
+
+    test("should overwrite existing contents", async () => {
+      const filePath: string = path.join(workDir, "note.txt");
+
+      await LocalFile.write(filePath, "first");
+      await LocalFile.write(filePath, "second");
+
+      expect(await LocalFile.read(filePath)).toEqual("second");
+    });
+
+    test("should read the same bytes back as a buffer", async () => {
+      const filePath: string = path.join(workDir, "note.txt");
+
+      await LocalFile.write(filePath, "buffer me");
+
+      const buffer: Buffer = await LocalFile.readAsBuffer(filePath);
+
+      expect(Buffer.isBuffer(buffer)).toBe(true);
+      expect(buffer.toString("utf-8")).toEqual("buffer me");
+    });
+
+    test("should reject when reading a file that does not exist", async () => {
+      await expect(
+        LocalFile.read(path.join(workDir, "missing.txt")),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("doesFileExist / doesDirectoryExist", () => {
+    test("should report an existing file as a file and not a directory", async () => {
+      const filePath: string = path.join(workDir, "note.txt");
+      await LocalFile.write(filePath, "x");
+
+      expect(await LocalFile.doesFileExist(filePath)).toBe(true);
+      expect(await LocalFile.doesDirectoryExist(filePath)).toBe(false);
+    });
+
+    test("should report an existing directory as a directory and not a file", async () => {
+      expect(await LocalFile.doesDirectoryExist(workDir)).toBe(true);
+      expect(await LocalFile.doesFileExist(workDir)).toBe(false);
+    });
+
+    test("should resolve false rather than throwing for a missing path", async () => {
+      const missing: string = path.join(workDir, "nope");
+
+      expect(await LocalFile.doesFileExist(missing)).toBe(false);
+      expect(await LocalFile.doesDirectoryExist(missing)).toBe(false);
+    });
+  });
+
+  describe("makeDirectory", () => {
+    test("should create nested directories", async () => {
+      const nested: string = path.join(workDir, "a", "b", "c");
+
+      await LocalFile.makeDirectory(nested);
+
+      expect(await LocalFile.doesDirectoryExist(nested)).toBe(true);
+    });
+
+    test("should be idempotent", async () => {
+      const dir: string = path.join(workDir, "a");
+
+      await LocalFile.makeDirectory(dir);
+      await LocalFile.makeDirectory(dir);
+
+      expect(await LocalFile.doesDirectoryExist(dir)).toBe(true);
+    });
+  });
+
+  describe("deleteFile", () => {
+    test("should delete an existing file", async () => {
+      const filePath: string = path.join(workDir, "note.txt");
+      await LocalFile.write(filePath, "x");
+
+      await LocalFile.deleteFile(filePath);
+
+      expect(await LocalFile.doesFileExist(filePath)).toBe(false);
+    });
+
+    test("should be a no-op for a missing file", async () => {
+      await expect(
+        LocalFile.deleteFile(path.join(workDir, "missing.txt")),
+      ).resolves.toBeUndefined();
+    });
+  });
+
+  describe("deleteDirectory", () => {
+    test("should remove a directory and its contents", async () => {
+      const dir: string = path.join(workDir, "a");
+      await LocalFile.makeDirectory(dir);
+      await LocalFile.write(path.join(dir, "note.txt"), "x");
+
+      await LocalFile.deleteDirectory(dir);
+
+      expect(await LocalFile.doesDirectoryExist(dir)).toBe(false);
+    });
+
+    test("should be a no-op for a missing directory", async () => {
+      await expect(
+        LocalFile.deleteDirectory(path.join(workDir, "missing")),
+      ).resolves.toBeUndefined();
+    });
+  });
+
+  describe("deleteAllDataInDirectory", () => {
+    test("should empty the directory but keep it in place", async () => {
+      const dir: string = path.join(workDir, "a");
+      await LocalFile.makeDirectory(path.join(dir, "nested"));
+      await LocalFile.write(path.join(dir, "note.txt"), "x");
+
+      await LocalFile.deleteAllDataInDirectory(dir);
+
+      expect(await LocalFile.doesDirectoryExist(dir)).toBe(true);
+      expect(await LocalFile.readDirectory(dir)).toEqual([]);
+    });
+
+    test("should be a no-op for a missing directory", async () => {
+      await expect(
+        LocalFile.deleteAllDataInDirectory(path.join(workDir, "missing")),
+      ).resolves.toBeUndefined();
+    });
+  });
+
+  describe("getListOfDirectories", () => {
+    test("should return only directories, not files", async () => {
+      await LocalFile.makeDirectory(path.join(workDir, "alpha"));
+      await LocalFile.makeDirectory(path.join(workDir, "beta"));
+      await LocalFile.write(path.join(workDir, "note.txt"), "x");
+
+      const directories: Array<string> = (
+        await LocalFile.getListOfDirectories(workDir)
+      ).sort();
+
+      expect(directories).toEqual(["alpha", "beta"]);
+    });
+
+    test("should return an empty array for a directory with no subdirectories", async () => {
+      await LocalFile.write(path.join(workDir, "note.txt"), "x");
+
+      expect(await LocalFile.getListOfDirectories(workDir)).toEqual([]);
+    });
+
+    test("should reject for a missing directory", async () => {
+      await expect(
+        LocalFile.getListOfDirectories(path.join(workDir, "missing")),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("copyFile", () => {
+    test("should copy contents to the destination", async () => {
+      const source: string = path.join(workDir, "source.txt");
+      const destination: string = path.join(workDir, "destination.txt");
+      await LocalFile.write(source, "copy me");
+
+      await LocalFile.copyFile({ source, destination });
+
+      expect(await LocalFile.read(destination)).toEqual("copy me");
+      // The source must survive a copy.
+      expect(await LocalFile.doesFileExist(source)).toBe(true);
+    });
+
+    test("should reject when the source does not exist", async () => {
+      await expect(
+        LocalFile.copyFile({
+          source: path.join(workDir, "missing.txt"),
+          destination: path.join(workDir, "destination.txt"),
+        }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("copyDirectory", () => {
+    test("should copy a directory tree recursively", async () => {
+      const source: string = path.join(workDir, "source");
+      const destination: string = path.join(workDir, "destination");
+
+      await LocalFile.makeDirectory(path.join(source, "nested"));
+      await LocalFile.write(path.join(source, "top.txt"), "top");
+      await LocalFile.write(path.join(source, "nested", "deep.txt"), "deep");
+
+      await LocalFile.copyDirectory({ source, destination });
+
+      expect(await LocalFile.read(path.join(destination, "top.txt"))).toEqual(
+        "top",
+      );
+      expect(
+        await LocalFile.read(path.join(destination, "nested", "deep.txt")),
+      ).toEqual("deep");
+    });
+  });
+});