@oneuptime/common 13.0.8 → 14.0.1

package/Tests/Server/EnvironmentConfigEnterpriseEdition.test.ts

@@ -0,0 +1,314 @@
+import { afterEach, describe, expect, it, jest } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import type URL from "../../Types/API/URL";
+
+/*
+ * The environment variables behind the Community / Enterprise split:
+ * ONEUPTIME_EDITION, ONEUPTIME_EE_DIR, ALLOW_BILLING_WITHOUT_ENTERPRISE and
+ * ENTERPRISE_LICENSE_SERVER_URL (which the two license-server endpoint URLs
+ * derive from).
+ *
+ * EnvironmentConfig reads process.env at module load, so every case here
+ * sets the environment, resets the module registry and imports afresh.
+ */
+
+type OneUptimeEditionSetting = "auto" | "community" | "enterprise";
+
+interface EnvironmentConfigShape {
+  OneUptimeEdition: OneUptimeEditionSetting | null;
+  ONEUPTIME_EDITION_SETTINGS: ReadonlyArray<OneUptimeEditionSetting>;
+  parseOneUptimeEdition: (
+    rawValue: string | undefined,
+  ) => OneUptimeEditionSetting | null;
+  OneUptimeEnterpriseDirectory: string | undefined;
+  AllowBillingWithoutEnterprise: boolean;
+  IsEnterpriseEdition: boolean;
+  DEFAULT_ENTERPRISE_LICENSE_SERVER_URL: string;
+  resolveEnterpriseLicenseServerUrl: (
+    rawValue: string | undefined,
+    allowInsecure: boolean,
+  ) => string;
+  EnterpriseLicenseServerUrl: URL;
+  EnterpriseLicenseValidationUrl: URL;
+  EnterpriseLicenseUserCountReportUrl: URL;
+}
+
+const MANAGED_KEYS: Array<string> = [
+  "ONEUPTIME_EDITION",
+  "ONEUPTIME_EE_DIR",
+  "ALLOW_BILLING_WITHOUT_ENTERPRISE",
+  "ENTERPRISE_LICENSE_SERVER_URL",
+  "IS_ENTERPRISE_EDITION",
+  "ENVIRONMENT",
+];
+
+const originalEnv: NodeJS.ProcessEnv = { ...process.env };
+
+async function load(
+  overrides: Record<string, string | undefined>,
+): Promise<EnvironmentConfigShape> {
+  for (const key of MANAGED_KEYS) {
+    delete process.env[key];
+  }
+
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  jest.resetModules();
+
+  return (await import(
+    "../../Server/EnvironmentConfig"
+  )) as unknown as EnvironmentConfigShape;
+}
+
+afterEach(() => {
+  process.env = { ...originalEnv };
+  jest.resetModules();
+});
+
+describe("ONEUPTIME_EDITION", () => {
+  it("defaults to auto when unset", async () => {
+    const config: EnvironmentConfigShape = await load({});
+
+    expect(config.OneUptimeEdition).toBe("auto");
+  });
+
+  it("reads a blank value as auto", async () => {
+    const config: EnvironmentConfigShape = await load({
+      ONEUPTIME_EDITION: "   ",
+    });
+
+    expect(config.OneUptimeEdition).toBe("auto");
+  });
+
+  it.each([
+    "auto",
+    "community",
+    "enterprise",
+  ] as Array<OneUptimeEditionSetting>)(
+    "accepts %s",
+    async (edition: OneUptimeEditionSetting) => {
+      const config: EnvironmentConfigShape = await load({
+        ONEUPTIME_EDITION: edition,
+      });
+
+      expect(config.OneUptimeEdition).toBe(edition);
+    },
+  );
+
+  it("is case- and whitespace-insensitive", async () => {
+    const config: EnvironmentConfigShape = await load({
+      ONEUPTIME_EDITION: "  Enterprise \n",
+    });
+
+    expect(config.OneUptimeEdition).toBe("enterprise");
+  });
+
+  it.each(["enterprize", "ce", "ee", "true", "1", "communityedition"])(
+    "reports an unrecognised value (%s) as null so the loader can refuse to boot",
+    async (rawValue: string) => {
+      const config: EnvironmentConfigShape = await load({
+        ONEUPTIME_EDITION: rawValue,
+      });
+
+      expect(config.OneUptimeEdition).toBeNull();
+    },
+  );
+
+  it("lists exactly the three settings", async () => {
+    const config: EnvironmentConfigShape = await load({});
+
+    expect([...config.ONEUPTIME_EDITION_SETTINGS]).toEqual([
+      "auto",
+      "community",
+      "enterprise",
+    ]);
+  });
+
+  it("parseOneUptimeEdition is a pure function of its argument", async () => {
+    const config: EnvironmentConfigShape = await load({
+      ONEUPTIME_EDITION: "community",
+    });
+
+    expect(config.parseOneUptimeEdition(undefined)).toBe("auto");
+    expect(config.parseOneUptimeEdition("")).toBe("auto");
+    expect(config.parseOneUptimeEdition("COMMUNITY")).toBe("community");
+    expect(config.parseOneUptimeEdition("nope")).toBeNull();
+  });
+
+  it("does not change what IS_ENTERPRISE_EDITION means", async () => {
+    const enterprise: EnvironmentConfigShape = await load({
+      IS_ENTERPRISE_EDITION: "true",
+      ONEUPTIME_EDITION: "community",
+    });
+
+    expect(enterprise.IsEnterpriseEdition).toBe(true);
+    expect(enterprise.OneUptimeEdition).toBe("community");
+
+    const community: EnvironmentConfigShape = await load({
+      ONEUPTIME_EDITION: "enterprise",
+    });
+
+    expect(community.IsEnterpriseEdition).toBe(false);
+  });
+});
+
+describe("ONEUPTIME_EE_DIR", () => {
+  it("is undefined when unset or blank", async () => {
+    expect((await load({})).OneUptimeEnterpriseDirectory).toBeUndefined();
+    expect(
+      (await load({ ONEUPTIME_EE_DIR: "  " })).OneUptimeEnterpriseDirectory,
+    ).toBeUndefined();
+  });
+
+  it("is the trimmed path when set", async () => {
+    const config: EnvironmentConfigShape = await load({
+      ONEUPTIME_EE_DIR: " /opt/fixtures/ee \n",
+    });
+
+    expect(config.OneUptimeEnterpriseDirectory).toBe("/opt/fixtures/ee");
+  });
+});
+
+describe("ALLOW_BILLING_WITHOUT_ENTERPRISE", () => {
+  it("is off unless exactly true", async () => {
+    expect((await load({})).AllowBillingWithoutEnterprise).toBe(false);
+    expect(
+      (await load({ ALLOW_BILLING_WITHOUT_ENTERPRISE: "1" }))
+        .AllowBillingWithoutEnterprise,
+    ).toBe(false);
+    expect(
+      (await load({ ALLOW_BILLING_WITHOUT_ENTERPRISE: "TRUE" }))
+        .AllowBillingWithoutEnterprise,
+    ).toBe(false);
+    expect(
+      (await load({ ALLOW_BILLING_WITHOUT_ENTERPRISE: "true" }))
+        .AllowBillingWithoutEnterprise,
+    ).toBe(true);
+  });
+});
+
+describe("ENTERPRISE_LICENSE_SERVER_URL", () => {
+  it("defaults to oneuptime.com and keeps the historical endpoint URLs byte-identical", async () => {
+    const config: EnvironmentConfigShape = await load({});
+
+    expect(config.DEFAULT_ENTERPRISE_LICENSE_SERVER_URL).toBe(
+      "https://oneuptime.com",
+    );
+    // The URL type renders a bare origin with its root path.
+    expect(config.EnterpriseLicenseServerUrl.toString()).toBe(
+      "https://oneuptime.com/",
+    );
+    expect(config.EnterpriseLicenseValidationUrl.toString()).toBe(
+      "https://oneuptime.com/api/enterprise-license/validate",
+    );
+    expect(config.EnterpriseLicenseUserCountReportUrl.toString()).toBe(
+      "https://oneuptime.com/api/enterprise-license/report-user-count",
+    );
+  });
+
+  it("derives both endpoints from an https override", async () => {
+    const config: EnvironmentConfigShape = await load({
+      ENTERPRISE_LICENSE_SERVER_URL: "https://licenses.staging.example.com/",
+      ENVIRONMENT: "production",
+    });
+
+    expect(config.EnterpriseLicenseServerUrl.toString()).toBe(
+      "https://licenses.staging.example.com/",
+    );
+    expect(config.EnterpriseLicenseValidationUrl.toString()).toBe(
+      "https://licenses.staging.example.com/api/enterprise-license/validate",
+    );
+    expect(config.EnterpriseLicenseUserCountReportUrl.toString()).toBe(
+      "https://licenses.staging.example.com/api/enterprise-license/report-user-count",
+    );
+  });
+
+  it("keeps a path prefix on the override", async () => {
+    const config: EnvironmentConfigShape = await load({
+      ENTERPRISE_LICENSE_SERVER_URL: "https://relay.example.com/oneuptime//",
+      ENVIRONMENT: "production",
+    });
+
+    expect(config.EnterpriseLicenseValidationUrl.toString()).toBe(
+      "https://relay.example.com/oneuptime/api/enterprise-license/validate",
+    );
+  });
+
+  it("refuses plain http in production (the license key would travel in the clear)", async () => {
+    const config: EnvironmentConfigShape = await load({
+      ENTERPRISE_LICENSE_SERVER_URL: "http://licenses.example.com",
+      ENVIRONMENT: "production",
+    });
+
+    expect(config.EnterpriseLicenseValidationUrl.toString()).toBe(
+      "https://oneuptime.com/api/enterprise-license/validate",
+    );
+  });
+
+  it.each(["development", "test"])(
+    "allows plain http in %s",
+    async (environment: string) => {
+      const config: EnvironmentConfigShape = await load({
+        ENTERPRISE_LICENSE_SERVER_URL: "http://localhost:3002",
+        ENVIRONMENT: environment,
+      });
+
+      expect(config.EnterpriseLicenseValidationUrl.toString()).toBe(
+        "http://localhost:3002/api/enterprise-license/validate",
+      );
+    },
+  );
+
+  it("resolveEnterpriseLicenseServerUrl falls back to the default for unusable values", async () => {
+    const config: EnvironmentConfigShape = await load({});
+    const resolve: EnvironmentConfigShape["resolveEnterpriseLicenseServerUrl"] =
+      config.resolveEnterpriseLicenseServerUrl;
+
+    expect(resolve(undefined, false)).toBe("https://oneuptime.com");
+    expect(resolve("", true)).toBe("https://oneuptime.com");
+    expect(resolve("   ", true)).toBe("https://oneuptime.com");
+    expect(resolve("licenses.example.com", true)).toBe("https://oneuptime.com");
+    expect(resolve("ftp://licenses.example.com", true)).toBe(
+      "https://oneuptime.com",
+    );
+    expect(resolve("javascript:alert(1)", true)).toBe("https://oneuptime.com");
+    expect(resolve("http://licenses.example.com", false)).toBe(
+      "https://oneuptime.com",
+    );
+    expect(resolve("https://", true)).toBe("https://oneuptime.com");
+  });
+
+  it("resolveEnterpriseLicenseServerUrl keeps usable values, minus trailing slashes", async () => {
+    const config: EnvironmentConfigShape = await load({});
+    const resolve: EnvironmentConfigShape["resolveEnterpriseLicenseServerUrl"] =
+      config.resolveEnterpriseLicenseServerUrl;
+
+    expect(resolve("https://licenses.example.com", false)).toBe(
+      "https://licenses.example.com",
+    );
+    expect(resolve(" HTTPS://Licenses.Example.com/// ", false)).toBe(
+      "HTTPS://Licenses.Example.com",
+    );
+    expect(resolve("http://localhost:3002/", true)).toBe(
+      "http://localhost:3002",
+    );
+  });
+});
+
+describe("EnvironmentConfig import hygiene", () => {
+  it("EnvironmentConfig never imports the enterprise module (no import cycle)", () => {
+    const source: string = fs.readFileSync(
+      path.join(__dirname, "../../Server/EnvironmentConfig.ts"),
+      "utf8",
+    );
+
+    expect(source).not.toContain("./Enterprise/");
+  });
+});

package/Tests/Server/Infrastructure/ContainerBootConfiguration.test.ts

@@ -59,10 +59,26 @@ interface ServiceImage {
    * we must not confuse with the production one.
    */
   productionStanza: string;
+  /*
+   * The whole Dockerfile as it renders for production: everything before the
+   * development branch plus the production stanza. Stages defined before the
+   * branch (a shared `base`) belong to the production build too.
+   */
+  productionDockerfile: string;
   // The `start` script the production CMD ultimately runs, if it runs one.
   startScript: string | null;
 }
 
+// One `FROM` stage of a Dockerfile.
+interface DockerfileStage {
+  // The `AS <name>`, lower-cased, or null for an unnamed stage.
+  name: string | null;
+  // What it is built FROM: an image or an earlier stage's name (lower-cased).
+  from: string;
+  // The instructions after the FROM line, up to the next FROM.
+  body: string;
+}
+
 // CMD forms that hand control to `npm start`.
 const CMD_NPM_START_EXEC_FORM: RegExp = /CMD\s*\[\s*"npm"\s*,\s*"start"\s*\]/;
 const CMD_NPM_START_SHELL_FORM: RegExp = /CMD\s+npm\s+start/;
@@ -80,6 +96,81 @@ const RUN_COMPILE_INSTRUCTION: RegExp = /^\s*RUN\s+npm\s+run\s+compile\s*$/m;
 const INCLUDE_ARRAY_BLOCK: RegExp = /"include"\s*:\s*\[([^\]]*)\]/;
 const QUOTED_STRING: RegExp = /"[^"]*"/g;
 
+// Where the development branch of a Dockerfile.tpl starts.
+const DEVELOPMENT_BRANCH_START: string =
+  '{{ if eq .Env.ENVIRONMENT "development" }}';
+// A FROM line: `FROM <image or stage> [AS <name>]`, case-insensitive like Docker.
+const FROM_INSTRUCTION: RegExp =
+  /^\s*FROM\s+(?:--\S+\s+)*(\S+)(?:\s+AS\s+(\S+))?\s*$/i;
+const USER_NODE_INSTRUCTION: RegExp = /^\s*USER\s+node\s*$/m;
+// Any COPY/ADD whose source is the ee/ directory (./ee, ee, ./ee/...).
+const COPIES_ENTERPRISE_DIRECTORY: RegExp =
+  /^\s*(?:COPY|ADD)\s+(?:--\S+\s+)*(?:\.\/)?ee(?:\/\S*)?\s/im;
+const SETS_ONEUPTIME_EDITION: RegExp = /^\s*ENV\s+ONEUPTIME_EDITION[=\s]/m;
+const SETS_ENTERPRISE_EDITION_MARKER: RegExp =
+  /^\s*ENV\s+ONEUPTIME_EDITION=enterprise\s*$/m;
+
+// The final stages the edition split builds (packages/App/Dockerfile.tpl).
+const EDITION_STAGE_NAMES: Array<string> = ["community", "enterprise"];
+
+// Splits a Dockerfile into its FROM stages, in order.
+const splitStages: (dockerfile: string) => Array<DockerfileStage> = (
+  dockerfile: string,
+): Array<DockerfileStage> => {
+  const stages: Array<DockerfileStage> = [];
+  let current: DockerfileStage | null = null;
+
+  for (const line of dockerfile.split("\n")) {
+    const from: RegExpMatchArray | null = line.match(FROM_INSTRUCTION);
+
+    if (from) {
+      current = {
+        from: (from[1] ?? "").toLowerCase(),
+        name: from[2] ? from[2].toLowerCase() : null,
+        body: "",
+      };
+      stages.push(current);
+      continue;
+    }
+
+    if (current) {
+      current.body += `${line}\n`;
+    }
+  }
+
+  return stages;
+};
+
+// The stage and every stage it is built FROM, nearest first.
+const stageAncestry: (
+  stages: Array<DockerfileStage>,
+  name: string,
+) => Array<DockerfileStage> = (
+  stages: Array<DockerfileStage>,
+  name: string,
+): Array<DockerfileStage> => {
+  const chain: Array<DockerfileStage> = [];
+  let next: string | null = name;
+
+  while (next !== null) {
+    const wanted: string = next;
+    const stage: DockerfileStage | undefined = stages.find(
+      (candidate: DockerfileStage) => {
+        return candidate.name === wanted;
+      },
+    );
+
+    if (!stage || chain.includes(stage)) {
+      break;
+    }
+
+    chain.push(stage);
+    next = stage.from;
+  }
+
+  return chain;
+};
+
 const listServiceImages: () => Array<ServiceImage> =
   (): Array<ServiceImage> => {
     const images: Array<ServiceImage> = [];
@@ -103,6 +194,13 @@ const listServiceImages: () => Array<ServiceImage> =
       const elseIndex: number = dockerfile.lastIndexOf("{{ else }}");
       const productionStanza: string =
         elseIndex === -1 ? dockerfile : dockerfile.slice(elseIndex);
+      const developmentIndex: number = dockerfile.indexOf(
+        DEVELOPMENT_BRANCH_START,
+      );
+      const productionDockerfile: string =
+        elseIndex === -1 || developmentIndex === -1
+          ? dockerfile
+          : dockerfile.slice(0, developmentIndex) + productionStanza;
 
       let startScript: string | null = null;
       const packageJsonPath: string = path.join(
@@ -120,6 +218,7 @@ const listServiceImages: () => Array<ServiceImage> =
       images.push({
         service: path.basename(directory),
         productionStanza,
+        productionDockerfile,
         startScript,
       });
     }
@@ -378,4 +477,194 @@ describe("Container boot configuration", () => {
       },
     );
   });
+
+  describe("images built as Community and Enterprise targets", () => {
+    /*
+     * The App builds both editions from one Dockerfile: `--target community`
+     * and `--target enterprise` (packages/App/Dockerfile.tpl). Docker does
+     * inherit USER, ENV and CMD from a parent stage, but that is exactly why
+     * the whole-stanza checks above cannot see a final stage that lost one of
+     * them: they match the instruction anywhere in the production branch. Each
+     * final stage is an image of its own, so each states its own boot
+     * configuration, and nothing the Community image is built from may copy
+     * ee/ in.
+     */
+    const stagesOf: (service: string) => Array<DockerfileStage> = (
+      service: string,
+    ): Array<DockerfileStage> => {
+      const image: ServiceImage | undefined = SERVICE_IMAGES.find(
+        (candidate: ServiceImage) => {
+          return candidate.service === service;
+        },
+      );
+
+      return image ? splitStages(image.productionDockerfile) : [];
+    };
+
+    const stageNamed: (
+      service: string,
+      name: string,
+    ) => DockerfileStage | undefined = (
+      service: string,
+      name: string,
+    ): DockerfileStage | undefined => {
+      return stagesOf(service).find((stage: DockerfileStage) => {
+        return stage.name === name;
+      });
+    };
+
+    const editionServices: Array<string> = SERVICE_IMAGES.filter(
+      (image: ServiceImage) => {
+        return splitStages(image.productionDockerfile).some(
+          (stage: DockerfileStage) => {
+            return (
+              stage.name !== null && EDITION_STAGE_NAMES.includes(stage.name)
+            );
+          },
+        );
+      },
+    ).map((image: ServiceImage) => {
+      return image.service;
+    });
+
+    const finalStages: Array<[string, string]> = editionServices.flatMap(
+      (service: string) => {
+        return EDITION_STAGE_NAMES.map((name: string): [string, string] => {
+          return [service, name];
+        });
+      },
+    );
+
+    test("the App is built this way, with exactly one stage per edition", () => {
+      expect(editionServices).toContain("App");
+
+      for (const name of EDITION_STAGE_NAMES) {
+        expect(
+          stagesOf("App").filter((stage: DockerfileStage) => {
+            return stage.name === name;
+          }),
+        ).toHaveLength(1);
+      }
+    });
+
+    test.each(editionServices)(
+      "%s: the community stage is last, so a build without --target is the Community Edition",
+      (service: string) => {
+        const stages: Array<DockerfileStage> = stagesOf(service);
+
+        expect(stages[stages.length - 1]?.name).toBe("community");
+      },
+    );
+
+    test.each(finalStages)(
+      "%s: the %s stage runs as the node user",
+      (service: string, name: string) => {
+        expect(stageNamed(service, name)?.body).toMatch(USER_NODE_INSTRUCTION);
+      },
+    );
+
+    test.each(finalStages)(
+      "%s: the %s stage sets TS_NODE_TRANSPILE_ONLY=1",
+      (service: string, name: string) => {
+        expect(stageNamed(service, name)?.body).toMatch(TRANSPILE_ONLY_ENV);
+      },
+    );
+
+    test.each(finalStages)(
+      "%s: the %s stage boots with CMD npm start",
+      (service: string, name: string) => {
+        const body: string = stageNamed(service, name)?.body ?? "";
+
+        expect(
+          CMD_NPM_START_EXEC_FORM.test(body) ||
+            CMD_NPM_START_SHELL_FORM.test(body),
+        ).toBe(true);
+      },
+    );
+
+    test.each(finalStages)(
+      "%s: the %s stage is type-checked at build time (npm run compile in its ancestry)",
+      (service: string, name: string) => {
+        const ancestry: Array<DockerfileStage> = stageAncestry(
+          stagesOf(service),
+          name,
+        );
+
+        expect(
+          ancestry.some((stage: DockerfileStage) => {
+            return RUN_COMPILE_INSTRUCTION.test(stage.body);
+          }),
+        ).toBe(true);
+      },
+    );
+
+    test.each(editionServices)(
+      "%s: nothing the community stage is built from copies ee/",
+      (service: string) => {
+        const ancestry: Array<DockerfileStage> = stageAncestry(
+          stagesOf(service),
+          "community",
+        );
+
+        expect(ancestry.length).toBeGreaterThan(1);
+        expect(
+          ancestry
+            .filter((stage: DockerfileStage) => {
+              return COPIES_ENTERPRISE_DIRECTORY.test(stage.body);
+            })
+            .map((stage: DockerfileStage) => {
+              return stage.name;
+            }),
+        ).toEqual([]);
+      },
+    );
+
+    test.each(editionServices)(
+      "%s: the enterprise stage's ancestry does copy ee/ (so the check above can fail)",
+      (service: string) => {
+        expect(
+          stageAncestry(stagesOf(service), "enterprise").some(
+            (stage: DockerfileStage) => {
+              return COPIES_ENTERPRISE_DIRECTORY.test(stage.body);
+            },
+          ),
+        ).toBe(true);
+      },
+    );
+
+    test.each(editionServices)(
+      "%s: the enterprise image is the community build plus ee/ (they share its layers)",
+      (service: string) => {
+        const communityParent: string | undefined = stageNamed(
+          service,
+          "community",
+        )?.from;
+        const enterpriseAncestry: Array<string | null> = stageAncestry(
+          stagesOf(service),
+          "enterprise",
+        ).map((stage: DockerfileStage) => {
+          return stage.name;
+        });
+
+        expect(communityParent).toBeDefined();
+        expect(enterpriseAncestry).toContain(communityParent);
+      },
+    );
+
+    test.each(editionServices)(
+      "%s: only the enterprise stage sets ONEUPTIME_EDITION, to enterprise",
+      (service: string) => {
+        expect(stageNamed(service, "enterprise")?.body).toMatch(
+          SETS_ENTERPRISE_EDITION_MARKER,
+        );
+        expect(
+          stageAncestry(stagesOf(service), "community").some(
+            (stage: DockerfileStage) => {
+              return SETS_ONEUPTIME_EDITION.test(stage.body);
+            },
+          ),
+        ).toBe(false);
+      },
+    );
+  });
 });

package/Tests/Server/Infrastructure/E2EClickHouseFixtureAccess.test.ts

@@ -68,9 +68,13 @@ const CLICKHOUSE_HTTP_CONTAINER_PORT: string = "8123";
  * The step that runs the suite:
  * `docker compose --project-directory . -f Scripts/Dev/docker-compose.dev.yml up ... e2e`,
  * or `... -f packages/E2E/docker-compose.e2e.yml up ... e2e` for the release image.
+ *
+ * `run --rm e2e <command>` counts too: the enterprise e2e jobs run one named
+ * suite per phase, which needs `run` to override the image's default CMD. Those
+ * suites use the same fixtures, so they need the same published port.
  */
 const RUNS_E2E_SERVICE: RegExp =
-  /docker compose\s[^\n]*-f (?:Scripts\/Dev\/docker-compose\.dev|packages\/E2E\/docker-compose\.e2e)\.yml\s+up\b[^\n]*\se2e\b/;
+  /docker compose\s[^\n]*-f (?:Scripts\/Dev\/docker-compose\.dev|packages\/E2E\/docker-compose\.e2e)\.yml\s+(?:up|run)\b[^\n]*\se2e\b/;
 const UP_SUBCOMMAND: RegExp = /\sup(?:\s|$)/;
 const DOWN_SUBCOMMAND: RegExp = /\sdown(?:\s|$)/;
 const ROOT_COMPOSE_FILE_FLAG: RegExp = /-f docker-compose\.yml\s/;

package/Tests/Server/Infrastructure/Postgres/AddConfigurableRuleCriteriaMigration.test.ts

@@ -25,6 +25,9 @@ const NEVER_MATCH_PATTERN: string = "(?!)";
 const RULE_MODELS_INTRODUCED_AFTER_MIGRATION: ReadonlyArray<string> = [
   // 1793100000000-SloProductOverhaul
   "ServiceLevelObjectiveMonitorRule",
+  // 1794100000000-AddSloLabelAndOwnerRules
+  "ServiceLevelObjectiveLabelRule",
+  "ServiceLevelObjectiveOwnerRule",
 ];
 
 type IsCoveredByMigrationFunction = (modelName: string) => boolean;