Add a manifest file next to each test fixture. (#7332)

Author: yuchenshi

.prettierignore

@@ -6,3 +6,6 @@
 /scripts/webframeworks-deploy-tests/angular/**
 /scripts/webframeworks-deploy-tests/nextjs/**
 /src/frameworks/docs/**
+
+# Intentionally invalid YAML file:
+/src/test/fixtures/extension-yamls/invalid/extension.yaml

scripts/emulator-tests/unzipEmulators.spec.ts

@@ -4,35 +4,42 @@ import * as path from "path";
 import { unzip } from "../../src/unzip";
 import { DownloadDetails } from "../../src/emulator/downloadableEmulators";
 import { Client } from "../../src/apiv2";
-const fixturesDir = path.resolve(__dirname, "dev");
-
-const ZIP_FIXTURES_PATH = path.join(fixturesDir, "zip-files");
-const ZIP_TEMPORARY_PATH = path.join(ZIP_FIXTURES_PATH, "temp");
+import { tmpdir } from "os";
 
 describe("unzipEmulators", () => {
+  let tempDir: string;
+
+  before(async () => {
+    tempDir = await fs.promises.mkdtemp(path.join(tmpdir(), "firebasetest-"));
+  });
+
+  after(async () => {
+    await fs.promises.rmdir(tempDir, { recursive: true });
+  });
+
   it("should unzip a ui emulator zip file", async () => {
     const [uiVersion, uiRemoteUrl] = [
       DownloadDetails.ui.version,
       DownloadDetails.ui.opts.remoteUrl,
     ];
 
-    const uiZipPath = path.join(ZIP_TEMPORARY_PATH, `ui-v${uiVersion}.zip`);
+    const uiZipPath = path.join(tempDir, `ui-v${uiVersion}.zip`);
 
-    await fs.promises.mkdir(ZIP_TEMPORARY_PATH, { recursive: true });
+    await fs.promises.mkdir(tempDir, { recursive: true });
     if (!(await fs.promises.access(uiZipPath).catch(() => false))) {
       await downloadFile(uiRemoteUrl, uiZipPath);
     }
 
-    await unzip(uiZipPath, path.join(ZIP_TEMPORARY_PATH, "ui"));
+    await unzip(uiZipPath, path.join(tempDir, "ui"));
 
-    const files = await fs.promises.readdir(ZIP_TEMPORARY_PATH);
+    const files = await fs.promises.readdir(tempDir);
     expect(files).to.include("ui");
 
-    const uiFiles = await fs.promises.readdir(path.join(ZIP_TEMPORARY_PATH, "ui"));
+    const uiFiles = await fs.promises.readdir(path.join(tempDir, "ui"));
     expect(uiFiles).to.include("client");
     expect(uiFiles).to.include("server");
 
-    const serverFiles = await fs.promises.readdir(path.join(ZIP_TEMPORARY_PATH, "ui", "server"));
+    const serverFiles = await fs.promises.readdir(path.join(tempDir, "ui", "server"));
     expect(serverFiles).to.include("server.mjs");
   }).timeout(10000);
 
@@ -42,28 +49,28 @@ describe("unzipEmulators", () => {
       DownloadDetails.pubsub.opts.remoteUrl,
     ];
 
-    const pubsubZipPath = path.join(ZIP_TEMPORARY_PATH, `pubsub-emulator-v${pubsubVersion}.zip`);
+    const pubsubZipPath = path.join(tempDir, `pubsub-emulator-v${pubsubVersion}.zip`);
 
     if (!(await fs.promises.access(pubsubZipPath).catch(() => false))) {
       await downloadFile(pubsubRemoteUrl, pubsubZipPath);
     }
 
-    await unzip(pubsubZipPath, path.join(ZIP_TEMPORARY_PATH, "pubsub"));
+    await unzip(pubsubZipPath, path.join(tempDir, "pubsub"));
 
-    const files = await fs.promises.readdir(ZIP_TEMPORARY_PATH);
+    const files = await fs.promises.readdir(tempDir);
     expect(files).to.include("pubsub");
 
-    const pubsubFiles = await fs.promises.readdir(path.join(ZIP_TEMPORARY_PATH, "pubsub"));
+    const pubsubFiles = await fs.promises.readdir(path.join(tempDir, "pubsub"));
     expect(pubsubFiles).to.include("pubsub-emulator");
 
     const pubsubEmulatorFiles = await fs.promises.readdir(
-      path.join(ZIP_TEMPORARY_PATH, "pubsub", "pubsub-emulator"),
+      path.join(tempDir, "pubsub", "pubsub-emulator"),
     );
     expect(pubsubEmulatorFiles).to.include("bin");
     expect(pubsubEmulatorFiles).to.include("lib");
 
     const binFiles = await fs.promises.readdir(
-      path.join(ZIP_TEMPORARY_PATH, "pubsub", "pubsub-emulator", "bin"),
+      path.join(tempDir, "pubsub", "pubsub-emulator", "bin"),
     );
     expect(binFiles).to.include("cloud-pubsub-emulator");
   }).timeout(10000);

src/archiveDirectory.spec.ts

@@ -3,13 +3,12 @@ import { expect } from "chai";
 import { FirebaseError } from "./error";
 
 import { archiveDirectory } from "./archiveDirectory";
-
-const SOME_FIXTURE_DIRECTORY = resolve(__dirname, "./test/fixtures/config-imports");
+import { FIXTURE_DIR } from "./test/fixtures/config-imports";
 
 describe("archiveDirectory", () => {
   it("should archive happy little directories", async () => {
-    const result = await archiveDirectory(SOME_FIXTURE_DIRECTORY, {});
-    expect(result.source).to.equal(SOME_FIXTURE_DIRECTORY);
+    const result = await archiveDirectory(FIXTURE_DIR, {});
+    expect(result.source).to.equal(FIXTURE_DIR);
     expect(result.size).to.be.greaterThan(0);
   });
 

src/config.spec.ts

@@ -2,17 +2,17 @@ import { expect } from "chai";
 import * as path from "path";
 
 import { Config } from "./config";
-
-function fixtureDir(name: string): string {
-  return path.resolve(__dirname, "./test/fixtures/" + name);
-}
+import { FIREBASE_JSON_PATH as VALID_CONFIG_PATH } from "./test/fixtures/valid-config";
+import { FIXTURE_DIR as SIMPLE_CONFIG_DIR } from "./test/fixtures/config-imports";
+import { FIXTURE_DIR as DUP_TOP_LEVEL_CONFIG_DIR } from "./test/fixtures/dup-top-level";
 
 describe("Config", () => {
   describe("#load", () => {
     it("should load a cjson file when configPath is specified", () => {
+      const cwd = __dirname;
       const config = Config.load({
-        cwd: __dirname,
-        configPath: "./test/fixtures/valid-config/firebase.json",
+        cwd,
+        configPath: path.relative(cwd, VALID_CONFIG_PATH),
       });
       expect(config).to.not.be.null;
       if (config) {
@@ -23,19 +23,19 @@ describe("Config", () => {
 
   describe("#parseFile", () => {
     it("should load a cjson file", () => {
-      const config = new Config({}, { cwd: fixtureDir("config-imports") });
+      const config = new Config({}, { cwd: SIMPLE_CONFIG_DIR });
       expect(config.parseFile("hosting", "hosting.json").public).to.equal(".");
     });
 
     it("should error out for an unknown file", () => {
-      const config = new Config({}, { cwd: fixtureDir("config-imports") });
+      const config = new Config({}, { cwd: SIMPLE_CONFIG_DIR });
       expect(() => {
         config.parseFile("hosting", "i-dont-exist.json");
       }).to.throw("Imported file i-dont-exist.json does not exist");
     });
 
     it("should error out for an unrecognized extension", () => {
-      const config = new Config({}, { cwd: fixtureDir("config-imports") });
+      const config = new Config({}, { cwd: SIMPLE_CONFIG_DIR });
       expect(() => {
         config.parseFile("hosting", "unsupported.txt");
       }).to.throw("unsupported.txt is not of a supported config file type");
@@ -49,7 +49,7 @@ describe("Config", () => {
     });
 
     it("should prevent top-level key duplication", () => {
-      const config = new Config({ rules: "rules.json" }, { cwd: fixtureDir("dup-top-level") });
+      const config = new Config({ rules: "rules.json" }, { cwd: DUP_TOP_LEVEL_CONFIG_DIR });
       expect(config.materialize("rules")).to.deep.equal({ ".read": true });
     });
   });

src/extensions/emulator/specHelper.spec.ts

@@ -1,10 +1,11 @@
 import { expect } from "chai";
-import * as path from "path";
 
 import * as specHelper from "./specHelper";
 import { Resource } from "../types";
 import { FirebaseError } from "../../error";
 import { Runtime } from "../../deploy/functions/runtimes/supported";
+import { FIXTURE_DIR as MINIMAL_EXT_DIR } from "../../test/fixtures/extension-yamls/minimal";
+import { FIXTURE_DIR as HELLO_WORLD_EXT_DIR } from "../../test/fixtures/extension-yamls/hello-world";
 
 const testResource: Resource = {
   name: "test-resource",
@@ -25,7 +26,7 @@ describe("readExtensionYaml", () => {
   }[] = [
     {
       desc: "should read a minimal extension.yaml",
-      directory: path.resolve(__dirname, "../../test/fixtures/extension-yamls/minimal"),
+      directory: MINIMAL_EXT_DIR,
       expected: {
         apis: [],
         contributors: [],
@@ -46,7 +47,7 @@ describe("readExtensionYaml", () => {
     },
     {
       desc: "should read a hello-world extension.yaml",
-      directory: path.resolve(__dirname, "../../test/fixtures/extension-yamls/hello-world"),
+      directory: HELLO_WORLD_EXT_DIR,
       expected: {
         apis: [],
         billingRequired: true,

src/extensions/localHelper.spec.ts

@@ -1,17 +1,13 @@
 import { expect } from "chai";
 import * as fs from "fs-extra";
 import * as yaml from "yaml";
-import { resolve } from "path";
 import * as sinon from "sinon";
 
 import * as localHelper from "./localHelper";
 import { FirebaseError } from "../error";
-
-const EXT_FIXTURE_DIRECTORY = resolve(__dirname, "../test/fixtures/sample-ext");
-const EXT_PREINSTALL_FIXTURE_DIRECTORY = resolve(
-  __dirname,
-  "../test/fixtures/sample-ext-preinstall",
-);
+import { FIXTURE_DIR as EXT_FIXTURE_DIRECTORY } from "../test/fixtures/extension-yamls/sample-ext";
+import { FIXTURE_DIR as EXT_PREINSTALL_FIXTURE_DIRECTORY } from "../test/fixtures/extension-yamls/sample-ext-preinstall";
+import { FIXTURE_DIR as INVALID_EXT_DIRECTORY } from "../test/fixtures/extension-yamls/invalid";
 
 describe("localHelper", () => {
   const sandbox = sinon.createSandbox();
@@ -36,16 +32,8 @@ describe("localHelper", () => {
     });
 
     describe("with an invalid YAML file", () => {
-      beforeEach(() => {
-        sandbox.stub(fs, "readFileSync").returns(`name: foo\nunknownkey\nother: value`);
-      });
-
-      afterEach(() => {
-        sandbox.restore();
-      });
-
       it("should return a rejected promise with a useful error if extension.yaml is invalid", async () => {
-        await expect(localHelper.getLocalExtensionSpec(EXT_FIXTURE_DIRECTORY)).to.be.rejectedWith(
+        await expect(localHelper.getLocalExtensionSpec(INVALID_EXT_DIRECTORY)).to.be.rejectedWith(
           FirebaseError,
           /YAML Error.+Implicit keys need to be on a single line.+line 2.+/,
         );

src/hosting/config.spec.ts

@@ -1,12 +1,12 @@
 import { expect } from "chai";
-import * as path from "path";
 import { FirebaseError } from "../error";
 import { HostingConfig, HostingMultiple, HostingSingle } from "../firebaseConfig";
 
 import * as config from "./config";
 import { HostingOptions } from "./options";
 import { cloneDeep } from "../utils";
 import { setEnabled } from "../experiments";
+import { FIREBASE_JSON_PATH, FIXTURE_DIR } from "../test/fixtures/simplehosting";
 
 function options(
   hostingConfig: HostingConfig,
@@ -25,8 +25,8 @@ function options(
         return targetsToSites?.[name] || [];
       },
     },
-    cwd: path.resolve(__dirname, "../test/fixtures/simplehosting"),
-    configPath: path.resolve(__dirname, "../test/fixtures/simplehosting/firebase.json"),
+    cwd: FIXTURE_DIR,
+    configPath: FIREBASE_JSON_PATH,
     ...base,
   };
 }

src/listFiles.spec.ts

@@ -1,12 +1,13 @@
 import { expect } from "chai";
-import { resolve } from "path";
 
 import { listFiles } from "./listFiles";
+import { FIXTURE_DIR } from "./test/fixtures/ignores";
 
 describe("listFiles", () => {
   // for details, see the file structure and firebase.json in test/fixtures/ignores
   it("should ignore firebase-debug.log, specified ignores, and nothing else", () => {
-    const fileNames = listFiles(resolve(__dirname, "./test/fixtures/ignores"), [
+    const fileNames = listFiles(FIXTURE_DIR, [
+      "index.ts",
       "**/.*",
       "firebase.json",
       "ignored.txt",
@@ -16,9 +17,10 @@ describe("listFiles", () => {
   });
 
   it("should allow us to not specify additional ignores", () => {
-    const fileNames = listFiles(resolve(__dirname, "./test/fixtures/ignores"));
+    const fileNames = listFiles(FIXTURE_DIR);
     expect(fileNames.sort()).to.have.members([
       ".hiddenfile",
+      "index.ts",
       "firebase.json",
       "ignored.txt",
       "ignored/deeper/index.txt",

src/profileReport.spec.ts

@@ -1,19 +1,16 @@
 import { expect } from "chai";
 
-import * as path from "path";
 import * as stream from "stream";
 import { extractReadableIndex, formatNumber, ProfileReport } from "./profileReport";
+import { SAMPLE_INPUT_PATH, SAMPLE_OUTPUT_PATH } from "./test/fixtures/profiler-data";
 
 function combinerFunc(obj1: any, obj2: any): any {
   return { count: obj1.count + obj2.count };
 }
 
-const fixturesDir = path.resolve(__dirname, "./test/fixtures");
-
 function newReport() {
-  const input = path.resolve(fixturesDir, "profiler-data/sample.json");
   const throwAwayStream = new stream.PassThrough();
-  return new ProfileReport(input, throwAwayStream, {
+  return new ProfileReport(SAMPLE_INPUT_PATH, throwAwayStream, {
     format: "JSON",
     isFile: false,
     collapse: true,
@@ -24,7 +21,7 @@ function newReport() {
 describe("profilerReport", () => {
   it("should correctly generate a report", () => {
     const report = newReport();
-    const output = require(path.resolve(fixturesDir, "profiler-data/sample-output.json"));
+    const output = require(SAMPLE_OUTPUT_PATH);
     return expect(report.generate()).to.eventually.deep.equal(output);
   });
 

src/rc.spec.ts

@@ -1,15 +1,14 @@
 import { expect } from "chai";
 import * as path from "path";
 import { RC, loadRC, RCData } from "./rc";
-
-const fixturesDir = path.resolve(__dirname, "./test/fixtures");
+import { CONFLICT_RC_DIR, FIREBASE_JSON_PATH, INVALID_RC_DIR } from "./test/fixtures/fbrc";
 
 const EMPTY_DATA: RCData = { projects: {}, targets: {}, etags: {}, dataconnectEmulatorConfig: {} };
 
 describe("RC", () => {
   describe(".load", () => {
     it("should load from nearest project directory", () => {
-      const result = loadRC({ cwd: path.resolve(fixturesDir, "fbrc/conflict") });
+      const result = loadRC({ cwd: CONFLICT_RC_DIR });
       expect(result.projects.default).to.eq("top");
     });
 
@@ -19,12 +18,13 @@ describe("RC", () => {
     });
 
     it("should not throw up on invalid json", () => {
-      const result = loadRC({ cwd: path.resolve(fixturesDir, "fbrc/invalid") });
+      const result = loadRC({ cwd: INVALID_RC_DIR });
       return expect(result.data).to.deep.eq(EMPTY_DATA);
     });
 
     it("should load from the right directory when --config is specified", () => {
-      const result = loadRC({ cwd: __dirname, configPath: "./test/fixtures/fbrc/firebase.json" });
+      const cwd = __dirname;
+      const result = loadRC({ cwd, configPath: path.relative(cwd, FIREBASE_JSON_PATH) });
       expect(result.projects.default).to.eq("top");
     });
   });

src/rulesDeploy.spec.ts

@@ -1,5 +1,4 @@
 import { expect } from "chai";
-import * as path from "path";
 import * as sinon from "sinon";
 
 import { FirebaseError } from "./error";
@@ -12,18 +11,17 @@ import { Config } from "./config";
 import * as gcp from "./gcp";
 
 import { RulesDeploy, RulesetServiceType } from "./rulesDeploy";
+import { FIXTURE_DIR, FIXTURE_FIRESTORE_RULES_PATH } from "./test/fixtures/rulesDeploy";
+import { FIXTURE_DIR as CROSS_SERVICE_FIXTURE_DIR } from "./test/fixtures/rulesDeployCrossService";
 
 describe("RulesDeploy", () => {
-  const FIXTURE_DIR = path.resolve(__dirname, "test/fixtures/rulesDeploy");
   const BASE_OPTIONS: { cwd: string; project: string; config: any } = {
     cwd: FIXTURE_DIR,
     project: "test-project",
     config: null,
   };
   BASE_OPTIONS.config = Config.load(BASE_OPTIONS, false);
-  const FIRESTORE_RULES_CONTENT = readFileSync(
-    path.resolve(FIXTURE_DIR, "firestore.rules"),
-  ).toString();
+  const FIRESTORE_RULES_CONTENT = readFileSync(FIXTURE_FIRESTORE_RULES_PATH).toString();
 
   describe("addFile", () => {
     it("should successfully add a file that exists", () => {
@@ -340,9 +338,8 @@ describe("RulesDeploy", () => {
     });
 
     describe("with cross-service rules", () => {
-      const FIXTURE_DIR = path.resolve(__dirname, "test/fixtures/rulesDeployCrossService");
       const CROSS_SERVICE_OPTIONS: { cwd: string; project: string; config: any } = {
-        cwd: FIXTURE_DIR,
+        cwd: CROSS_SERVICE_FIXTURE_DIR,
         project: "test-project",
         config: null,
       };