adding initial client support

Author: jlsherrill

.github/workflows/stageTestAction.yml

@@ -51,7 +51,8 @@ jobs:
           echo "PROXY=$PROXY" >> .env
           echo "TOKEN=apple" >> .env
           echo "CI=true" >> .env
-
+          echo "ORG_ID_1=$STAGE_ORG_ID" >> .env
+          echo "ACTIVATION_KEY_1=$STAGE_ACTIVATION_KEY" >> .env
       - name: Set up Node.js
         uses: actions/setup-node@v2
         with:

example.env

@@ -3,7 +3,13 @@
 
 USER1USERNAME="contentPlaywrightUserAdmin" # Required
 USER1PASSWORD="" # Required (Ask Andrew if needed)
+ORG_ID_1="1234" #org id to register for registration tests
+ACTIVATION_KEY_1="MyKey" #activation Key used for testing
+
+PROD=""
 BASE_URL="https://stage.foo.redhat.com:1337" # Required
 PROXY="https://something.foo.redhat.com:5432" # Required in CI only or if locally running against stage
 CI="" # This is set to true for CI jobs, if checking for CI do  !!process.env.CI
 TOKEN="" # This is handled programmatically.
+
+#DOCKER_SOCKET="/tmp/podman.sock"

package.json

@@ -16,6 +16,8 @@
     "@types/node": "^22.9.0"
   },
   "dependencies": {
+    "@types/dockerode": "^3.3.34",
+    "dockerode": "^4.0.4",
     "dotenv": "^16.4.7",
     "github-actions-ctrf": "^0.0.58",
     "playwright-ctrf-json-reporter": "^0.0.18"

readme.md

@@ -14,6 +14,26 @@ This stores your local credentials
 
 yarn get-tests
 
+# Setup container api for testing with clients
+
+## Podman
+
+As your user, run podman to serve the api:
+```
+podman system service -t 0 /tmp/podman.sock
+```
+
+Uncomment the DOCKER_SOCKET option in the .env file:
+```
+DOCKER_SOCKET="/tmp/podman.sock"
+```
+
+## Docker
+
+* ensure the docker service is running
+* ensure your user is part of the 'docker' user group
+
+
 # Option 1 Run local:
 
 For local testing, make sure your front-end/backend servers are running and accessible, then:

tests/helpers/containers.tsx

@@ -0,0 +1,128 @@
+import Dockerode, { Container } from "dockerode";
+import { PassThrough } from "stream";
+import { finished } from "stream/promises";
+
+var Docker = require("dockerode");
+
+const util = require("util");
+const exec = util.promisify(require("child_process").exec);
+
+const dockerHost = () => {
+  return process.env.DOCKER_SOCKET!;
+};
+
+const docker = (): Dockerode => {
+  return new Docker({ socketPath: dockerHost() });
+};
+
+export const startContainer = async (
+  containerName: string,
+  imageName: string
+) => {
+  console.log("starting container " + containerName);
+  const container = await docker().createContainer({
+    Image: imageName,
+    name: containerName,
+  });
+  return container?.start();
+};
+
+/*
+ * starts a container and kills one if it already exists with the same name
+ */
+export const startNewContainer = async (
+  containerName: string,
+  imageName: string
+) => {
+  await killContainer(containerName);
+  return await startContainer(containerName, imageName);
+  //await waitForContainer(containerName)
+};
+
+async function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+const waitForContainer = async (name: string): Promise<Container | void> => {
+  var container = await getContainer(name);
+  var waited = 10;
+  while (container == undefined && waited > 0) {
+    waited -= 1;
+    await sleep(1000);
+    container = await getContainer(name);
+  }
+  return container;
+};
+
+const getContainerInfo = async (name: string) => {
+  const containers = await docker().listContainers({ all: true });
+
+  for (var contInfo of containers) {
+    if (contInfo.Names.includes("/" + name)) {
+      return contInfo;
+    }
+  }
+  return undefined;
+};
+
+const getContainer = async (name: string): Promise<Container | void> => {
+  const cInfo = await getContainerInfo(name);
+  if (cInfo !== undefined) {
+    return docker().getContainer(cInfo.Id);
+  }
+};
+
+export const killContainer = async (containerName: string) => {
+  const info = await getContainerInfo(containerName);
+  const c = await getContainer(containerName);
+  if (info?.State == "running") {
+    await c?.kill();
+  }
+  return c?.remove();
+};
+
+interface ExecReturn {
+  stdout?: string;
+  stderr?: string;
+  exitCode?: number | null;
+}
+
+// Runs a non-interactive command and returns stdout, stderr, and the exit code
+export const runCommand = async (
+  containerName: string,
+  command: string[]
+): Promise<ExecReturn | void> => {
+  console.log("Running " + command + " on " + containerName);
+  const c = await getContainer(containerName);
+  const exec = await c?.exec({
+    Cmd: command,
+    AttachStdout: true,
+    AttachStderr: true,
+  });
+  if (exec == undefined) {
+    return undefined;
+  }
+
+  const execStream = await exec?.start({});
+  if (execStream == undefined) {
+    return undefined;
+  }
+
+  const stdoutStream = new PassThrough();
+  const stderrStream = new PassThrough();
+
+  docker().modem.demuxStream(execStream, stdoutStream, stderrStream);
+
+  execStream.resume();
+  await finished(execStream);
+
+  const stderr = stderrStream.read() as Buffer | undefined;
+  const stdout = stdoutStream.read() as Buffer | undefined;
+  const execInfo = await exec.inspect();
+
+  return {
+    exitCode: execInfo.ExitCode,
+    stderr: stderr?.toString(),
+    stdout: stdout?.toString(),
+  };
+};

tests/helpers/loginHelpers.tsx

@@ -84,7 +84,8 @@ export const throwIfMissingEnvVariables = () => {
     "USER1USERNAME",
     "USER1PASSWORD",
     "BASE_URL",
-    "PROXY",
+    "ORG_ID_1",
+    "ACTIVATION_KEY_1",
   ];
 
   if (!process.env.PROD) ManditoryEnvVariables.push("PROXY");

tests/helpers/rhsmClient.tsx

@@ -0,0 +1,75 @@
+import { URL } from "url";
+import { killContainer, runCommand, startNewContainer } from "./containers";
+
+export type OSVersion = "rhel9" | "rhel8";
+
+const RemoteImages = {
+  rhel9: "quay.io/jlsherri/client-rhel9",
+  rhel8: "localhost/client-rhel9",
+};
+
+export class RHSMClient {
+  name: string;
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  async Boot(version: OSVersion) {
+    return startNewContainer(this.name, RemoteImages[version]);
+  }
+
+  async ConfigureForStage() {
+    return runCommand(this.name, stageConfigureCommand());
+  }
+
+  async Register(activationKey?: string, orgId?: string) {
+    if (!process.env.PROD) {
+      await this.ConfigureForStage();
+    }
+
+    if (activationKey == undefined) {
+      activationKey = process.env.ACTIVATION_KEY_1 || "COULD_NOT_FIND_KEY";
+    }
+    if (activationKey == undefined) {
+      orgId = process.env.ORG_ID_1 || "COULD_NOT_FIND_ORG_ID";
+    }
+
+    return runCommand(this.name, [
+      "subscription-manager",
+      "register",
+      "--activationkey",
+      activationKey,
+      "--org=" + orgId,
+      "--name",
+      this.name,
+    ]);
+  }
+
+  async Unregister() {
+    return runCommand(this.name, ["subscription-manager", "unregister"]);
+  }
+
+  async Destroy() {
+    const cmd = await this.Unregister();
+    console.log(cmd?.stdout);
+    console.log(cmd?.stderr);
+    return killContainer(this.name);
+  }
+}
+
+const stageConfigureCommand = (): string[] => {
+  var command = [
+    "subscription-manager",
+    "config",
+    "--server.hostname=subscription.rhsm.stage.redhat.com",
+    "--server.port=443",
+    "--server.prefix=/subscription",
+    "--server.insecure=0",
+  ];
+  if (process.env.PROXY !== undefined) {
+    const url = new URL(process.env.PROXY);
+    command.push("--server.proxy_hostname=" + url.hostname);
+    command.push("--server.proxy_port=" + url.port);
+  }
+  return command;
+};