refactor: add initial refactor work

Author: cabljac

integration_test/package-lock.json

@@ -20,9 +20,12 @@
     "@types/jest": "^29.5.11",
     "@types/js-yaml": "^4.0.9",
     "@types/node-fetch": "^2.6.11",
+    "chalk": "^5.5.0",
+    "dotenv": "^17.2.1",
     "jest": "^29.7.0",
     "p-limit": "^6.2.0",
     "p-retry": "^6.2.1",
-    "ts-jest": "^29.1.1"
+    "ts-jest": "^29.1.1",
+    "zod": "^4.0.17"
   }
 }

integration_test/package.json

@@ -6,10 +6,10 @@ import client from "firebase-tools";
 import { getRuntimeDelegate } from "firebase-tools/lib/deploy/functions/runtimes/index.js";
 import { detectFromPort } from "firebase-tools/lib/deploy/functions/runtimes/discovery/index.js";
 import setup from "./setup.js";
-import { loadEnv } from "./utils.js";
+import * as dotenv from "dotenv";
 import { deployFunctionsWithRetry, postCleanup } from "./deployment-utils.js";
 
-loadEnv();
+dotenv.config();
 
 let {
   DEBUG,
@@ -49,21 +49,26 @@ if (!["node", "python"].includes(TEST_RUNTIME)) {
   process.exit(1);
 }
 
-if (!FIREBASE_ADMIN && TEST_RUNTIME === "node") {
-  FIREBASE_ADMIN = "^12.0.0";
-}
+// TypeScript type guard to ensure TEST_RUNTIME is the correct type
+const validRuntimes = ["node", "python"] as const;
+type ValidRuntime = (typeof validRuntimes)[number];
+const runtime: ValidRuntime = TEST_RUNTIME as ValidRuntime;
 
-if (!FIREBASE_ADMIN && TEST_RUNTIME === "python") {
+if (!FIREBASE_ADMIN && runtime === "node") {
+  FIREBASE_ADMIN = "^12.0.0";
+} else if (!FIREBASE_ADMIN && runtime === "python") {
   FIREBASE_ADMIN = "6.5.0";
+} else if (!FIREBASE_ADMIN) {
+  throw new Error("FIREBASE_ADMIN is not set");
 }
 
-setup(TEST_RUNTIME as "node" | "python", TEST_RUN_ID, NODE_VERSION, FIREBASE_ADMIN!);
+setup(runtime, TEST_RUN_ID, NODE_VERSION, FIREBASE_ADMIN);
 
 const config = {
   projectId: PROJECT_ID,
   projectDir: process.cwd(),
   sourceDir: `${process.cwd()}/functions`,
-  runtime: TEST_RUNTIME === "node" ? "nodejs18" : "python311",
+  runtime: runtime === "node" ? "nodejs18" : "python311",
 };
 
 console.log("Firebase config created: ");
@@ -175,28 +180,6 @@ async function deployModifiedFunctions(): Promise<void> {
   }
 }
 
-async function removeDeployedFunctions(functionNames: string[]): Promise<void> {
-  console.log("Removing deployed functions...");
-
-  try {
-    const options = {
-      project: config.projectId,
-      config: "./firebase.json",
-      debug: true,
-      nonInteractive: true,
-      force: true,
-    };
-
-    console.log("Removing functions with id:", TEST_RUN_ID);
-    await client.functions.delete(functionNames, options);
-
-    console.log("Deployed functions have been removed.");
-  } catch (err) {
-    console.error("Error removing deployed functions. Exiting.", err);
-    process.exit(1);
-  }
-}
-
 function cleanFiles(): void {
   console.log("Cleaning files...");
   const functionsDir = "functions";

integration_test/run.ts

@@ -1,6 +1,6 @@
 import setup from "./setup";
-import { loadEnv } from "./utils";
+import * as dotenv from "dotenv";
 
-loadEnv();
+dotenv.config();
 
 setup("node", "local", "18", "^12.0.0");

integration_test/setup-local.ts

@@ -0,0 +1,65 @@
+import fs from "fs";
+import { logError, logCleanup } from "./logger.js";
+
+export function cleanFiles(testRunId: string): void {
+  logCleanup("Cleaning files...");
+  const functionsDir = "functions";
+  process.chdir(functionsDir); // go to functions
+  try {
+    const files = fs.readdirSync(".");
+    files.forEach((file) => {
+      // For Node
+      if (file.match(`firebase-functions-${testRunId}.tgz`)) {
+        fs.rmSync(file);
+      }
+      // For Python
+      if (file.match(`firebase_functions.tar.gz`)) {
+        fs.rmSync(file);
+      }
+      if (file.match("package.json")) {
+        fs.rmSync(file);
+      }
+      if (file.match("requirements.txt")) {
+        fs.rmSync(file);
+      }
+      if (file.match("firebase-debug.log")) {
+        fs.rmSync(file);
+      }
+      if (file.match("functions.yaml")) {
+        fs.rmSync(file);
+      }
+    });
+
+    fs.rmSync("lib", { recursive: true, force: true });
+    fs.rmSync("venv", { recursive: true, force: true });
+  } catch (error) {
+    logError("Error occurred while cleaning files:", error as Error);
+  }
+
+  process.chdir("../"); // go back to integration_test
+}
+
+export async function handleCleanUp(client: any, testRunId: string): Promise<void> {
+  logCleanup("Cleaning up...");
+  try {
+    // Import postCleanup from deployment-utils
+    const { postCleanup } = await import("../deployment-utils.js");
+    await postCleanup(client, testRunId);
+  } catch (err) {
+    logError("Error during post-cleanup:", err as Error);
+    // Don't throw here to ensure files are still cleaned
+  }
+  cleanFiles(testRunId);
+}
+
+export function gracefulShutdown(cleanupFn: () => Promise<void>): void {
+  console.log("SIGINT received...");
+  cleanupFn()
+    .then(() => {
+      process.exit(1);
+    })
+    .catch((error) => {
+      logError("Error during graceful shutdown:", error);
+      process.exit(1);
+    });
+}

integration_test/src/cleanup.ts

@@ -0,0 +1,142 @@
+import * as z from "zod/mini";
+
+// Load English locale for better error messages
+z.config(z.locales.en());
+
+export interface TestConfig {
+  projectId: string;
+  testRunId: string;
+  runtime: "node" | "python";
+  nodeVersion: string;
+  firebaseAdmin: string;
+  region: string;
+  storageRegion: string;
+  debug?: string;
+  databaseUrl: string;
+  storageBucket: string;
+  firebaseAppId: string;
+  firebaseMeasurementId: string;
+  firebaseAuthDomain: string;
+  firebaseApiKey: string;
+  googleAnalyticsApiSecret: string;
+}
+
+// Environment validation schema
+const environmentSchema = z.object({
+  PROJECT_ID: z.string().check(z.minLength(1, "PROJECT_ID is required")),
+  DATABASE_URL: z.string().check(z.minLength(1, "DATABASE_URL is required")),
+  STORAGE_BUCKET: z.string().check(z.minLength(1, "STORAGE_BUCKET is required")),
+  FIREBASE_APP_ID: z.string().check(z.minLength(1, "FIREBASE_APP_ID is required")),
+  FIREBASE_MEASUREMENT_ID: z.string().check(z.minLength(1, "FIREBASE_MEASUREMENT_ID is required")),
+  FIREBASE_AUTH_DOMAIN: z.string().check(z.minLength(1, "FIREBASE_AUTH_DOMAIN is required")),
+  FIREBASE_API_KEY: z.string().check(z.minLength(1, "FIREBASE_API_KEY is required")),
+  GOOGLE_ANALYTICS_API_SECRET: z
+    .string()
+    .check(z.minLength(1, "GOOGLE_ANALYTICS_API_SECRET is required")),
+  TEST_RUNTIME: z.enum(["node", "python"]),
+  NODE_VERSION: z.optional(z.string()),
+  FIREBASE_ADMIN: z.optional(z.string()),
+  REGION: z.optional(z.string()),
+  STORAGE_REGION: z.optional(z.string()),
+  DEBUG: z.optional(z.string()),
+});
+
+/**
+ * Validates that all required environment variables are set and have valid values.
+ * Exits the process with code 1 if validation fails.
+ */
+export function validateEnvironment(): void {
+  try {
+    environmentSchema.parse(process.env);
+  } catch (error) {
+    console.error("Environment validation failed:");
+    if (error && typeof error === "object" && "errors" in error) {
+      const zodError = error as { errors: Array<{ path: string[]; message: string }> };
+      zodError.errors.forEach((err) => {
+        console.error(`  ${err.path.join(".")}: ${err.message}`);
+      });
+    } else {
+      console.error("Unexpected error during environment validation:", error);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Loads and validates environment configuration, returning a typed config object.
+ * @returns TestConfig object with all validated environment variables
+ */
+export function loadConfig(): TestConfig {
+  // Validate environment first to ensure all required variables are set
+  const validatedEnv = environmentSchema.parse(process.env);
+
+  // TypeScript type guard to ensure TEST_RUNTIME is the correct type
+  const validRuntimes = ["node", "python"] as const;
+  type ValidRuntime = (typeof validRuntimes)[number];
+  const runtime: ValidRuntime = validatedEnv.TEST_RUNTIME;
+
+  let firebaseAdmin = validatedEnv.FIREBASE_ADMIN;
+  if (!firebaseAdmin && runtime === "node") {
+    firebaseAdmin = "^12.0.0";
+  } else if (!firebaseAdmin && runtime === "python") {
+    firebaseAdmin = "6.5.0";
+  } else if (!firebaseAdmin) {
+    throw new Error("FIREBASE_ADMIN is not set");
+  }
+
+  const testRunId = `t${Date.now()}`;
+
+  return {
+    projectId: validatedEnv.PROJECT_ID,
+    testRunId,
+    runtime,
+    nodeVersion: validatedEnv.NODE_VERSION ?? "18",
+    firebaseAdmin,
+    region: validatedEnv.REGION ?? "us-central1",
+    storageRegion: validatedEnv.STORAGE_REGION ?? "us-central1",
+    debug: validatedEnv.DEBUG,
+    databaseUrl: validatedEnv.DATABASE_URL,
+    storageBucket: validatedEnv.STORAGE_BUCKET,
+    firebaseAppId: validatedEnv.FIREBASE_APP_ID,
+    firebaseMeasurementId: validatedEnv.FIREBASE_MEASUREMENT_ID,
+    firebaseAuthDomain: validatedEnv.FIREBASE_AUTH_DOMAIN,
+    firebaseApiKey: validatedEnv.FIREBASE_API_KEY,
+    googleAnalyticsApiSecret: validatedEnv.GOOGLE_ANALYTICS_API_SECRET,
+  };
+}
+
+/**
+ * Creates Firebase configuration object for deployment.
+ * @param config - The test configuration object
+ * @returns Firebase configuration object
+ */
+export function createFirebaseConfig(config: TestConfig) {
+  return {
+    projectId: config.projectId,
+    projectDir: process.cwd(),
+    sourceDir: `${process.cwd()}/functions`,
+    runtime: config.runtime === "node" ? "nodejs18" : "python311",
+  };
+}
+
+/**
+ * Creates environment configuration for function deployment.
+ * @param config - The test configuration object
+ * @returns Environment configuration object
+ */
+export function createEnvironmentConfig(config: TestConfig) {
+  const firebaseConfig = {
+    databaseURL: config.databaseUrl,
+    projectId: config.projectId,
+    storageBucket: config.storageBucket,
+  };
+
+  return {
+    DEBUG: config.debug,
+    FIRESTORE_PREFER_REST: "true",
+    GCLOUD_PROJECT: config.projectId,
+    FIREBASE_CONFIG: JSON.stringify(firebaseConfig),
+    REGION: config.region,
+    STORAGE_REGION: config.storageRegion,
+  };
+}