@oneuptime/common 12.0.4 → 12.0.5

package/Tests/Utils/Monitor/MonitorMetricType.test.ts

@@ -37,6 +37,16 @@ describe("getAggregationTypeByMonitorMetricType", () => {
         MonitorMetricType.IsOnline,
       ),
     ).toBe(AggregationType.Min);
+    expect(
+      MonitorMetricTypeUtil.getAggregationTypeByMonitorMetricType(
+        MonitorMetricType.PortDnsLookupTime,
+      ),
+    ).toBe(AggregationType.Avg);
+    expect(
+      MonitorMetricTypeUtil.getAggregationTypeByMonitorMetricType(
+        MonitorMetricType.PortTcpConnectTime,
+      ),
+    ).toBe(AggregationType.Avg);
   });
 
   test("cumulative byte/op counters aggregate with Max (latest-in-bucket)", () => {
@@ -70,6 +80,16 @@ describe("getMonitorMeticTypeByCheckOn", () => {
         CheckOn.CPUIoWaitPercent,
       ),
     ).toBe(MonitorMetricType.CPUTimeIoWaitPercent);
+    expect(
+      MonitorMetricTypeUtil.getMonitorMeticTypeByCheckOn(
+        CheckOn.PortDnsLookupTime,
+      ),
+    ).toBe(MonitorMetricType.PortDnsLookupTime);
+    expect(
+      MonitorMetricTypeUtil.getMonitorMeticTypeByCheckOn(
+        CheckOn.PortTcpConnectTime,
+      ),
+    ).toBe(MonitorMetricType.PortTcpConnectTime);
   });
 
   test("throws for a CheckOn without a metric mapping", () => {
@@ -115,6 +135,34 @@ describe("getMonitorMetricTypesByMonitorType", () => {
     expect(ping).toContain(MonitorMetricType.Jitter);
   });
 
+  test("Port exposes total connection time and its Port-specific phases", () => {
+    expect(
+      MonitorMetricTypeUtil.getMonitorMetricTypesByMonitorType(
+        MonitorType.Port,
+      ),
+    ).toEqual([
+      MonitorMetricType.IsOnline,
+      MonitorMetricType.ResponseTime,
+      MonitorMetricType.PortDnsLookupTime,
+      MonitorMetricType.PortTcpConnectTime,
+    ]);
+  });
+
+  test("Port phase metrics do not alias the HTTP phase metric names", () => {
+    expect(MonitorMetricType.PortDnsLookupTime).toBe(
+      "oneuptime.monitor.port.dns.lookup.time",
+    );
+    expect(MonitorMetricType.PortTcpConnectTime).toBe(
+      "oneuptime.monitor.port.tcp.connect.time",
+    );
+    expect(MonitorMetricType.PortDnsLookupTime).not.toBe(
+      MonitorMetricType.DnsLookupTime,
+    );
+    expect(MonitorMetricType.PortTcpConnectTime).not.toBe(
+      MonitorMetricType.TcpConnectTime,
+    );
+  });
+
   test("a monitor type with no metrics returns an empty list", () => {
     expect(
       MonitorMetricTypeUtil.getMonitorMetricTypesByMonitorType(
@@ -187,6 +235,75 @@ describe("display metadata", () => {
         MonitorMetricType.ResponseStatusCode,
       ),
     ).toBe("");
+    expect(
+      MonitorMetricTypeUtil.getLegendUnitByMonitorMetricType(
+        MonitorMetricType.PortDnsLookupTime,
+      ),
+    ).toBe("ms");
+    expect(
+      MonitorMetricTypeUtil.getLegendUnitByMonitorMetricType(
+        MonitorMetricType.PortTcpConnectTime,
+      ),
+    ).toBe("ms");
+  });
+
+  test("Port phase metrics have distinct user-facing metadata", () => {
+    expect(
+      MonitorMetricTypeUtil.getTitleByMonitorMetricType(
+        MonitorMetricType.PortDnsLookupTime,
+      ),
+    ).toBe("Port DNS Lookup Time");
+    expect(
+      MonitorMetricTypeUtil.getTitleByMonitorMetricType(
+        MonitorMetricType.PortTcpConnectTime,
+      ),
+    ).toBe("Port TCP Connect Time");
+    expect(
+      MonitorMetricTypeUtil.getDescriptionByMonitorMetricType(
+        MonitorMetricType.PortDnsLookupTime,
+      ),
+    ).toContain("IP address");
+    expect(
+      MonitorMetricTypeUtil.getDescriptionByMonitorMetricType(
+        MonitorMetricType.PortTcpConnectTime,
+      ),
+    ).toContain("IPv6/IPv4 fallback");
+  });
+
+  test("contextualizes the existing response-time metric for Port charts", () => {
+    expect(
+      MonitorMetricTypeUtil.getTitleByMonitorMetricType(
+        MonitorMetricType.ResponseTime,
+        MonitorType.Port,
+      ),
+    ).toBe("Total Connection Time (DNS + TCP)");
+    expect(
+      MonitorMetricTypeUtil.getLegendByMonitorMetricType(
+        MonitorMetricType.ResponseTime,
+        MonitorType.Port,
+      ),
+    ).toBe("Total Connection Time (DNS + TCP)");
+    expect(
+      MonitorMetricTypeUtil.getDescriptionByMonitorMetricType(
+        MonitorMetricType.ResponseTime,
+        MonitorType.Port,
+      ),
+    ).toContain("resolving the hostname");
+  });
+
+  test("keeps response-time metadata unchanged outside Port charts", () => {
+    expect(
+      MonitorMetricTypeUtil.getTitleByMonitorMetricType(
+        MonitorMetricType.ResponseTime,
+        MonitorType.Website,
+      ),
+    ).toBe("Response Time");
+    expect(
+      MonitorMetricTypeUtil.getDescriptionByMonitorMetricType(
+        MonitorMetricType.ResponseTime,
+        MonitorType.Website,
+      ),
+    ).toContain("server to respond to a request");
   });
 });
 

package/Tests/Utils/RecordingRuleExpression.test.ts

@@ -1,10 +1,13 @@
 import {
   evaluate,
   parse,
+  tokenize,
   validate,
   type Node,
   type ParseError,
   type ParseResult,
+  type Token,
+  type ValidateResult,
 } from "../../Utils/Metrics/RecordingRuleExpression";
 
 function parseOk(input: string): ParseResult {
@@ -17,6 +20,53 @@ function parseOk(input: string): ParseResult {
   return r;
 }
 
+function parseErr(input: string): ParseError {
+  const r: ParseResult | ParseError = parse(input);
+  if (r.ok) {
+    throw new Error(`Expected parse to fail for "${input}" but it succeeded`);
+  }
+  return r;
+}
+
+function tokensOf(input: string): Array<Token> {
+  const t: Array<Token> | ParseError = tokenize(input);
+  if (!Array.isArray(t)) {
+    throw new Error(
+      `Expected tokenize to succeed for "${input}" but got: ${t.error}`,
+    );
+  }
+  return t;
+}
+
+function tokenTypes(input: string): Array<string> {
+  return tokensOf(input).map((t: Token) => {
+    return t.type;
+  });
+}
+
+function tokenValues(input: string): Array<string> {
+  return tokensOf(input).map((t: Token) => {
+    return t.value;
+  });
+}
+
+function tokenizeErr(input: string): ParseError {
+  const t: Array<Token> | ParseError = tokenize(input);
+  if (Array.isArray(t)) {
+    throw new Error(`Expected tokenize to fail for "${input}" but it did not`);
+  }
+  return t;
+}
+
+// ((((A)))) with `depth` pairs of parens.
+function nestParens(depth: number): string {
+  let input: string = "A";
+  for (let i: number = 0; i < depth; i++) {
+    input = `(${input})`;
+  }
+  return input;
+}
+
 function evalOk(input: string, bindings: Record<string, number>): number {
   const r: ParseResult = parseOk(input);
   const v: number | null = evaluate(r.ast, bindings);
@@ -174,4 +224,281 @@ describe("RecordingRuleExpression", () => {
       expect(ast.right.op).toBe("*");
     });
   });
+
+  describe("tokenize", () => {
+    test("emits typed tokens carrying their source position", () => {
+      expect(tokensOf("A + 1")).toEqual([
+        { type: "ident", value: "A", pos: 0 },
+        { type: "op", value: "+", pos: 2 },
+        { type: "number", value: "1", pos: 4 },
+      ]);
+    });
+
+    test("parens get their own token types", () => {
+      expect(tokenTypes("(A)")).toEqual(["lparen", "ident", "rparen"]);
+    });
+
+    test("adjacent operators need no separating space", () => {
+      expect(tokenValues("A*B/C")).toEqual(["A", "*", "B", "/", "C"]);
+    });
+
+    test("space, tab, newline and carriage return are all skipped, and positions still point at the original string", () => {
+      expect(tokensOf("  A\t\n\rB  ")).toEqual([
+        { type: "ident", value: "A", pos: 2 },
+        { type: "ident", value: "B", pos: 6 },
+      ]);
+    });
+
+    test("an unknown character aborts tokenizing and reports where", () => {
+      const r: ParseError = tokenizeErr("A@B");
+      expect(r.error).toBe('Unexpected character "@" at position 1');
+      expect(r.position).toBe(1);
+    });
+  });
+
+  describe("number lexing", () => {
+    test("a trailing dot is consumed into the number and reads as the integer", () => {
+      // The lexer takes the '.' unconditionally, so "1." is one number token.
+      expect(tokensOf("1.")).toEqual([{ type: "number", value: "1.", pos: 0 }]);
+      expect(evalOk("1.", {})).toBe(1);
+    });
+
+    test("leading zeros are kept in the token but not in the value", () => {
+      expect(tokensOf("007")[0]?.value).toBe("007");
+      expect(evalOk("007", {})).toBe(7);
+    });
+
+    test("a second dot is not part of the number and is rejected as a stray character", () => {
+      const r: ParseError = parseErr("2.5.5");
+      expect(r.error).toBe('Unexpected character "." at position 3');
+      expect(r.position).toBe(3);
+    });
+
+    test("a number may not start with a dot", () => {
+      const r: ParseError = parseErr(".5");
+      expect(r.error).toBe('Unexpected character "." at position 0');
+      expect(r.position).toBe(0);
+    });
+
+    test("digits followed by letters lex as two tokens, so the parser rejects them", () => {
+      expect(tokenTypes("1a")).toEqual(["number", "ident"]);
+      expect(parseErr("1a").error).toBe('Unexpected token "a" at position 1');
+    });
+  });
+
+  describe("identifier lexing rules", () => {
+    test("an identifier may be a bare underscore", () => {
+      expect(tokensOf("_")).toEqual([{ type: "ident", value: "_", pos: 0 }]);
+    });
+
+    test("digits are allowed after the first character but not as the first", () => {
+      expect(tokensOf("_9")[0]?.value).toBe("_9");
+      expect(tokensOf("a9_b")[0]?.value).toBe("a9_b");
+      // A leading digit starts a number instead, which leaves a stray ident.
+      expect(tokenTypes("9a")).toEqual(["number", "ident"]);
+    });
+
+    test("characters outside [A-Za-z0-9_] are not identifier characters", () => {
+      expect(tokenizeErr("$a").position).toBe(0);
+      // '-' ends the identifier and becomes an operator rather than joining it.
+      expect(tokenValues("a-b")).toEqual(["a", "-", "b"]);
+    });
+  });
+
+  describe("parse error shapes", () => {
+    test("running out of input reports no position, because there is no token to point at", () => {
+      for (const input of ["", "   ", "A +", "("]) {
+        const r: ParseError = parseErr(input);
+        expect(r.error).toBe("Unexpected end of expression");
+        expect(r.position).toBeUndefined();
+      }
+    });
+
+    test("an unclosed paren at end of input also has no position", () => {
+      const r: ParseError = parseErr("(A + B");
+      expect(r.error).toBe("Expected ')'");
+      expect(r.position).toBeUndefined();
+    });
+
+    test("a stray trailing token names the position both in the message and in the field", () => {
+      const r: ParseError = parseErr("A B");
+      expect(r.error).toBe('Unexpected token "B" at position 2');
+      expect(r.position).toBe(2);
+    });
+
+    test("a token in operand position reports the field but omits the position from the message", () => {
+      // Note the asymmetry with the trailing-token message above.
+      const r: ParseError = parseErr("A + + B");
+      expect(r.error).toBe('Unexpected token "+"');
+      expect(r.position).toBe(4);
+    });
+
+    test("empty parens and a leading binary operator are both rejected in operand position", () => {
+      expect(parseErr("()").error).toBe('Unexpected token ")"');
+      expect(parseErr("()").position).toBe(1);
+      expect(parseErr("* A").error).toBe('Unexpected token "*"');
+      expect(parseErr("* A").position).toBe(0);
+    });
+  });
+
+  describe("associativity", () => {
+    test("'-' is left associative, so A - B - C is (A - B) - C", () => {
+      const ast: Node = parseOk("A - B - C").ast;
+      expect(ast.type).toBe("binary");
+      if (ast.type !== "binary") {
+        return;
+      }
+      expect(ast.left.type).toBe("binary");
+      expect(ast.right.type).toBe("ident");
+      // Right associativity would give 10 - (3 - 2) = 9.
+      expect(evalOk("A - B - C", { A: 10, B: 3, C: 2 })).toBe(5);
+    });
+
+    test("'/' is left associative, so A / B / C is (A / B) / C", () => {
+      const ast: Node = parseOk("A / B / C").ast;
+      expect(ast.type).toBe("binary");
+      if (ast.type !== "binary") {
+        return;
+      }
+      expect(ast.left.type).toBe("binary");
+      expect(ast.right.type).toBe("ident");
+      // Right associativity would give 100 / (5 / 2) = 40.
+      expect(evalOk("A / B / C", { A: 100, B: 5, C: 2 })).toBe(10);
+    });
+
+    test("equal-precedence operators mix left to right", () => {
+      const ast: Node = parseOk("A - B + C").ast;
+      expect(ast.type).toBe("binary");
+      if (ast.type !== "binary") {
+        return;
+      }
+      // The last operator ends up at the root.
+      expect(ast.op).toBe("+");
+      expect(evalOk("A - B + C", { A: 10, B: 3, C: 2 })).toBe(9);
+      expect(evalOk("A / B * C", { A: 100, B: 5, C: 2 })).toBe(40);
+    });
+  });
+
+  describe("nesting depth boundary", () => {
+    test("32 levels of parens still parse", () => {
+      expect(parse(nestParens(32)).ok).toBe(true);
+    });
+
+    test("33 levels are rejected, with no position", () => {
+      const r: ParseError = parseErr(nestParens(33));
+      expect(r.error).toBe("Expression nesting too deep");
+      expect(r.position).toBeUndefined();
+    });
+
+    test("32 unary operators still parse", () => {
+      expect(parse(`${"-".repeat(32)}A`).ok).toBe(true);
+    });
+
+    test("33 unary operators are rejected, with no position", () => {
+      const r: ParseError = parseErr(`${"-".repeat(33)}A`);
+      expect(r.error).toBe("Expression nesting too deep");
+      expect(r.position).toBeUndefined();
+    });
+
+    test("parentheses and unary operators share the nesting limit", () => {
+      const input: string = `${"(".repeat(16)}${"-".repeat(17)}A${")".repeat(16)}`;
+      expect(parseErr(input).error).toBe("Expression nesting too deep");
+    });
+
+    test("the limit is on nesting, not on expression length", () => {
+      // 200 chained additions stay at depth 1 and must not trip the guard.
+      let chain: string = "A";
+      for (let i: number = 0; i < 200; i++) {
+        chain += " + A";
+      }
+      expect(parse(chain).ok).toBe(true);
+      expect(evalOk(chain, { A: 1 })).toBe(201);
+    });
+  });
+
+  describe("identifier collection order", () => {
+    test("identifiers come back in first-appearance order, not sorted", () => {
+      expect(parseOk("C + A + B").identifiers).toEqual(["C", "A", "B"]);
+    });
+
+    test("a repeated identifier is listed once", () => {
+      expect(parseOk("A + A").identifiers).toEqual(["A"]);
+    });
+
+    test("order follows the parse, so a parenthesised group is collected as it is reached", () => {
+      expect(parseOk("Z * (Y + X)").identifiers).toEqual(["Z", "Y", "X"]);
+    });
+
+    test("an expression of pure literals binds nothing", () => {
+      expect(parseOk("1 + 2 * 3").identifiers).toEqual([]);
+    });
+  });
+
+  describe("validate passthrough", () => {
+    test("a parse error carrying a position keeps it", () => {
+      const r: ValidateResult = validate("A @ B", ["A"]);
+      expect(r.ok).toBe(false);
+      expect(r.error).toBe('Unexpected character "@" at position 2');
+      expect(r.position).toBe(2);
+    });
+
+    test("a parse error without a position does not invent one", () => {
+      const r: ValidateResult = validate("(A", ["A"]);
+      expect(r.ok).toBe(false);
+      expect(r.error).toBe("Expected ')'");
+      expect(r.position).toBeUndefined();
+    });
+
+    test("every unknown identifier is reported, in first-appearance order", () => {
+      const r: ValidateResult = validate("A + X + Y", ["A"]);
+      expect(r.ok).toBe(false);
+      expect(r.error).toBe("Unknown identifier(s): X, Y");
+      expect(r.unknownIdentifiers).toEqual(["X", "Y"]);
+    });
+
+    test("an expression with no identifiers passes an empty allow list", () => {
+      expect(validate("1 + 1", [])).toEqual({ ok: true });
+    });
+
+    test("a successful validate reports nothing but ok", () => {
+      const r: ValidateResult = validate("A + B", ["A", "B", "C"]);
+      expect(r.ok).toBe(true);
+      expect(r.error).toBeUndefined();
+      expect(r.unknownIdentifiers).toBeUndefined();
+    });
+  });
+
+  describe("evaluate edge cases", () => {
+    test("a non-number Object.prototype member is not a binding", () => {
+      /*
+       * bindings["toString"] is a function, so the typeof guard must reject it
+       * rather than letting a prototype member leak into the result.
+       */
+      const r: ParseResult = parseOk("toString");
+      expect(evaluate(r.ast, {})).toBeNull();
+    });
+
+    test("a numeric inherited property is not a binding", () => {
+      const bindings: Record<string, number> = Object.create({ inherited: 7 });
+      const r: ParseResult = parseOk("inherited");
+      expect(evaluate(r.ast, bindings)).toBeNull();
+    });
+
+    test("an own property on a null-prototype binding map is accepted", () => {
+      const bindings: Record<string, number> = Object.create(null);
+      bindings["A"] = 7;
+      const r: ParseResult = parseOk("A");
+      expect(evaluate(r.ast, bindings)).toBe(7);
+    });
+
+    test("0 / 0 is null rather than NaN", () => {
+      const r: ParseResult = parseOk("A / B");
+      expect(evaluate(r.ast, { A: 0, B: 0 })).toBeNull();
+    });
+
+    test("double unary minus cancels out", () => {
+      expect(evalOk("--A", { A: 5 })).toBe(5);
+      expect(evalOk("-3 * -2", {})).toBe(6);
+    });
+  });
 });