@vaharoni/devops 1.0.47

package/src/libs/k8s-image-config.ts

@@ -0,0 +1,165 @@
+import { CommandExecutor } from "../cli/common";
+import { getWorkspace } from "./discovery";
+import { imageConfigMap } from "./k8s-constants";
+import { kubectlCommand, upsertConfigMapCommand } from "./k8s-helpers";
+
+//= config map
+
+type ImageConfigMap = {
+  version?: string;
+  scale?: string;
+}
+
+function updateImageConfigMap(monorepoEnv: string, image: string, data = {}) {
+  const imageConfigMapName = imageConfigMap(image);
+  return new CommandExecutor(
+    upsertConfigMapCommand(monorepoEnv, imageConfigMapName, data)
+  ).exec();
+}
+
+function getImageConfigMap(monorepoEnv: string, image: string): ImageConfigMap {
+  const imageConfigMapName = imageConfigMap(image);
+  const { statusCode, stdout } = new CommandExecutor(
+    kubectlCommand(
+      `get configmap ${imageConfigMapName} -o jsonpath='{.data}'`,
+      { monorepoEnv }
+    ),
+    { quiet: true }
+  ).exec({ asObject: true });
+  if (statusCode !== 0 || !stdout) return {};
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    console.error(
+      `Error parsing config map data for ${image}. Received: ${stdout}`
+    );
+    process.exit(1);
+  }
+}
+
+function deserializeImageConfigMapKey<T>(monorepoEnv: string, image: string, key: keyof ImageConfigMap): Record<string, T> {
+  const value = getImageConfigMap(monorepoEnv, image)[key];
+  if (!value) return {};
+  try {
+    return JSON.parse(value);
+  }
+  catch {
+    console.error(`Error parsing config map data for ${image} for key ${key}. Received: ${value}`);
+    process.exit(1);
+  }
+}
+
+// = Version
+
+export function getImageVersion(monorepoEnv: string, image: string) {
+  const data = getImageConfigMap(monorepoEnv, image);
+  return data.version;
+}
+
+export function setImageVersion(
+  monorepoEnv: string,
+  image: string,
+  version: string
+) {
+  const data = getImageConfigMap(monorepoEnv, image);
+  return updateImageConfigMap(monorepoEnv, image, { ...data, version });
+}
+
+export function deleteImageVersion(monorepoEnv: string, image: string) {
+  const { version, ...rest } = getImageConfigMap(monorepoEnv, image);
+  return updateImageConfigMap(monorepoEnv, image, rest);
+}
+
+// = Scale
+
+function setK8sScale(
+  monorepoEnv: string,
+  workspaceName: string,
+  replicaCount: number
+) {
+  const workspaceData = getWorkspace(workspaceName);
+  const serviceName = workspaceData.packageDataEntries.find(x => x.deployment?.service_name)?.deployment?.service_name;
+  if (!serviceName) {
+    console.error(
+      `Workspace ${workspaceName} must have a service_name defined in its deployment key in package.json. Skipping.`
+    );
+    return false;
+  }
+  new CommandExecutor(
+    kubectlCommand(
+      `scale deployment ${workspaceName} --replicas=${replicaCount}`,
+      { monorepoEnv }
+    )
+  ).exec();
+  return true;
+}
+
+// Returns the old version prior to setting
+export function setWorkspaceScale(
+  monorepoEnv: string,
+  image: string,
+  workspaceName: string,
+  replicaCount: number
+) {
+  const workspaceData = getWorkspace(workspaceName);
+  if (!workspaceData.packageDataEntries.find(x => x.deployment)) {
+    console.error(`Workspace ${workspaceName} does not have deployment data.`);
+    process.exit(1);
+  }
+  if (replicaCount < 1) {
+    console.error("Replica count must be at least 1.");
+    process.exit(1);
+  }
+  const { scale: _scale, ...rest } = getImageConfigMap(monorepoEnv, image);
+  const parsedScale = deserializeImageConfigMapKey<number>(monorepoEnv, image, "scale");
+  const isApplicable = setK8sScale(monorepoEnv, workspaceName, replicaCount);
+  if (!isApplicable) return;
+  updateImageConfigMap(monorepoEnv, image, {
+    ...rest,
+    scale: JSON.stringify({
+      ...parsedScale,
+      [workspaceName]: replicaCount,
+    }),
+  });
+  return parsedScale?.[workspaceName] ?? 1;
+}
+
+export function getWorkspaceScale(monorepoEnv: string, image: string): Record<string, number>;
+export function getWorkspaceScale(monorepoEnv: string, image: string, workspaceName: string): number;
+export function getWorkspaceScale(
+  monorepoEnv: string,
+  image: string,
+  /** If not provided, returns all workspaces */
+  workspaceName?: string
+) {
+  const parsedScale = deserializeImageConfigMapKey<number>(monorepoEnv, image, "scale");
+  if (!workspaceName) return parsedScale ?? {};
+  const _ensureWorkspace = getWorkspace(workspaceName);
+  return parsedScale?.[workspaceName] ?? 1;
+}
+
+// /** Returns the old scale prior to deletion */
+export function resetWorkspaceScale(
+  monorepoEnv: string,
+  image: string,
+  workspaceName?: string
+) {
+  const { scale: _scale, ...rest } = getImageConfigMap(monorepoEnv, image);
+  const parsedScale = deserializeImageConfigMapKey<number>(monorepoEnv, image, "scale");
+  if (!workspaceName) {
+    updateImageConfigMap(monorepoEnv, image, rest);
+    Object.entries(parsedScale ?? {})
+      .filter(([_name, scale]) => Number(scale) > 1)
+      .forEach(([name, _scale]) => {
+        setK8sScale(monorepoEnv, name, 1);
+      });
+    return parsedScale;
+  } else {
+    const oldScale = parsedScale?.[workspaceName] ?? 1;
+    const newScale = { ...parsedScale };
+    delete newScale[workspaceName];
+    updateImageConfigMap(monorepoEnv, image, { ...rest, scale: JSON.stringify(newScale) });
+    setK8sScale(monorepoEnv, workspaceName, 1);
+    return oldScale;
+  }
+}

package/src/libs/k8s-job-waiter.ts

@@ -0,0 +1,124 @@
+import { CommandExecutor } from "../cli/common";
+import { envToNamespace } from "./k8s-constants";
+import { kubectlCommand } from "./k8s-helpers";
+
+const POLL_INTERVAL_SEC = 1;
+
+export type JobStatuses = Record<
+  string,
+  { status: "success" | "failure" | "timeout"; elapsed: number; error?: string }
+>;
+
+class K8sJobWaiter {
+  timeoutInMs: number;
+  namespace: string;
+  jobStatuses: JobStatuses;
+
+  constructor(public monorepoEnv: string, timeoutInS: number) {
+    this.namespace = envToNamespace(monorepoEnv);
+    this.jobStatuses = {};
+    this.timeoutInMs = timeoutInS * 1000;
+  }
+
+  async pollJob(job: string) {
+    const startTime = Date.now();
+
+    while (true) {
+      const res = await this.fetchStatus(job);
+      const elapsed = Date.now() - startTime;
+
+      if (res.failure > 0) {
+        const error = await this.fetchError(job);
+        this.jobStatuses[job] = { status: "failure", elapsed, error };
+        return;
+      }
+
+      if (res.success > 0) {
+        this.jobStatuses[job] = { status: "success", elapsed };
+        return;
+      }
+
+      if (elapsed >= this.timeoutInMs) {
+        this.jobStatuses[job] = { status: "timeout", elapsed };
+        return;
+      }
+
+      await new Promise((res) => setTimeout(res, POLL_INTERVAL_SEC * 1000));
+    }
+  }
+
+  private async fetchStatus(job: string) {
+    const result = new CommandExecutor(
+      kubectlCommand(
+        `get job ${job} -o jsonpath='{.status.failed},{.status.succeeded}'`,
+        { namespace: this.namespace }
+      )
+    ).exec();
+    const [failure, success] = result.split(",").map((x: string) => Number(x));
+    return { failure, success };
+  }
+
+  private async fetchError(job: string) {
+    try {
+      const podName = new CommandExecutor(
+        kubectlCommand(`get pod -l job-name=${job} -o name`, {
+          namespace: this.namespace,
+        })
+      ).exec();
+      const logs = new CommandExecutor(
+        kubectlCommand(`logs ${podName}`, { namespace: this.namespace })
+      ).exec();
+      return logs;
+    } catch (e) {
+      console.log("Error fetching logs for job", { job, e });
+      return `<COULD NOT FETCH ERROR FOR ${job}>`;
+    }
+  }
+}
+
+export async function k8sJobWaiter(
+  monorepoEnv: string,
+  timeoutInS: number,
+  jobs: string[]
+) {
+  const waiter = new K8sJobWaiter(monorepoEnv, timeoutInS);
+  await Promise.all(jobs.map((job) => waiter.pollJob(job)));
+  return waiter.jobStatuses;
+}
+
+export function printJobStatuses(statuses: JobStatuses) {
+  console.log("Statuses:");
+  Object.entries(statuses).forEach(([job, statusRecord]) => {
+    console.log(
+      `${job}: ${statusRecord.status} ${
+        Math.round((statusRecord.elapsed / 1000) * 100) / 100
+      }s`
+    );
+  });
+  console.log();
+
+  Object.entries(statuses)
+    .filter(([_, statusRecord]) => statusRecord.status === "failure")
+    .forEach(([job, statusRecord]) => {
+      console.error(`Error for ${job}:`);
+      console.error(statusRecord.error);
+      console.error();
+    });
+
+  const failures = Object.entries(statuses).filter(([_, statusRecord]) =>
+    ["failure", "timeout"].includes(statusRecord.status)
+  );
+
+  if (failures.length > 0) {
+    console.error();
+    console.error(
+      `Some jobs did not succeed: ${failures.map(([job, _]) => job).join(", ")}`
+    );
+    console.error();
+    process.exit(1);
+  }
+
+  Object.entries(statuses).forEach(([job, statusRecord]) => {
+    console.log(`${job}: ${statusRecord.status}`);
+  });
+}

package/src/libs/k8s-namespace.ts

@@ -0,0 +1,41 @@
+import { CommandExecutor } from "../cli/common";
+import { envToNamespace, secretName } from "./k8s-constants";
+import { kubectlCommand, patchSecretKeyCommand } from "./k8s-helpers";
+import { randomBytes } from "crypto";
+
+export const BASE_SECRET_KEY = 'baseSecret';
+
+export function checkEnvSetup(monorepoEnv: string) {
+  const namespace = envToNamespace(monorepoEnv);
+  const exitCode = new CommandExecutor(
+    kubectlCommand(`get ns ${namespace}`)
+  ).exec({
+    onlyStatusCode: true,
+  });
+  return exitCode === 0;
+}
+
+export function createNamespace(monorepoEnv: string) {
+  new CommandExecutor(kubectlCommand(`create ns ${envToNamespace(monorepoEnv)}`)).exec();
+}
+
+export function createEmptyEnvSecret(monorepoEnv: string) {
+  const cmd = kubectlCommand(`create secret generic ${secretName()}`, {namespace: envToNamespace(monorepoEnv)});
+  new CommandExecutor(cmd).exec();
+}
+
+export function patchBaseSecret(monorepoEnv: string) {
+  const { fullCommand, redactedCommand } = patchSecretKeyCommand(
+    monorepoEnv, 
+    secretName(), 
+    BASE_SECRET_KEY, 
+    randomBytes(32).toString('hex')
+  );
+  new CommandExecutor(fullCommand, { quiet: true, redactedCommand }).exec();
+}
+
+export function deleteNamespace(monorepoEnv: string) {
+  const cmd = kubectlCommand(`delete ns ${envToNamespace(monorepoEnv)}`);
+  new CommandExecutor(cmd).exec();
+}
+

package/src/libs/k8s-redis.ts

@@ -0,0 +1,31 @@
+import { CommandExecutor } from "../cli/common";
+import { kubectlCommand } from "./k8s-helpers";
+
+export function getRedisList() {
+  const cmd = kubectlCommand(`get pods -l app.kubernetes.io/name=redis -A`);
+  const res = new CommandExecutor(cmd, { quiet: true }).exec();
+  if (!res) return null;
+  return res;
+}
+
+export function getRedisPassword(namespace: string) {
+  const cmd = kubectlCommand(`get secrets/${namespace} -o jsonpath="{.data}"`, {
+    namespace,
+  });
+  const res = new CommandExecutor(cmd, { quiet: true }).exec();
+  if (!res) return null;
+  try {
+    const resJson = JSON.parse(res);
+    const password = atob(resJson["redis-password"]);
+    return { password };
+  } catch {
+    return null;
+  }
+}
+
+export function establishRedisTunnel(namespace: string, port: string) {
+  const cmd = kubectlCommand(`port-forward svc/${namespace}-master ${port}:6379`, {
+    namespace,
+  });
+  new CommandExecutor(cmd).spawn();
+}

package/src/libs/k8s-secrets-manager.ts

@@ -0,0 +1,79 @@
+import { CommandExecutor } from "../cli/common";
+import { secretName } from "./k8s-constants";
+import { kubectlCommand, patchSecretKeyCommand } from "./k8s-helpers";
+
+// This env file should not be used in local development
+const SECRET_FILE_NAME = "env_json";
+
+// Basic commands (L1)
+
+// Override the secret value with the new value
+function execUpdateSecret(
+  monorepoEnv: string,
+  secretValue: Record<string, string>
+) {
+  const { fullCommand, redactedCommand } = patchSecretKeyCommand(monorepoEnv, secretName(), SECRET_FILE_NAME, JSON.stringify(secretValue));
+  new CommandExecutor(fullCommand, { quiet: true, redactedCommand }).exec();
+}
+
+function getSecret(monorepoEnv: string, keys: string[] = []) {
+  // Dots in jsonpath can only be accessed with a \ prefix
+  const escapedSecretFileName = SECRET_FILE_NAME.replaceAll(".", "\\.");
+  // prettier-ignore
+  const cmd = kubectlCommand(`get secrets/${secretName()} -o jsonpath="{.data['${escapedSecretFileName}']}"`, { monorepoEnv });
+  const res = new CommandExecutor(cmd, { quiet: true }).exec();
+  if (!res) return {};
+  const resJson: Record<string, string> = JSON.parse(atob(res));
+  if (!keys || keys.length === 0) return resJson;
+  return Object.fromEntries(
+    keys.filter((x) => resJson[x]).map((x) => [x, resJson[x]])
+  );
+}
+
+// Combined commands (L2)
+
+function updateSecret(monorepoEnv: string, vars: Record<string, string>) {
+  if (!vars || Object.keys(vars).length === 0) {
+    console.error(
+      "Keys-value pairs to set must be provided, e.g. KEY1=val1 KEY2=val2"
+    );
+    process.exit(1);
+  }
+  const current = getSecret(monorepoEnv);
+  const newVars = { ...current, ...vars };
+  execUpdateSecret(monorepoEnv, newVars);
+}
+
+function deleteSecretKeys(monorepoEnv: string, keys: string[] = []) {
+  if (!keys || keys.length === 0) {
+    console.error("Keys to delete must be provided");
+    process.exit(1);
+  }
+  const secretValue = getSecret(monorepoEnv);
+  keys.forEach((key) => delete secretValue[key]);
+  execUpdateSecret(monorepoEnv, secretValue);
+}
+
+//= Interface (L3)
+
+export function getMonorepoSecret(monorepoEnv: string, keys: string[] = []) {
+  const value = getSecret(monorepoEnv, keys);
+  return Object.entries(value)
+    .map((pair) => pair.join("="))
+    .join("\n");
+}
+
+/** E.g.: setMonorepoSecret('staging', ['KEY1=val1', 'KEY2=val2']) */
+export function setMonorepoSecret(monorepoEnv: string, pairs: string[] = []) {
+  const pairsObj = Object.fromEntries(
+    pairs.map((x) => {
+      const [key, ...values] = x.split("=");
+      return [key, values.join("=")];
+    })
+  );
+  updateSecret(monorepoEnv, pairsObj);
+}
+
+export function deleteMonorepoSecret(monorepoEnv: string, keys: string[] = []) {
+  deleteSecretKeys(monorepoEnv, keys);
+}

package/src/libs/validate-env.spec.ts

@@ -0,0 +1,223 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  CombinedEnvValidator,
+  DotEnvParser,
+  SingleEnvValidator,
+} from './validate-env';
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function withEnvVars(envVars: Record<string, string>, callbackFn: Function) {
+  Object.entries(envVars).forEach(([key, value]) => (process.env[key] = value));
+  try {
+    callbackFn();
+  } finally {
+    Object.keys(envVars).forEach((key) => delete process.env[key]);
+  }
+}
+
+describe('SingleEnvValidator', () => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function createSubject(yamlContent: any) {
+    const subject = new SingleEnvValidator('dummy-path.yaml');
+    vi.spyOn(subject, '_readFile').mockReturnValue(yamlContent);
+    return subject;
+  }
+
+  describe('invalid yaml files', () => {
+    it('contains parsingError when not an array', () => {
+      const subject = createSubject({ DUMMY1: 'optional' });
+      subject.validate();
+      expect(subject.parsingError).toContain(
+        'env.yaml file must resolve to an array',
+      );
+    });
+
+    it('contains parsingError when an object has multiple keys', () => {
+      const subject = createSubject([
+        { DUMMY1: 'optional', DUMMY2: 'optional' },
+      ]);
+      subject.validate();
+      expect(subject.parsingError).toContain(
+        'every object in env.yaml must have one key. Error near: DUMMY1',
+      );
+    });
+
+    it('contains parsingError when an object has invalid requirement', () => {
+      const subject = createSubject([{ DUMMY1: 'optttttttional' }]);
+      subject.validate();
+      expect(subject.parsingError).toContain('invalid value for DUMMY1');
+    });
+  });
+
+  describe('valid yaml file', () => {
+    const validYaml = [
+      'TEST_ENV_MANDATORY',
+      { TEST_ENV_OPTIONAL: 'optional' },
+      { TEST_ENV_BOOLEAN1: 'boolean' },
+      { TEST_ENV_BOOLEAN2: 'boolean' },
+      { TEST_ENV_ENUM1: ['option1', 'option2'] },
+      { TEST_ENV_ENUM2: ['option1', 'option2'] },
+    ];
+
+    const defaultValues = {
+      TEST_ENV_MANDATORY: 'some_value',
+      TEST_ENV_BOOLEAN1: 'true',
+      TEST_ENV_BOOLEAN2: 'false',
+      TEST_ENV_ENUM1: 'option1',
+      TEST_ENV_ENUM2: 'option2',
+    };
+
+    function withEnvVarsHelper(
+      envVars: Partial<
+        Record<keyof typeof defaultValues, string> & {
+          TEST_ENV_OPTIONAL: string;
+        }
+      >,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+      callbackFn: Function,
+    ) {
+      envVars = { ...defaultValues, ...envVars };
+      withEnvVars(envVars, callbackFn);
+    }
+
+    it('works when all env vars are provided as expected', () => {
+      const subject = createSubject(validYaml);
+      withEnvVarsHelper({}, () => subject.validate());
+      expect(subject.parsingError).toEqual(undefined);
+      expect(subject.errors).toEqual({});
+    });
+
+    it('works when an optional varilable is provided', () => {
+      const subject = createSubject(validYaml);
+      withEnvVarsHelper({ TEST_ENV_OPTIONAL: 'value' }, () =>
+        subject.validate(),
+      );
+      expect(subject.parsingError).toEqual(undefined);
+      expect(subject.errors).toEqual({});
+    });
+
+    it('contains errors when mandatory is not provided', () => {
+      const subject = createSubject(validYaml);
+      withEnvVarsHelper({ TEST_ENV_MANDATORY: '' }, () => subject.validate());
+      expect(subject.parsingError).toEqual(undefined);
+      expect(Object.keys(subject.errors)).toEqual(['TEST_ENV_MANDATORY']);
+    });
+
+    it('contains errors when boolean is different than true or false', () => {
+      const subject = createSubject(validYaml);
+      withEnvVarsHelper({ TEST_ENV_BOOLEAN1: 'value' }, () =>
+        subject.validate(),
+      );
+      expect(subject.parsingError).toEqual(undefined);
+      expect(Object.keys(subject.errors)).toEqual(['TEST_ENV_BOOLEAN1']);
+    });
+
+    it('contains errors when enum is different than provided options', () => {
+      const subject = createSubject(validYaml);
+      withEnvVarsHelper({ TEST_ENV_ENUM1: 'option3' }, () =>
+        subject.validate(),
+      );
+      expect(subject.parsingError).toEqual(undefined);
+      expect(Object.keys(subject.errors)).toEqual(['TEST_ENV_ENUM1']);
+    });
+  });
+});
+
+describe('DotEnvParser', () => {
+  function createSubject(text: string) {
+    const subject = new DotEnvParser('dummy-path.env');
+    vi.spyOn(subject, '_readFile').mockReturnValue(text);
+    return subject;
+  }
+
+  it('works, taking into account comments and ignoring empty lines', () => {
+    const subject = createSubject(`
+        
+    # Ignored
+    TEST1=hello
+
+    TEST2=world   # also ignored
+
+
+    TEST3 = spaces should not normally be allowed in .env   # so the parser is not strict
+
+    `);
+    subject.parse();
+    expect(subject.keys).toEqual(['TEST1', 'TEST2', 'TEST3']);
+  });
+});
+
+describe('CombinedEnvValidator', () => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function createSubject(yamlContent: any[], dotEnvContent: string[]) {
+    const yamlPaths = yamlContent.map((_, i) => `dummy-yaml-${i}`);
+    const dotEnvPaths = dotEnvContent.map((_, i) => `dummy-dotenv-${i}`);
+
+    const yamlValidators = yamlContent.map((content, i) => {
+      const validator = new SingleEnvValidator(yamlPaths[i]);
+      vi.spyOn(validator, '_readFile').mockReturnValue(content);
+      return validator;
+    });
+
+    const dotEnvParsers = dotEnvContent.map((content, i) => {
+      const parser = new DotEnvParser(dotEnvPaths[i]);
+      vi.spyOn(parser, '_readFile').mockReturnValue(content);
+      return parser;
+    });
+
+    const subject = new CombinedEnvValidator(yamlPaths, dotEnvPaths);
+    vi.spyOn(subject, '_loadYamlFiles').mockImplementation(
+      () => (subject.yamlValidators = yamlValidators),
+    );
+    vi.spyOn(subject, '_loadDotEnvFiles').mockImplementation(
+      () => (subject.dotEnvParsers = dotEnvParsers),
+    );
+    return subject;
+  }
+
+  it('works when no errors and no warnings', () => {
+    const yaml1 = ['TEST_ENV1', 'TEST_ENV2'];
+    const yaml2 = [{ TEST_ENV3: 'optional' }];
+    const dotEnv1 = 'TEST_ENV1=hi';
+    const dotEnv2 = 'TEST_ENV2=bye';
+
+    const subject = createSubject([yaml1, yaml2], [dotEnv1, dotEnv2]);
+    withEnvVars({ TEST_ENV1: 'hi', TEST_ENV2: 'bye' }, () =>
+      subject.validate(),
+    );
+
+    expect(subject.warnings).toEqual([]);
+    expect(subject.errors).toEqual({});
+  });
+
+  it('emits warnings', () => {
+    const yaml1 = ['TEST_ENV1', 'TEST_ENV2'];
+    const yaml2 = [{ TEST_ENV3: 'optional' }];
+    const dotEnv1 = 'TEST_ENV1=hi';
+    const dotEnv2 = 'TEST_ENV2=bye';
+    const dotEnv3 = 'TEST_ENV4=boo';
+
+    const subject = createSubject([yaml1, yaml2], [dotEnv1, dotEnv2, dotEnv3]);
+    withEnvVars({ TEST_ENV1: 'hi', TEST_ENV2: 'bye' }, () =>
+      subject.validate(),
+    );
+
+    expect(subject.warnings.length).toEqual(1);
+    expect(subject.warnings[0]).toContain('TEST_ENV4');
+    expect(subject.errors).toEqual({});
+  });
+
+  it('emits errors', () => {
+    vi.spyOn(process, 'exit').mockReturnValue(undefined as never);
+    const yaml1 = ['TEST_ENV1', 'TEST_ENV2'];
+    const yaml2 = [{ TEST_ENV3: 'optional' }];
+    const dotEnv1 = 'TEST_ENV1=hi';
+
+    const subject = createSubject([yaml1, yaml2], [dotEnv1]);
+    withEnvVars({ TEST_ENV1: 'hi' }, () => subject.validate());
+    expect(process.exit).toHaveBeenCalledWith(1);
+
+    expect(subject.warnings).toEqual([]);
+    expect(Object.keys(subject.errors)).toEqual(['TEST_ENV2']);
+  });
+});