Merge master.

Author: taeold

src/emulator/controller.spec.ts

@@ -1,54 +1,10 @@
 import { Emulators } from "./types";
 import { EmulatorRegistry } from "./registry";
 import { expect } from "chai";
-import * as sinon from "sinon";
-
-import * as controller from "./controller";
-import * as commandUtils from "./commandUtils";
-import * as functionsConfig from "../functions/projectConfig";
-import * as functionsHelper from "../deploy/functions/functionsDeployHelper";
-import * as projectUtils from "../projectUtils";
-import * as portUtils from "./portUtils";
 import { FakeEmulator } from "./testing/fakeEmulator";
-import { FunctionsEmulator } from "./functionsEmulator";
-import { Runtime } from "../deploy/functions/runtimes/supported";
-import { Options } from "../options";
-import { Config } from "../config";
 
 describe("EmulatorController", () => {
-  const sandbox = sinon.createSandbox();
-
-  let functionsEmulatorConstructorStub: sinon.SinonStub;
-  let normalizeAndValidateStub: sinon.SinonStub;
-  let getEndpointFiltersStub: sinon.SinonStub;
-  let shouldStartStub: sinon.SinonStub;
-  let filterEmulatorTargetsStub: sinon.SinonStub;
-  let resolveHostAndAssignPortsStub: sinon.SinonStub;
-  let getProjectIdStub: sinon.SinonStub;
-  let startEmulatorStub: sinon.SinonStub;
-  let checkJavaMajorVersionStub: sinon.SinonStub;
-
-  beforeEach(() => {
-    // Stub dependencies
-    functionsEmulatorConstructorStub = sandbox.stub(FunctionsEmulator.prototype, "start");
-    normalizeAndValidateStub = sandbox.stub(functionsConfig, "normalizeAndValidate");
-    getEndpointFiltersStub = sandbox.stub(functionsHelper, "getEndpointFilters");
-    shouldStartStub = sandbox.stub(controller, "shouldStart");
-    filterEmulatorTargetsStub = sandbox.stub(controller, "filterEmulatorTargets");
-    resolveHostAndAssignPortsStub = sandbox.stub(portUtils, "resolveHostAndAssignPorts");
-    getProjectIdStub = sandbox.stub(projectUtils, "getProjectId");
-    startEmulatorStub = sandbox.stub(EmulatorRegistry, "start");
-    checkJavaMajorVersionStub = sandbox.stub(commandUtils, "checkJavaMajorVersion").resolves(11); // Assume valid Java version
-
-    // Default stub behaviors
-    getProjectIdStub.returns("test-project");
-    shouldStartStub.returns(false); // Default to not starting emulators unless specified
-    filterEmulatorTargetsStub.returns([]); // Default to no targets unless specified
-    resolveHostAndAssignPortsStub.resolves({}); // Default to empty assigned ports
-  });
-
   afterEach(async () => {
-    sandbox.restore();
     await EmulatorRegistry.stopAll();
   });
 
@@ -63,84 +19,4 @@ describe("EmulatorController", () => {
     expect(EmulatorRegistry.isRunning(name)).to.be.true;
     expect(EmulatorRegistry.getInfo(name)!.port).to.eql(fake.getInfo().port);
   });
-
-  describe("startAll", () => {
-    const mockOptions = (): Options => {
-      return {
-        project: "test-project",
-        only: "",
-        config: new Config({}), // Provide a mock Config object
-        // Add other necessary default options
-      } as unknown as Options; // Use unknown assertion carefully
-    };
-
-    const mockFunctionsConfig: functionsConfig.ValidatedConfig = [
-      { source: "functions- A", codebase: "default", runtime: "nodejs18" },
-      { source: "functions-B", codebase: "api", runtime: "nodejs18" },
-      { source: "functions-C", codebase: "worker", runtime: "nodejs18" },
-    ];
-
-    it("should call getEndpointFilters with strict=true when starting Functions emulator", async () => {
-      const options = mockOptions();
-      options.only = "functions"; // Enable functions emulator generally
-      options.config = new Config({ functions: { source: "functions" } }); // Basic functions config
-
-      // Setup stubs for this test
-      shouldStartStub.withArgs(options, Emulators.FUNCTIONS).returns(true);
-      filterEmulatorTargetsStub.withArgs(options).returns([Emulators.FUNCTIONS]);
-      normalizeAndValidateStub.returns(mockFunctionsConfig.slice(0, 1)); // Return only default codebase config
-      resolveHostAndAssignPortsStub.resolves({
-        [Emulators.FUNCTIONS]: [{ address: "localhost", port: 5001, family: "IPv4" }],
-        [Emulators.EVENTARC]: [{ address: "localhost", port: 9200, family: "IPv4" }],
-        [Emulators.TASKS]: [{ address: "localhost", port: 9300, family: "IPv4" }],
-      });
-      getEndpointFiltersStub.returns(undefined); // No specific filters from --only
-
-      await controller.startAll(options);
-
-      // Assert getEndpointFilters was called with strict = true
-      expect(getEndpointFiltersStub.calledOnce).to.be.true;
-      expect(getEndpointFiltersStub.getCall(0).args[1]).to.equal(true); // strict = true
-    });
-
-    it("should filter function codebases based on --only flag using strict parsing", async () => {
-      const options = mockOptions();
-      options.only = "functions:api"; // Only start 'api' codebase functions
-      options.config = new Config({
-        functions: [
-          { source: "functions-A", codebase: "default" },
-          { source: "functions-B", codebase: "api" },
-          { source: "functions-C", codebase: "worker" },
-        ],
-      });
-
-      // Setup stubs for this test
-      shouldStartStub.withArgs(options, Emulators.FUNCTIONS).returns(true);
-      filterEmulatorTargetsStub.withArgs(options).returns([Emulators.FUNCTIONS]);
-      normalizeAndValidateStub.returns(mockFunctionsConfig); // Return all codebases initially
-      resolveHostAndAssignPortsStub.resolves({
-        [Emulators.FUNCTIONS]: [{ address: "localhost", port: 5001, family: "IPv4" }],
-        [Emulators.EVENTARC]: [{ address: "localhost", port: 9200, family: "IPv4" }],
-        [Emulators.TASKS]: [{ address: "localhost", port: 9300, family: "IPv4" }],
-      });
-
-      // Simulate getEndpointFilters returning the filter for 'api' codebase in strict mode
-      getEndpointFiltersStub.withArgs(options, true).returns([{ codebase: "api" }]);
-
-      // Spy on the FunctionsEmulator constructor to capture arguments
-      const functionsEmulatorSpy = sandbox.spy(
-        require("../emulator/functionsEmulator"), // Use require to spy on the class itself
-        "FunctionsEmulator",
-      );
-
-      await controller.startAll(options);
-
-      // Assert FunctionsEmulator was called with filtered backends
-      expect(functionsEmulatorSpy.calledOnce).to.be.true;
-      const constructorArgs = functionsEmulatorSpy.getCall(0).args[0];
-      expect(constructorArgs.emulatableBackends).to.be.an("array").with.lengthOf(1);
-      expect(constructorArgs.emulatableBackends[0].codebase).to.equal("api");
-      expect(constructorArgs.emulatableBackends[0].source).to.equal("functions-B");
-    });
-  });
-}).timeout(10000); // Increase timeout for potentially slower setup/teardown
+}).timeout(2000);