More Jules generated tests (#8978)

* feat: Improve test coverage for emulator controller

This change adds a new test case to `src/emulator/controller.spec.ts` to verify that the functions emulator does not start if the functions source directory is not configured, even when specified in the `--only` flag.

This also fixes a failing test in the same file by correcting the mock options setup.

* Reverting some unwanted eslint change

* PR fix

---------

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

Author: joehan

src/auth.spec.ts

@@ -2,6 +2,7 @@ import { expect } from "chai";
 import * as sinon from "sinon";
 
 import {
+  assertAccount,
   getAdditionalAccounts,
   getAllAccounts,
   getGlobalDefaultAccount,
@@ -148,4 +149,30 @@ describe("auth", () => {
       expect(account).to.deep.equal(additionalUser2);
     });
   });
+
+  describe("assertAccount", () => {
+    const defaultAccount: Account = {
+      user: {
+        email: "[email protected]",
+      },
+      tokens: {
+        access_token: "abc1234",
+      },
+    };
+
+    beforeEach(() => {
+      configstore.set("user", defaultAccount.user);
+      configstore.set("tokens", defaultAccount.tokens);
+    });
+
+    it("should not throw an error if the account exists", () => {
+      expect(() => assertAccount("[email protected]")).to.not.throw();
+    });
+
+    it("should throw an error if the account does not exist", () => {
+      expect(() => assertAccount("[email protected]")).to.throw(
+        "Account [email protected] does not exist",
+      );
+    });
+  });
 });

src/emulator/controller.spec.ts

@@ -2,6 +2,27 @@ import { Emulators } from "./types";
 import { EmulatorRegistry } from "./registry";
 import { expect } from "chai";
 import { FakeEmulator } from "./testing/fakeEmulator";
+import { shouldStart } from "./controller";
+import { Options } from "../options";
+
+function createMockOptions(
+  only: string | undefined,
+  configValues: { [key: string]: any },
+): Options {
+  const config = {
+    get: (key: string) => configValues[key],
+    has: (key: string) => !!configValues[key],
+    src: {
+      emulators: configValues,
+      functions: configValues.functions,
+    },
+  };
+  return {
+    only,
+    config,
+    project: "test-project",
+  } as any;
+}
 
 describe("EmulatorController", () => {
   afterEach(async () => {
@@ -19,4 +40,68 @@ describe("EmulatorController", () => {
     expect(EmulatorRegistry.isRunning(name)).to.be.true;
     expect(EmulatorRegistry.getInfo(name)!.port).to.eql(fake.getInfo().port);
   });
+
+  describe("shouldStart", () => {
+    it("should start the hub if a project is specified", () => {
+      const options = { project: "test-project" } as Options;
+      expect(shouldStart(options, Emulators.HUB)).to.be.true;
+    });
+
+    it("should not start the hub if no project is specified", () => {
+      const options = {} as Options;
+      expect(shouldStart(options, Emulators.HUB)).to.be.false;
+    });
+
+    it("should start the UI if options.ui is true", () => {
+      const options = createMockOptions(undefined, {});
+      options.ui = true;
+      expect(shouldStart(options, Emulators.UI)).to.be.true;
+    });
+
+    it("should start the UI if a project is specified and a UI-supported emulator is running", () => {
+      const options = createMockOptions("firestore", { firestore: {} });
+      expect(shouldStart(options, Emulators.UI)).to.be.true;
+    });
+
+    it("should not start the UI if no project is specified", () => {
+      const options = createMockOptions("firestore", { firestore: {} });
+      delete options.project;
+      expect(shouldStart(options, Emulators.UI)).to.be.false;
+    });
+
+    it("should not start the UI if no UI-supported emulator is running", () => {
+      const options = createMockOptions(undefined, {});
+      expect(shouldStart(options, Emulators.UI)).to.be.false;
+    });
+
+    it("should start an emulator if it's in the only string", () => {
+      const options = createMockOptions("functions,hosting", {
+        functions: { source: "functions" },
+        hosting: {},
+      });
+      expect(shouldStart(options, Emulators.FUNCTIONS)).to.be.true;
+    });
+
+    it("should not start an emulator if it's not in the only string", () => {
+      const options = createMockOptions("functions", {
+        functions: { source: "functions" },
+        hosting: {},
+      });
+      expect(shouldStart(options, Emulators.HOSTING)).to.be.false;
+    });
+
+    it("should not start an emulator if it's in the only string but has no config", () => {
+      const options = createMockOptions("hosting,functions", {
+        hosting: {},
+      });
+      expect(shouldStart(options, Emulators.FUNCTIONS)).to.be.false;
+    });
+
+    it("should not start functions emulator if source directory is not configured", () => {
+      const options = createMockOptions("functions", {
+        functions: {}, // Config is present, but no source
+      });
+      expect(shouldStart(options, Emulators.FUNCTIONS)).to.be.false;
+    });
+  });
 }).timeout(2000);

src/track.spec.ts

@@ -0,0 +1,40 @@
+import { expect } from "chai";
+import * as sinon from "sinon";
+
+import { usageEnabled } from "./track";
+import { configstore } from "./configstore";
+
+describe("track", () => {
+  const sandbox: sinon.SinonSandbox = sinon.createSandbox();
+
+  afterEach(() => {
+    sandbox.restore();
+    delete process.env.IS_FIREBASE_CLI;
+    delete process.env.IS_FIREBASE_MCP;
+  });
+
+  describe("usageEnabled", () => {
+    it("should return true if IS_FIREBASE_CLI and usage are true", () => {
+      process.env.IS_FIREBASE_CLI = "true";
+      sandbox.stub(configstore, "get").withArgs("usage").returns(true);
+      expect(usageEnabled()).to.be.true;
+    });
+
+    it("should return false if IS_FIREBASE_CLI is not set", () => {
+      sandbox.stub(configstore, "get").withArgs("usage").returns(true);
+      expect(usageEnabled()).to.be.false;
+    });
+
+    it("should return false if usage is false", () => {
+      process.env.IS_FIREBASE_CLI = "true";
+      sandbox.stub(configstore, "get").withArgs("usage").returns(false);
+      expect(usageEnabled()).to.be.false;
+    });
+
+    it("should return true if IS_FIREBASE_MCP and usage are true", () => {
+      process.env.IS_FIREBASE_MCP = "true";
+      sandbox.stub(configstore, "get").withArgs("usage").returns(true);
+      expect(usageEnabled()).to.be.true;
+    });
+  });
+});