@oneuptime/common 11.5.12 → 11.6.0

package/Tests/Server/Utils/Marketing/ConversionUploadProvider.test.ts

@@ -0,0 +1,183 @@
+import MarketingConversion from "../../../../Models/DatabaseModels/MarketingConversion";
+import ConversionUploadProvider, {
+  ConversionSkip,
+  ConversionUploadBatchResult,
+} from "../../../../Server/Utils/Marketing/ConversionUploadProvider";
+import { MarketingConversionType } from "../../../../Types/Marketing/MarketingConversion";
+import { AxiosError } from "axios";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+
+class TestProvider extends ConversionUploadProvider {
+  public override readonly key: string = "test";
+  public override readonly displayName: string = "Test Provider";
+
+  public override isConfigured(): boolean {
+    return true;
+  }
+
+  public override getSkipReason(
+    _conversion: MarketingConversion,
+  ): ConversionSkip | null {
+    return null;
+  }
+
+  public override async upload(
+    _conversions: Array<MarketingConversion>,
+  ): Promise<ConversionUploadBatchResult> {
+    return { permanentFailures: new Map<number, string>() };
+  }
+
+  public readClickId(
+    conversion: MarketingConversion,
+    key: string,
+  ): string | undefined {
+    return this.getClickId(conversion, key);
+  }
+
+  public readValueInUSD(conversion: MarketingConversion): number | undefined {
+    return this.getValueInUSD(conversion);
+  }
+
+  public readIsSignUp(conversion: MarketingConversion): boolean {
+    return this.isSignUp(conversion);
+  }
+
+  public readIsOlderThanDays(
+    conversion: MarketingConversion,
+    days: number,
+  ): boolean {
+    return this.isOlderThanDays(conversion, days);
+  }
+}
+
+const makeConversion: (
+  data?: Partial<MarketingConversion>,
+) => MarketingConversion = (
+  data: Partial<MarketingConversion> = {},
+): MarketingConversion => {
+  return Object.assign(new MarketingConversion(), data);
+};
+
+describe("ConversionUploadProvider", () => {
+  const provider: TestProvider = new TestProvider();
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("extracts a non-empty string click ID", () => {
+    const conversion: MarketingConversion = makeConversion({
+      clickIds: { gclid: "google-click" },
+    });
+
+    expect(provider.readClickId(conversion, "gclid")).toBe("google-click");
+  });
+
+  test.each([undefined, null, "", 0, 123, false, { nested: true }])(
+    "rejects an invalid click ID value: %p",
+    (value: unknown) => {
+      const conversion: MarketingConversion = makeConversion({
+        clickIds: { gclid: value as never },
+      });
+
+      expect(provider.readClickId(conversion, "gclid")).toBeUndefined();
+    },
+  );
+
+  test("returns undefined when click IDs are absent", () => {
+    const conversion: MarketingConversion = makeConversion();
+    delete conversion.clickIds;
+
+    expect(provider.readClickId(conversion, "gclid")).toBeUndefined();
+  });
+
+  test("converts cents to an exact USD decimal", () => {
+    expect(
+      provider.readValueInUSD(
+        makeConversion({ conversionValueInUSDCents: 12345 }),
+      ),
+    ).toBe(123.45);
+  });
+
+  test.each([undefined, null, 0, -1, -100])(
+    "omits a non-positive or missing conversion value: %p",
+    (value: number | null | undefined) => {
+      const conversion: MarketingConversion = makeConversion();
+      conversion.conversionValueInUSDCents = value as never;
+
+      expect(provider.readValueInUSD(conversion)).toBeUndefined();
+    },
+  );
+
+  test("classifies only the SignUp conversion type as a signup", () => {
+    expect(
+      provider.readIsSignUp(
+        makeConversion({ conversionType: MarketingConversionType.SignUp }),
+      ),
+    ).toBe(true);
+    expect(
+      provider.readIsSignUp(
+        makeConversion({
+          conversionType: MarketingConversionType.PaidSubscription,
+        }),
+      ),
+    ).toBe(false);
+  });
+
+  test("checks conversion age against the provider window", () => {
+    jest
+      .spyOn(Date, "now")
+      .mockReturnValue(new Date("2026-07-22T12:00:00.000Z").getTime());
+
+    expect(
+      provider.readIsOlderThanDays(
+        makeConversion({
+          conversionAt: new Date("2026-04-22T11:59:59.999Z"),
+        }),
+        90,
+      ),
+    ).toBe(true);
+    expect(
+      provider.readIsOlderThanDays(
+        makeConversion({
+          conversionAt: new Date("2026-07-21T12:00:00.000Z"),
+        }),
+        90,
+      ),
+    ).toBe(false);
+  });
+
+  test("uses the current time when conversionAt is missing", () => {
+    jest
+      .spyOn(Date, "now")
+      .mockReturnValue(new Date("2026-07-22T12:00:00.000Z").getTime());
+
+    expect(provider.readIsOlderThanDays(makeConversion(), 90)).toBe(false);
+  });
+
+  test("formats ordinary errors without leaking an object dump", () => {
+    expect(
+      ConversionUploadProvider.getErrorMessage(new Error("network down")),
+    ).toBe("network down");
+  });
+
+  test("formats Axios errors with status and bounded response data", () => {
+    const error: AxiosError = new AxiosError("rate limited");
+    Object.assign(error, {
+      response: {
+        status: 429,
+        data: { error: "retry later" },
+      },
+    });
+
+    expect(ConversionUploadProvider.getErrorMessage(error)).toBe(
+      'HTTP 429: {"error":"retry later"}',
+    );
+  });
+
+  test("falls back to Unknown error for non-error values", () => {
+    expect(ConversionUploadProvider.getErrorMessage(null)).toBe(
+      "Unknown error",
+    );
+  });
+});

package/Tests/Server/Utils/Marketing/GoogleAds.test.ts

@@ -0,0 +1,340 @@
+import MarketingConversion from "../../../../Models/DatabaseModels/MarketingConversion";
+import logger from "../../../../Server/Utils/Logger";
+import GoogleAdsProvider from "../../../../Server/Utils/Marketing/Providers/GoogleAds";
+import { ConversionUploadBatchResult } from "../../../../Server/Utils/Marketing/ConversionUploadProvider";
+import { JSONObject } from "../../../../Types/JSON";
+import { MarketingConversionType } from "../../../../Types/Marketing/MarketingConversion";
+import axios, { AxiosResponse } from "axios";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { SpyInstance } from "jest-mock";
+
+jest.mock("../../../../Server/EnvironmentConfig", () => {
+  return {
+    GoogleAdsApiVersion: "v23",
+    GoogleAdsCustomerId: "1234567890",
+    GoogleAdsDeveloperToken: "developer-token",
+    GoogleAdsLoginCustomerId: "0987654321",
+    GoogleAdsOAuthClientId: "oauth-client-id",
+    GoogleAdsOAuthClientSecret: "oauth-client-secret",
+    GoogleAdsOAuthRefreshToken: "oauth-refresh-token",
+    GoogleAdsPaidSubscriptionConversionActionId: "222222",
+    GoogleAdsSignUpConversionActionId: "111111",
+  };
+});
+
+jest.mock("../../../../Server/Utils/Logger", () => {
+  return {
+    __esModule: true,
+    default: {
+      error: jest.fn(),
+    },
+  };
+});
+
+const makeConversion: (
+  data?: Partial<MarketingConversion>,
+) => MarketingConversion = (
+  data: Partial<MarketingConversion> = {},
+): MarketingConversion => {
+  return Object.assign(new MarketingConversion(), {
+    conversionType: MarketingConversionType.SignUp,
+    conversionAt: new Date("2026-07-22T10:11:12.345Z"),
+    clickIds: { gclid: "google-click" },
+    ...data,
+  });
+};
+
+const response: (data: JSONObject) => AxiosResponse<JSONObject> = (
+  data: JSONObject,
+): AxiosResponse<JSONObject> => {
+  return { data } as AxiosResponse<JSONObject>;
+};
+
+describe("GoogleAdsProvider", () => {
+  let provider: GoogleAdsProvider;
+  let postSpy: SpyInstance<any>;
+
+  beforeEach(() => {
+    provider = new GoogleAdsProvider();
+    postSpy = jest.spyOn(axios, "post") as SpyInstance<any>;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("reports configured only when the OAuth and account settings exist", () => {
+    expect(provider.isConfigured()).toBe(true);
+  });
+
+  test("permanently skips conversions without a Google click identifier", () => {
+    expect(
+      provider.getSkipReason(makeConversion({ clickIds: { fbclid: "meta" } })),
+    ).toEqual({
+      reason: "No Google click id (gclid/wbraid/gbraid)",
+      isPermanent: true,
+    });
+  });
+
+  test.each([
+    ["gclid", "standard-click"],
+    ["wbraid", "web-to-app-click"],
+    ["gbraid", "app-to-web-click"],
+  ])("accepts the supported %s identifier", (key: string, value: string) => {
+    expect(
+      provider.getSkipReason(makeConversion({ clickIds: { [key]: value } })),
+    ).toBeNull();
+  });
+
+  test("prefers gclid when multiple Google identifiers are present", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(response({}) as never);
+
+    await provider.upload([
+      makeConversion({
+        clickIds: {
+          gclid: "preferred-gclid",
+          wbraid: "secondary-wbraid",
+          gbraid: "secondary-gbraid",
+        },
+      }),
+    ]);
+
+    const uploadBody: JSONObject = postSpy.mock.calls[1]?.[1] as JSONObject;
+    const uploadedConversion: JSONObject = (
+      uploadBody["conversions"] as Array<JSONObject>
+    )[0]!;
+
+    expect(uploadedConversion).toMatchObject({ gclid: "preferred-gclid" });
+    expect(uploadedConversion["wbraid"]).toBeUndefined();
+    expect(uploadedConversion["gbraid"]).toBeUndefined();
+  });
+
+  test("permanently skips conversions outside Google's 90-day window", () => {
+    jest
+      .spyOn(Date, "now")
+      .mockReturnValue(new Date("2026-07-22T12:00:00.000Z").getTime());
+
+    expect(
+      provider.getSkipReason(
+        makeConversion({
+          conversionAt: new Date("2026-04-01T00:00:00.000Z"),
+        }),
+      ),
+    ).toEqual({
+      reason: "Conversion older than Google's 90-day click window",
+      isPermanent: true,
+    });
+  });
+
+  test("uploads signup and paid conversions with the correct actions and value", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(response({}) as never);
+
+    const result: ConversionUploadBatchResult = await provider.upload([
+      makeConversion({
+        conversionType: MarketingConversionType.SignUp,
+        clickIds: { wbraid: "signup-wbraid" },
+      }),
+      makeConversion({
+        conversionType: MarketingConversionType.PaidSubscription,
+        clickIds: { gbraid: "paid-gbraid" },
+        conversionValueInUSDCents: 12999,
+      }),
+    ]);
+
+    expect(result.permanentFailures.size).toBe(0);
+    expect(postSpy).toHaveBeenCalledTimes(2);
+    expect(postSpy.mock.calls[0]?.[0]).toBe(
+      "https://oauth2.googleapis.com/token",
+    );
+    expect(postSpy.mock.calls[0]?.[1]).toContain(
+      "refresh_token=oauth-refresh-token",
+    );
+
+    const uploadUrl: string = postSpy.mock.calls[1]?.[0] as string;
+    const uploadBody: JSONObject = postSpy.mock.calls[1]?.[1] as JSONObject;
+    const uploadOptions: JSONObject = postSpy.mock.calls[1]?.[2] as JSONObject;
+    const conversions: Array<JSONObject> = uploadBody[
+      "conversions"
+    ] as Array<JSONObject>;
+
+    expect(uploadUrl).toBe(
+      "https://googleads.googleapis.com/v23/customers/1234567890:uploadClickConversions",
+    );
+    expect(uploadBody["partialFailure"]).toBe(true);
+    expect(conversions[0]).toEqual({
+      wbraid: "signup-wbraid",
+      conversionAction: "customers/1234567890/conversionActions/111111",
+      conversionDateTime: "2026-07-22 10:11:12+00:00",
+    });
+    expect(conversions[1]).toEqual({
+      gbraid: "paid-gbraid",
+      conversionAction: "customers/1234567890/conversionActions/222222",
+      conversionDateTime: "2026-07-22 10:11:12+00:00",
+      conversionValue: 129.99,
+      currencyCode: "USD",
+    });
+    expect(uploadOptions).toMatchObject({
+      headers: {
+        Authorization: "Bearer access-token",
+        "developer-token": "developer-token",
+        "login-customer-id": "0987654321",
+      },
+      timeout: 30000,
+    });
+  });
+
+  test("does not send zero or negative conversion values", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(response({}) as never);
+
+    await provider.upload([
+      makeConversion({ conversionValueInUSDCents: 0 }),
+      makeConversion({ conversionValueInUSDCents: -100 }),
+    ]);
+
+    const uploadBody: JSONObject = postSpy.mock.calls[1]?.[1] as JSONObject;
+    const conversions: Array<JSONObject> = uploadBody[
+      "conversions"
+    ] as Array<JSONObject>;
+
+    expect(conversions[0]?.["conversionValue"]).toBeUndefined();
+    expect(conversions[0]?.["currencyCode"]).toBeUndefined();
+    expect(conversions[1]?.["conversionValue"]).toBeUndefined();
+  });
+
+  test("reuses an unexpired OAuth access token across batches", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "cached-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValue(response({}) as never);
+
+    await provider.upload([makeConversion()]);
+    await provider.upload([makeConversion({ clickIds: { gclid: "second" } })]);
+
+    expect(postSpy).toHaveBeenCalledTimes(3);
+    expect(
+      postSpy.mock.calls.filter((call: Array<unknown>) => {
+        return call[0] === "https://oauth2.googleapis.com/token";
+      }),
+    ).toHaveLength(1);
+  });
+
+  test("maps indexed partial failures to the submitted conversion", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(
+        response({
+          partialFailureError: {
+            details: [
+              {
+                errors: [
+                  {
+                    message: "Expired click identifier",
+                    location: {
+                      fieldPathElements: [
+                        { fieldName: "conversions", index: 1 },
+                      ],
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        }) as never,
+      );
+
+    const result: ConversionUploadBatchResult = await provider.upload([
+      makeConversion(),
+      makeConversion({ clickIds: { gclid: "expired" } }),
+    ]);
+
+    expect(Array.from(result.permanentFailures.entries())).toEqual([
+      [1, "Expired click identifier"],
+    ]);
+  });
+
+  test("treats ALREADY_EXISTS as successful idempotent delivery", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(
+        response({
+          partialFailureError: {
+            details: [
+              {
+                errors: [
+                  {
+                    errorCode: { conversionUploadError: "ALREADY_EXISTS" },
+                    message: "The conversion was already uploaded",
+                    location: {
+                      fieldPathElements: [
+                        { fieldName: "conversions", index: 0 },
+                      ],
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        }) as never,
+      );
+
+    const result: ConversionUploadBatchResult = await provider.upload([
+      makeConversion(),
+    ]);
+
+    expect(result.permanentFailures.size).toBe(0);
+  });
+
+  test("logs an unparseable partial failure instead of silently hiding it", async () => {
+    const errorSpy: SpyInstance<typeof logger.error> = jest
+      .spyOn(logger, "error")
+      .mockImplementation((): void => {
+        return undefined;
+      });
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(
+        response({
+          partialFailureError: {
+            details: [{ errors: [{ message: "Unindexed failure" }] }],
+          },
+        }) as never,
+      );
+
+    const result: ConversionUploadBatchResult = await provider.upload([
+      makeConversion(),
+    ]);
+
+    expect(result.permanentFailures.size).toBe(0);
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        "Google Ads partial failure with unparseable indexes",
+      ),
+    );
+  });
+});

package/Tests/Server/Utils/Monitor/Criteria/ExceptionMonitorCriteria.test.ts

@@ -0,0 +1,87 @@
+import ExceptionMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/ExceptionMonitorCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+import ExceptionMonitorResponse from "../../../../../Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse";
+import DataToProcess from "../../../../../Server/Utils/Monitor/DataToProcess";
+import ObjectID from "../../../../../Types/ObjectID";
+
+/*
+ * ExceptionMonitorCriteria is the ExceptionCount analogue of
+ * LogMonitorCriteria and shares the same fallback-fixed worker path
+ * (monitorException). Covered here for parity across the count-based
+ * telemetry criteria.
+ */
+function buildResponse(exceptionCount: number | undefined): DataToProcess {
+  const response: Partial<ExceptionMonitorResponse> = {
+    projectId: ObjectID.generate(),
+    monitorId: ObjectID.generate(),
+    exceptionCount: exceptionCount as number,
+    exceptionQuery: {},
+  };
+  return response as DataToProcess;
+}
+
+function evaluate(
+  exceptionCount: number | undefined,
+  criteriaFilter: CriteriaFilter,
+): Promise<string | null> {
+  return ExceptionMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+    dataToProcess: buildResponse(exceptionCount),
+    criteriaFilter,
+  });
+}
+
+describe("ExceptionMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
+  test("ExceptionCount GreaterThan 0 → met when exceptions exist", async () => {
+    expect(
+      await evaluate(3, {
+        checkOn: CheckOn.ExceptionCount,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+    ).toBeTruthy();
+  });
+
+  test("ExceptionCount EqualTo 0 → met when there are none (default)", async () => {
+    expect(
+      await evaluate(0, {
+        checkOn: CheckOn.ExceptionCount,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    ).toBeTruthy();
+  });
+
+  test("ExceptionCount GreaterThan → not met when none", async () => {
+    expect(
+      await evaluate(0, {
+        checkOn: CheckOn.ExceptionCount,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+    ).toBeNull();
+  });
+
+  test("a missing exceptionCount is treated as 0", async () => {
+    expect(
+      await evaluate(undefined, {
+        checkOn: CheckOn.ExceptionCount,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    ).toBeTruthy();
+  });
+
+  test("a non-ExceptionCount checkOn returns null (unhandled)", async () => {
+    expect(
+      await evaluate(9, {
+        checkOn: CheckOn.LogCount,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+    ).toBeNull();
+  });
+});