refactoring of the cypress.config.ts

Author: kstekovi

config/containers/database.ts

@@ -0,0 +1,28 @@
+import { PullPolicy, GenericContainer, StartedTestContainer, Wait } from "testcontainers";
+import { DatabaseConfig } from "../interfaces";
+import { handleContainerError } from "../helpers";
+
+export function startDatabaseContainer(
+  config: DatabaseConfig,
+  startedContainersMap: Map<string, StartedTestContainer>,
+): Promise<StartedTestContainer> {
+  const containerBuilder = new GenericContainer(config.image)
+    .withPullPolicy(PullPolicy.alwaysPull())
+    .withName(config.name)
+    .withNetworkAliases(config.name)
+    .withNetworkMode(config.networkName)
+    .withExposedPorts(config.port)
+    .withEnvironment(config.environmentProperties)
+    .withWaitStrategy(Wait.forLogMessage(new RegExp(config.waitLogMessage)));
+
+  return containerBuilder
+    .start()
+    .then((container) => {
+      console.log(config.successMessage);
+      startedContainersMap.set(config.containerMapKey, container);
+      return container;
+    })
+    .catch((err: unknown) => {
+      throw handleContainerError(err);
+    });
+}

config/containers/index.ts

@@ -0,0 +1,2 @@
+export * from "./database";
+export * from "./wildfly";

config/containers/wildfly.ts

@@ -0,0 +1,126 @@
+import axios from "axios";
+import { GenericContainer, StartedTestContainer } from "testcontainers";
+import { findAPortNotInUse } from "portscanner";
+import {
+  WILDFLY_MANAGEMENT_PORT,
+  WILDFLY_PORT_RANGE,
+  DEFAULT_WILDFLY_CONFIG,
+  WILDFLY_READY_TIMEOUT_MS,
+  WILDFLY_POLL_INTERVAL_MS,
+  JBOSS_CLI_PATH,
+  MANAGEMENT_INTERFACE_ADDRESS,
+} from "../../cypress.config";
+import { WildflyManagementResponse } from "../interfaces";
+import { buildLocalhostUrl } from "../helpers";
+
+export function pollWildflyState(managementApi: string, container: StartedTestContainer): Promise<string> {
+  const startTime = new Date().getTime();
+  return new Promise<string>((resolve, reject) => {
+    const interval = setInterval(() => {
+      if (new Date().getTime() - startTime > WILDFLY_READY_TIMEOUT_MS) {
+        clearInterval(interval);
+        reject(new Error("Timeout waiting for WildFly to start"));
+      }
+      axios
+        .post(managementApi, {
+          operation: "read-attribute",
+          name: "server-state",
+        })
+        .then((response: WildflyManagementResponse) => {
+          if (response.data.result === "running") {
+            clearInterval(interval);
+            const wildflyServer = buildLocalhostUrl(container.getMappedPort(WILDFLY_MANAGEMENT_PORT));
+            resolve(wildflyServer);
+          }
+        })
+        .catch(() => {
+          console.log("WildFly server is not ready yet");
+        });
+    }, WILDFLY_POLL_INTERVAL_MS);
+  });
+}
+
+export function executeJBossCLI(
+  container: StartedTestContainer,
+  managementPort: number,
+  command: string,
+): Promise<string> {
+  return container
+    .exec([
+      `/bin/sh`,
+      `-c`,
+      `${JBOSS_CLI_PATH} --connect --controller=localhost:${managementPort} --command="${command}"`,
+    ])
+    .then((result) => result.output);
+}
+
+export function configureWildflyNetworkMode(
+  wildfly: GenericContainer,
+  configuration: string,
+  useHostMode: boolean,
+  networkName?: string,
+): Promise<{ portOffset: number }> {
+  if (useHostMode) {
+    console.log("host mode");
+    return findAPortNotInUse(WILDFLY_PORT_RANGE.min, WILDFLY_PORT_RANGE.max).then((freePort) => {
+      const portOffset = freePort - WILDFLY_PORT_RANGE.min;
+      wildfly
+        .withNetworkMode("host")
+        .withCommand([
+          "-c",
+          configuration || DEFAULT_WILDFLY_CONFIG,
+          `-Djboss.socket.binding.port-offset=${portOffset.toString()}`,
+          "-Djboss.node.name=localhost",
+        ] as string[]);
+      return { portOffset };
+    });
+  } else {
+    console.log(`default network mode, network name: ${networkName}`);
+    wildfly
+      .withNetworkMode(networkName!)
+      .withNetworkAliases("wildfly")
+      .withExposedPorts(WILDFLY_MANAGEMENT_PORT)
+      .withCommand(["-c", configuration || DEFAULT_WILDFLY_CONFIG] as string[]);
+    return Promise.resolve({ portOffset: 0 });
+  }
+}
+
+export function configureWildflyPostStart(
+  container: StartedTestContainer,
+  halPort: string,
+  useHostMode: boolean,
+  managementPort?: number,
+): Promise<string> {
+  if (useHostMode) {
+    const effectiveManagementPort = managementPort!;
+    return executeJBossCLI(
+      container,
+      effectiveManagementPort,
+      `/core-service=management/management-interface=http-interface:list-add(name=allowed-origins,value=${buildLocalhostUrl(Number(halPort))}`,
+    )
+      .then(() => executeJBossCLI(container, effectiveManagementPort, "reload"))
+      .then(() => executeJBossCLI(container, effectiveManagementPort, "read-attribute server-state"))
+      .then((output) => {
+        if (output.includes("running")) {
+          return buildLocalhostUrl(effectiveManagementPort);
+        }
+        throw new Error("WildFly did not reach running state");
+      });
+  } else {
+    const managementApi = buildLocalhostUrl(container.getMappedPort(WILDFLY_MANAGEMENT_PORT), "/management");
+
+    return axios
+      .post(managementApi, {
+        operation: "list-add",
+        address: MANAGEMENT_INTERFACE_ADDRESS,
+        name: "allowed-origins",
+        value: buildLocalhostUrl(Number(halPort)),
+      })
+      .then(() =>
+        axios.post(managementApi, {
+          operation: "reload",
+        }),
+      )
+      .then(() => pollWildflyState(managementApi, container));
+  }
+}

config/helpers/container-helpers.ts

@@ -0,0 +1,14 @@
+import { hostname } from "os";
+import { WILDFLY_MANAGEMENT_PORT, LOCALHOST_IP } from "../../cypress.config";
+
+export function calculateManagementPort(portOffset: number): number {
+  return portOffset + WILDFLY_MANAGEMENT_PORT;
+}
+
+export function getHostnameMapping(): Array<{ host: string; ipAddress: string }> {
+  return [{ host: hostname(), ipAddress: LOCALHOST_IP }];
+}
+
+export function buildKeycloakStartCommand(port: number): string[] {
+  return ["start-dev", "--db=dev-mem", `--http-port=${port.toString()}`, "--import-realm"];
+}

config/helpers/error-handler.ts

@@ -0,0 +1,4 @@
+export function handleContainerError(err: unknown): Error {
+  console.log(err);
+  return err instanceof Error ? err : new Error(JSON.stringify(err));
+}

config/helpers/index.ts

@@ -0,0 +1,3 @@
+export * from "./error-handler";
+export * from "./url-builder";
+export * from "./container-helpers";

config/helpers/url-builder.ts

@@ -0,0 +1,4 @@
+export function buildLocalhostUrl(port: number, path?: string): string {
+  const baseUrl = `http://localhost:${port}`;
+  return path ? `${baseUrl}${path}` : baseUrl;
+}

config/interfaces.ts

@@ -0,0 +1,51 @@
+import { Environment } from "testcontainers/build/types";
+
+export interface DatabaseConfig {
+  name: string;
+  image: string;
+  port: number;
+  waitLogMessage: string;
+  environmentProperties: Environment;
+  networkName: string;
+  containerMapKey: string;
+  successMessage: string;
+}
+
+export interface WildflyManagementResponse {
+  data: {
+    result: string;
+  };
+}
+
+export interface AxiosErrorResponse {
+  response: {
+    data: string;
+  };
+}
+
+export interface StartWildflyContainerParams {
+  name: string;
+  configuration: string;
+  useNetworkHostMode?: boolean;
+}
+
+export interface StartKeycloakContainerParams {
+  name: string;
+}
+
+export interface StartDatabaseContainerParams {
+  name: string;
+  environmentProperties: Environment;
+}
+
+export interface ExecuteInContainerParams {
+  containerName: string;
+  command: string;
+}
+
+export interface ExecuteCliParams {
+  managementApi: string;
+  operation: string;
+  address: string[];
+  [key: string]: unknown;
+}

config/tasks/cli-tasks.ts

@@ -0,0 +1,18 @@
+import axios from "axios";
+import { ExecuteCliParams, AxiosErrorResponse } from "../interfaces";
+
+export function createExecuteCli() {
+  return ({ managementApi, operation, address, ...args }: ExecuteCliParams) => {
+    return axios
+      .post(managementApi, {
+        operation,
+        address,
+        ...args,
+      })
+      .then((response) => response.data as unknown)
+      .catch((err: AxiosErrorResponse) => {
+        console.log(err);
+        throw new Error(err.response.data);
+      });
+  };
+}

config/tasks/database-tasks.ts

@@ -0,0 +1,89 @@
+import { StartedTestContainer } from "testcontainers";
+import {
+  DEFAULT_POSTGRES_IMAGE,
+  DEFAULT_MYSQL_IMAGE,
+  DEFAULT_MARIADB_IMAGE,
+  DEFAULT_SQLSERVER_IMAGE,
+  POSTGRES_PORT,
+  MYSQL_PORT,
+  MARIADB_PORT,
+  SQLSERVER_PORT,
+  POSTGRES_STARTED_MSG,
+  MYSQL_STARTED_MSG,
+  MARIADB_STARTED_MSG,
+  SQLSERVER_STARTED_MSG,
+} from "../../cypress.config";
+import { StartDatabaseContainerParams } from "../interfaces";
+import { startDatabaseContainer } from "../containers";
+
+export function createPostgresContainer(startedContainers: Map<string, StartedTestContainer>, networkName: string) {
+  return ({ name, environmentProperties }: StartDatabaseContainerParams) => {
+    return startDatabaseContainer(
+      {
+        name,
+        image: process.env.POSTGRES_IMAGE || DEFAULT_POSTGRES_IMAGE,
+        port: POSTGRES_PORT,
+        waitLogMessage: POSTGRES_STARTED_MSG,
+        environmentProperties,
+        networkName,
+        containerMapKey: "postgres",
+        successMessage: "PostgreSQL started successfully",
+      },
+      startedContainers,
+    );
+  };
+}
+
+export function createMysqlContainer(startedContainers: Map<string, StartedTestContainer>, networkName: string) {
+  return ({ name, environmentProperties }: StartDatabaseContainerParams) => {
+    return startDatabaseContainer(
+      {
+        name,
+        image: process.env.MYSQL_IMAGE || DEFAULT_MYSQL_IMAGE,
+        port: MYSQL_PORT,
+        waitLogMessage: MYSQL_STARTED_MSG,
+        environmentProperties,
+        networkName,
+        containerMapKey: "mysql",
+        successMessage: "MySQL started successfully",
+      },
+      startedContainers,
+    );
+  };
+}
+
+export function createMariadbContainer(startedContainers: Map<string, StartedTestContainer>, networkName: string) {
+  return ({ name, environmentProperties }: StartDatabaseContainerParams) => {
+    return startDatabaseContainer(
+      {
+        name,
+        image: process.env.MARIADB_IMAGE || DEFAULT_MARIADB_IMAGE,
+        port: MARIADB_PORT,
+        waitLogMessage: MARIADB_STARTED_MSG,
+        environmentProperties,
+        networkName,
+        containerMapKey: "mariadb",
+        successMessage: "Mariadb started successfully",
+      },
+      startedContainers,
+    );
+  };
+}
+
+export function createSqlserverContainer(startedContainers: Map<string, StartedTestContainer>, networkName: string) {
+  return ({ name, environmentProperties }: StartDatabaseContainerParams) => {
+    return startDatabaseContainer(
+      {
+        name,
+        image: process.env.MSSQL_IMAGE || DEFAULT_SQLSERVER_IMAGE,
+        port: SQLSERVER_PORT,
+        waitLogMessage: SQLSERVER_STARTED_MSG,
+        environmentProperties,
+        networkName,
+        containerMapKey: "sqlserver",
+        successMessage: "SQL server started successfully",
+      },
+      startedContainers,
+    );
+  };
+}