@oneuptime/common 11.6.0 → 11.6.2

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

@@ -0,0 +1,370 @@
+import StackTraceParser, {
+  ParsedStackTrace,
+  StackFrame,
+} from "../../../Server/Utils/Telemetry/StackTraceParser";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * StackTraceParser auto-detects the language of a raw stack trace by running
+ * every language parser and keeping whichever produces the most frames. These
+ * tests lock down:
+ *
+ *   1. Each language parser recognizes its canonical format.
+ *   2. The inApp classification (user code vs library/framework code) matches
+ *      the LIBRARY_PATTERNS heuristics — this drives which frames get
+ *      highlighted in the UI, so a regression here silently mislabels frames.
+ *   3. The auto-detect "most frames wins" tie-break picks the right parser
+ *      when a trace could be partially matched by more than one parser.
+ */
+
+describe("StackTraceParser.parse - guard clauses", () => {
+  test("returns empty frames for empty string", () => {
+    const result: ParsedStackTrace = StackTraceParser.parse("");
+    expect(result.frames).toEqual([]);
+    expect(result.raw).toBe("");
+  });
+
+  test("returns empty frames for whitespace-only string", () => {
+    const result: ParsedStackTrace = StackTraceParser.parse("   \n  \t \n ");
+    expect(result.frames).toEqual([]);
+  });
+
+  test("preserves the raw string unchanged", () => {
+    const raw: string = "at foo (/app/index.js:1:1)";
+    const result: ParsedStackTrace = StackTraceParser.parse(raw);
+    expect(result.raw).toBe(raw);
+  });
+
+  test("handles null/undefined gracefully via falsy guard", () => {
+    // parse() guards with `!rawStackTrace` before using it.
+    const result: ParsedStackTrace = StackTraceParser.parse(
+      undefined as unknown as string,
+    );
+    expect(result.frames).toEqual([]);
+    expect(result.raw).toBe("");
+  });
+
+  test("returns empty frames for unparseable garbage", () => {
+    const result: ParsedStackTrace = StackTraceParser.parse(
+      "this is not a stack trace at all\njust some random text",
+    );
+    expect(result.frames).toEqual([]);
+  });
+});
+
+describe("StackTraceParser.parse - JavaScript/Node.js", () => {
+  test("parses `at functionName (file:line:col)`", () => {
+    const trace: string = [
+      "Error: boom",
+      "    at doWork (/app/src/worker.js:42:15)",
+      "    at main (/app/src/index.js:10:3)",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(2);
+    expect(result.frames[0]).toEqual({
+      functionName: "doWork",
+      fileName: "/app/src/worker.js",
+      lineNumber: 42,
+      columnNumber: 15,
+      inApp: true,
+    });
+    expect(result.frames[1]!.functionName).toBe("main");
+    expect(result.frames[1]!.lineNumber).toBe(10);
+  });
+
+  test("parses anonymous `at file:line:col` frames", () => {
+    const trace: string = "    at /app/src/index.js:10:3";
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(1);
+    expect(result.frames[0]).toEqual({
+      functionName: "<anonymous>",
+      fileName: "/app/src/index.js",
+      lineNumber: 10,
+      columnNumber: 3,
+      inApp: true,
+    });
+  });
+
+  test("parses `at functionName (file:line)` without a column", () => {
+    const trace: string = "    at render (/app/component.js:7)";
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(1);
+    expect(result.frames[0]!.lineNumber).toBe(7);
+    expect(result.frames[0]!.columnNumber).toBeUndefined();
+    expect(result.frames[0]!.functionName).toBe("render");
+  });
+
+  test("parses eval frames", () => {
+    const trace: string =
+      "    at eval (eval at compile (/app/vm.js:5:10), <anonymous>:1:1)";
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(1);
+    expect(result.frames[0]!.functionName).toBe("eval at compile");
+    expect(result.frames[0]!.fileName).toBe("/app/vm.js");
+    expect(result.frames[0]!.lineNumber).toBe(5);
+    expect(result.frames[0]!.columnNumber).toBe(10);
+  });
+
+  test("marks node_modules and node: internals as not inApp", () => {
+    const trace: string = [
+      "    at userCode (/app/src/handler.js:1:1)",
+      "    at libCode (/app/node_modules/express/lib/router.js:2:2)",
+      "    at process (node:internal/process/task_queues:3:3)",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(3);
+    expect(result.frames[0]!.inApp).toBe(true);
+    expect(result.frames[1]!.inApp).toBe(false);
+    expect(result.frames[2]!.inApp).toBe(false);
+  });
+});
+
+describe("StackTraceParser.parse - Python", () => {
+  test('parses `File "path", line N, in function`', () => {
+    const trace: string = [
+      "Traceback (most recent call last):",
+      '  File "/app/main.py", line 22, in run',
+      "    do_thing()",
+      '  File "/app/service.py", line 5, in do_thing',
+      "    raise ValueError()",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(2);
+    expect(result.frames[0]).toEqual({
+      functionName: "run",
+      fileName: "/app/main.py",
+      lineNumber: 22,
+      inApp: true,
+    });
+    expect(result.frames[1]!.functionName).toBe("do_thing");
+  });
+
+  test("uses <module> when the `in function` suffix is absent", () => {
+    const trace: string = '  File "/app/main.py", line 1';
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(1);
+    expect(result.frames[0]!.functionName).toBe("<module>");
+  });
+
+  test("marks site-packages as not inApp", () => {
+    const trace: string = [
+      '  File "/app/main.py", line 1, in run',
+      '  File "/usr/lib/python3.11/site-packages/requests/api.py", line 9, in get',
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(2);
+    expect(result.frames[0]!.inApp).toBe(true);
+    expect(result.frames[1]!.inApp).toBe(false);
+  });
+});
+
+describe("StackTraceParser.parse - Java", () => {
+  test("parses `at package.Class.method(File.java:line)`", () => {
+    const trace: string = [
+      "java.lang.NullPointerException",
+      "    at com.example.Service.process(Service.java:42)",
+      "    at com.example.Main.main(Main.java:10)",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(2);
+    expect(result.frames[0]!.functionName).toBe("com.example.Service.process");
+    expect(result.frames[0]!.fileName).toBe("Service.java");
+    expect(result.frames[0]!.lineNumber).toBe(42);
+  });
+
+  test("parses native and unknown-source frames", () => {
+    const trace: string = [
+      "    at com.example.Service.process(Service.java:42)",
+      "    at sun.reflect.NativeMethod.invoke(Native Method)",
+      "    at com.example.App.run(Unknown Source)",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(3);
+    expect(result.frames[1]!.fileName).toBe("Native Method");
+    expect(result.frames[1]!.lineNumber).toBe(0);
+    expect(result.frames[1]!.inApp).toBe(false);
+    expect(result.frames[2]!.fileName).toBe("Unknown Source");
+    expect(result.frames[2]!.lineNumber).toBe(0);
+  });
+
+  test("marks java.* / org.springframework.* as not inApp", () => {
+    const trace: string = [
+      "    at com.example.Service.process(Service.java:42)",
+      "    at org.springframework.web.Dispatcher.doDispatch(Dispatcher.java:1)",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames[0]!.inApp).toBe(true);
+    expect(result.frames[1]!.inApp).toBe(false);
+  });
+});
+
+describe("StackTraceParser.parse - Go", () => {
+  test("pairs the function line with the following file:line", () => {
+    const trace: string = [
+      "goroutine 1 [running]:",
+      "main.doWork(0x1, 0x2)",
+      "\t/app/main.go:25 +0x1a",
+      "main.main()",
+      "\t/app/main.go:10 +0x2b",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(2);
+    expect(result.frames[0]!.functionName).toBe("main.doWork");
+    expect(result.frames[0]!.fileName).toBe("/app/main.go");
+    expect(result.frames[0]!.lineNumber).toBe(25);
+    expect(result.frames[1]!.functionName).toBe("main.main");
+  });
+
+  test("marks vendor / pkg/mod paths as not inApp", () => {
+    const trace: string = [
+      "main.doWork()",
+      "\t/app/main.go:25 +0x1a",
+      "github.com/lib/pq.Query()",
+      "\t/app/vendor/github.com/lib/pq/conn.go:5 +0x3c",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(2);
+    expect(result.frames[0]!.inApp).toBe(true);
+    expect(result.frames[1]!.inApp).toBe(false);
+  });
+});
+
+describe("StackTraceParser.parse - Ruby", () => {
+  test("parses `file:line:in 'method'`", () => {
+    const trace: string = [
+      "/app/service.rb:12:in `process'",
+      "/app/main.rb:3:in `<main>'",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(2);
+    expect(result.frames[0]!.functionName).toBe("process");
+    expect(result.frames[0]!.fileName).toBe("/app/service.rb");
+    expect(result.frames[0]!.lineNumber).toBe(12);
+    expect(result.frames[1]!.functionName).toBe("<main>");
+  });
+
+  test("marks gems paths as not inApp", () => {
+    const trace: string = [
+      "/app/service.rb:12:in `process'",
+      "/usr/local/gems/activerecord/lib/query.rb:8:in `execute'",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames[0]!.inApp).toBe(true);
+    expect(result.frames[1]!.inApp).toBe(false);
+  });
+});
+
+describe("StackTraceParser.parse - C#/.NET", () => {
+  test("parses `at Namespace.Class.Method(params) in file:line N`", () => {
+    const trace: string = [
+      "System.NullReferenceException: boom",
+      "   at MyApp.Service.Process(String id) in /app/Service.cs:line 42",
+      "   at MyApp.Program.Main() in /app/Program.cs:line 10",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(2);
+    expect(result.frames[0]!.functionName).toBe(
+      "MyApp.Service.Process(String id)",
+    );
+    expect(result.frames[0]!.fileName).toBe("/app/Service.cs");
+    expect(result.frames[0]!.lineNumber).toBe(42);
+  });
+
+  test("parses frames without file info", () => {
+    const trace: string = [
+      "   at MyApp.Service.Process(String id) in /app/Service.cs:line 42",
+      "   at MyApp.Internal.Helper.Run()",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(2);
+    expect(result.frames[1]!.fileName).toBe("");
+    expect(result.frames[1]!.lineNumber).toBe(0);
+    expect(result.frames[1]!.functionName).toBe("MyApp.Internal.Helper.Run()");
+  });
+});
+
+describe("StackTraceParser.parse - PHP", () => {
+  test("parses `#N /path/file.php(line): Class->method()`", () => {
+    const trace: string = [
+      "#0 /app/service.php(42): Service->process()",
+      "#1 /app/index.php(10): Service->run()",
+      "#2 {main}",
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames).toHaveLength(3);
+    expect(result.frames[0]!.functionName).toBe("Service->process");
+    expect(result.frames[0]!.fileName).toBe("/app/service.php");
+    expect(result.frames[0]!.lineNumber).toBe(42);
+    expect(result.frames[2]!.functionName).toBe("{main}");
+    expect(result.frames[2]!.inApp).toBe(true);
+  });
+
+  test("strips trailing () from method names", () => {
+    const trace: string = "#0 /app/service.php(42): MyClass->doThing()";
+    const result: ParsedStackTrace = StackTraceParser.parse(trace);
+
+    expect(result.frames[0]!.functionName).toBe("MyClass->doThing");
+  });
+});
+
+describe("StackTraceParser.parse - auto-detection", () => {
+  test("picks the parser that yields the most frames", () => {
+    /*
+     * A pure Python trace should be attributed entirely to the Python parser,
+     * not partially matched by another language.
+     */
+    const python: string = [
+      '  File "/app/a.py", line 1, in a',
+      '  File "/app/b.py", line 2, in b',
+      '  File "/app/c.py", line 3, in c',
+    ].join("\n");
+
+    const result: ParsedStackTrace = StackTraceParser.parse(python);
+    expect(result.frames).toHaveLength(3);
+    expect(
+      result.frames.every((f: StackFrame) => {
+        return f.fileName.endsWith(".py");
+      }),
+    ).toBe(true);
+  });
+
+  test("a single JS frame beats zero frames from other parsers", () => {
+    const result: ParsedStackTrace = StackTraceParser.parse(
+      "    at solo (/app/only.js:1:1)",
+    );
+    expect(result.frames).toHaveLength(1);
+    expect(result.frames[0]!.fileName).toBe("/app/only.js");
+  });
+});

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

@@ -0,0 +1,87 @@
+import StreamUtil from "../../../Server/Utils/Stream";
+import { PassThrough, Readable } from "stream";
+
+describe("StreamUtil", () => {
+  describe("convertStreamToText", () => {
+    test("should concatenate chunks in order", async () => {
+      const stream: Readable = Readable.from(["hello ", "world"]);
+
+      expect(await StreamUtil.convertStreamToText(stream)).toEqual(
+        "hello world",
+      );
+    });
+
+    test("should return an empty string for an empty stream", async () => {
+      expect(await StreamUtil.convertStreamToText(Readable.from([]))).toEqual(
+        "",
+      );
+    });
+
+    test("should handle buffer chunks", async () => {
+      const stream: Readable = Readable.from([
+        Buffer.from("abc"),
+        Buffer.from("def"),
+      ]);
+
+      expect(await StreamUtil.convertStreamToText(stream)).toEqual("abcdef");
+    });
+
+    test("should decode multi-byte characters split across chunks", async () => {
+      /*
+       * Chunks are collected as buffers and only decoded once at the end, so a
+       * character whose bytes straddle a chunk boundary must still come out
+       * intact.
+       */
+      const euro: Buffer = Buffer.from("€", "utf8");
+      const stream: Readable = Readable.from([
+        euro.subarray(0, 1),
+        euro.subarray(1),
+      ]);
+
+      expect(await StreamUtil.convertStreamToText(stream)).toEqual("€");
+    });
+
+    test("should reject when the stream errors", async () => {
+      const stream: PassThrough = new PassThrough();
+
+      const result: Promise<string> = StreamUtil.convertStreamToText(stream);
+
+      stream.emit("error", new Error("stream blew up"));
+
+      await expect(result).rejects.toThrow("stream blew up");
+    });
+  });
+
+  describe("toStringArray", () => {
+    test("should split the stream on newlines", async () => {
+      const stream: Readable = Readable.from(["first\nsecond\nthird"]);
+
+      expect(await StreamUtil.toStringArray(stream)).toEqual([
+        "first",
+        "second",
+        "third",
+      ]);
+    });
+
+    test("should keep the trailing empty entry from a trailing newline", async () => {
+      // split() on a trailing separator yields a final empty string.
+      expect(await StreamUtil.toStringArray(Readable.from(["a\n"]))).toEqual([
+        "a",
+        "",
+      ]);
+    });
+
+    test("should return a single empty entry for an empty stream", async () => {
+      expect(await StreamUtil.toStringArray(Readable.from([]))).toEqual([""]);
+    });
+
+    test("should not split lines that span chunk boundaries", async () => {
+      const stream: Readable = Readable.from(["fir", "st\nsec", "ond"]);
+
+      expect(await StreamUtil.toStringArray(stream)).toEqual([
+        "first",
+        "second",
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,221 @@
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import Project from "../../../Models/DatabaseModels/Project";
+import Team from "../../../Models/DatabaseModels/Team";
+
+/*
+ * TeamService reaches Postgres, so it is replaced with a fake whose only job
+ * is to answer "which teams exist and which project does each belong to".
+ * The mock must be declared before the module under test is imported.
+ */
+const findByMock: jest.Mock = jest.fn();
+
+jest.mock("../../../Server/Services/TeamService", () => {
+  return {
+    __esModule: true,
+    default: {
+      findBy: (...args: Array<unknown>) => {
+        return findByMock(...args);
+      },
+    },
+  };
+});
+
+import validateGlobalProviderProjectTeams, {
+  resolveAttachmentProjectId,
+} from "../../../Server/Utils/ValidateGlobalProviderProjectTeams";
+
+type MakeTeamFunction = (data: { id: string; projectId?: string }) => Team;
+
+const makeTeam: MakeTeamFunction = (data: {
+  id: string;
+  projectId?: string;
+}): Team => {
+  const team: Team = new Team();
+  team.id = new ObjectID(data.id);
+
+  if (data.projectId) {
+    team.projectId = new ObjectID(data.projectId);
+  }
+
+  return team;
+};
+
+describe("resolveAttachmentProjectId", () => {
+  const projectId: ObjectID = ObjectID.generate();
+
+  test("should prefer an explicit projectId", () => {
+    const other: Project = new Project();
+    other.id = ObjectID.generate();
+
+    expect(
+      resolveAttachmentProjectId({ projectId, project: other })?.toString(),
+    ).toEqual(projectId.toString());
+  });
+
+  test("should fall back to the project relation's id", () => {
+    const project: Project = new Project();
+    project.id = projectId;
+
+    expect(resolveAttachmentProjectId({ project })?.toString()).toEqual(
+      projectId.toString(),
+    );
+  });
+
+  test("should fall back to a bare _id on the project relation", () => {
+    /*
+     * The Admin Dashboard entity dropdown submits the related Project as a
+     * plain object carrying only `_id`, which is the shape this branch exists
+     * for.
+     */
+    const project: Project = {
+      _id: projectId.toString(),
+    } as unknown as Project;
+
+    expect(resolveAttachmentProjectId({ project })?.toString()).toEqual(
+      projectId.toString(),
+    );
+  });
+
+  test("should return undefined when neither is present", () => {
+    expect(resolveAttachmentProjectId({})).toBeUndefined();
+    expect(
+      resolveAttachmentProjectId({ project: new Project() }),
+    ).toBeUndefined();
+  });
+});
+
+describe("validateGlobalProviderProjectTeams", () => {
+  const projectId: ObjectID = ObjectID.generate();
+  const otherProjectId: ObjectID = ObjectID.generate();
+
+  beforeEach(() => {
+    findByMock.mockReset();
+  });
+
+  test("should do nothing when no teams are selected", async () => {
+    await expect(
+      validateGlobalProviderProjectTeams({ teams: undefined, projectId }),
+    ).resolves.toBeUndefined();
+
+    await expect(
+      validateGlobalProviderProjectTeams({ teams: [], projectId }),
+    ).resolves.toBeUndefined();
+
+    // No teams means no reason to hit the database at all.
+    expect(findByMock).not.toHaveBeenCalled();
+  });
+
+  test("should reject teams selected without a project", async () => {
+    const team: Team = makeTeam({ id: ObjectID.generate().toString() });
+
+    await expect(
+      validateGlobalProviderProjectTeams({
+        teams: [team],
+        projectId: undefined,
+      }),
+    ).rejects.toThrow(BadDataException);
+
+    expect(findByMock).not.toHaveBeenCalled();
+  });
+
+  test("should pass when every team belongs to the target project", async () => {
+    const first: string = ObjectID.generate().toString();
+    const second: string = ObjectID.generate().toString();
+
+    findByMock.mockResolvedValue([
+      makeTeam({ id: first, projectId: projectId.toString() }),
+      makeTeam({ id: second, projectId: projectId.toString() }),
+    ]);
+
+    await expect(
+      validateGlobalProviderProjectTeams({
+        teams: [makeTeam({ id: first }), makeTeam({ id: second })],
+        projectId,
+      }),
+    ).resolves.toBeUndefined();
+
+    expect(findByMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("should reject a team that belongs to a different project", async () => {
+    /*
+     * This is the guard's whole reason to exist: the SSO login fan-out
+     * provisions a TeamMember with the attachment's projectId and the team's
+     * id, and runs with ignoreHooks, so a cross-project team here would
+     * produce a corrupt membership row that nothing else would catch.
+     */
+    const mine: string = ObjectID.generate().toString();
+    const theirs: string = ObjectID.generate().toString();
+
+    findByMock.mockResolvedValue([
+      makeTeam({ id: mine, projectId: projectId.toString() }),
+      makeTeam({ id: theirs, projectId: otherProjectId.toString() }),
+    ]);
+
+    await expect(
+      validateGlobalProviderProjectTeams({
+        teams: [makeTeam({ id: mine }), makeTeam({ id: theirs })],
+        projectId,
+      }),
+    ).rejects.toThrow(
+      "All selected teams must belong to the project this provider is attached to.",
+    );
+  });
+
+  test("should reject when a selected team does not exist", async () => {
+    const present: string = ObjectID.generate().toString();
+    const missing: string = ObjectID.generate().toString();
+
+    findByMock.mockResolvedValue([
+      makeTeam({ id: present, projectId: projectId.toString() }),
+    ]);
+
+    await expect(
+      validateGlobalProviderProjectTeams({
+        teams: [makeTeam({ id: present }), makeTeam({ id: missing })],
+        projectId,
+      }),
+    ).rejects.toThrow("One or more selected teams could not be found.");
+  });
+
+  test("should reject a team with no project at all", async () => {
+    const teamId: string = ObjectID.generate().toString();
+
+    findByMock.mockResolvedValue([makeTeam({ id: teamId })]);
+
+    await expect(
+      validateGlobalProviderProjectTeams({
+        teams: [makeTeam({ id: teamId })],
+        projectId,
+      }),
+    ).rejects.toThrow(BadDataException);
+  });
+
+  test("should accept teams submitted as bare _id objects", async () => {
+    const teamId: string = ObjectID.generate().toString();
+
+    findByMock.mockResolvedValue([
+      makeTeam({ id: teamId, projectId: projectId.toString() }),
+    ]);
+
+    await expect(
+      validateGlobalProviderProjectTeams({
+        teams: [{ _id: teamId } as unknown as Team],
+        projectId,
+      }),
+    ).resolves.toBeUndefined();
+  });
+
+  test("should skip the lookup when no team carries an id", async () => {
+    // Nothing identifiable to validate, so there is nothing to query for.
+    await expect(
+      validateGlobalProviderProjectTeams({
+        teams: [new Team()],
+        projectId,
+      }),
+    ).resolves.toBeUndefined();
+
+    expect(findByMock).not.toHaveBeenCalled();
+  });
+});