fix: wire coreEngineDependencies into Factory<DBTCloudProjectIntegration> (#1938)

Author: ralphstodomingo

src/inversify.config.ts

@@ -676,6 +676,9 @@ container
       onDiagnosticsChanged: () => void,
     ) => {
       const { container } = context;
+      const pythonStrategyFactory = container.get<
+        (projectRoot: string) => PythonDBTCommandExecutionStrategy
+      >("Factory<PythonDBTCommandExecutionStrategy>");
       return new DBTCloudProjectIntegration(
         container.get(DBTCommandExecutionInfrastructure),
         container.get(DBTCommandFactory),
@@ -688,6 +691,11 @@ container
         deferConfig,
         onDiagnosticsChanged,
         container.get(DbtCloudVariantDetector),
+        {
+          pythonDBTCommandExecutionStrategy: pythonStrategyFactory(projectRoot),
+          dbtConfiguration: container.get<DBTConfiguration>("DBTConfiguration"),
+          dbtIntegrationClient: container.get(DbtIntegrationClient),
+        },
       );
     };
   });

src/test/suite/dbtCloudCoreEngineDeps.test.ts

@@ -0,0 +1,96 @@
+import {
+  DBTCloudProjectIntegration,
+  DBTCommandExecutionInfrastructure,
+  DBTCommandFactory,
+  DBTConfiguration,
+  DBTDiagnosticData,
+  DBTTerminal,
+  DbtCloudVariantDetector,
+  DbtIntegrationClient,
+  DeferConfig,
+  PythonDBTCommandExecutionStrategy,
+  PythonEnvironmentProvider,
+  RuntimePythonEnvironment,
+} from "@altimateai/dbt-integration";
+import { describe, expect, it, jest } from "@jest/globals";
+
+// Documents the runtime contract that Factory<DBTCloudProjectIntegration> must
+// satisfy. The Cloud integration only constructs its engine inside
+// refreshProjectConfig(), and for any non-Fusion variant (including the
+// "no ~/.dbt/dbt_cloud.yml" / "API call failed" case where detect() returns
+// null) it routes through CloudCoreCommandIntegration — which requires
+// coreEngineDependencies to be passed in. Without those, the engine is never
+// constructed and every subsequent dialect call throws "engine not initialized".
+
+const noopTerminal = (): DBTTerminal =>
+  ({
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    log: jest.fn(),
+    show: jest.fn(),
+  }) as unknown as DBTTerminal;
+
+const stubVariantDetectorReturningNull = (): DbtCloudVariantDetector =>
+  ({
+    detect: jest.fn(async () => null),
+  }) as unknown as DbtCloudVariantDetector;
+
+const buildIntegration = (opts: {
+  withCoreEngineDeps: boolean;
+}): DBTCloudProjectIntegration => {
+  const terminal = noopTerminal();
+  const detector = stubVariantDetectorReturningNull();
+  const onDiagnosticsChanged = () => {};
+  const coreEngineDeps = opts.withCoreEngineDeps
+    ? {
+        pythonDBTCommandExecutionStrategy:
+          {} as unknown as PythonDBTCommandExecutionStrategy,
+        dbtConfiguration: {} as unknown as DBTConfiguration,
+        dbtIntegrationClient: {} as unknown as DbtIntegrationClient,
+      }
+    : undefined;
+  return new DBTCloudProjectIntegration(
+    {} as unknown as DBTCommandExecutionInfrastructure,
+    {} as unknown as DBTCommandFactory,
+    () => ({}) as never,
+    {} as unknown as RuntimePythonEnvironment,
+    {} as unknown as PythonEnvironmentProvider,
+    terminal,
+    "/tmp/project",
+    [] as DBTDiagnosticData[],
+    {} as DeferConfig,
+    onDiagnosticsChanged,
+    detector,
+    coreEngineDeps,
+  );
+};
+
+describe("DBTCloudProjectIntegration coreEngineDependencies contract", () => {
+  it("createEngine throws on a non-Fusion variant when coreEngineDependencies is omitted (the v0.61.0 regression — Factory<DBTCloudProjectIntegration> must wire these up)", () => {
+    const integration = buildIntegration({ withCoreEngineDeps: false });
+    expect(() =>
+      (
+        integration as unknown as {
+          createEngine: () => unknown;
+        }
+      ).createEngine(),
+    ).toThrow(/cannot construct CloudCoreCommandIntegration/);
+  });
+
+  it("createEngine clears the coreEngineDependencies guard once they are provided", () => {
+    // Pinpoints the guard at the top of createEngine. Construction past the
+    // guard reaches into CloudCoreCommandIntegration's super-chain which needs
+    // real DBTCommandExecutionInfrastructure / RuntimePythonEnvironment
+    // wiring; here we only prove the missing-deps gate is no longer hit.
+    const integration = buildIntegration({ withCoreEngineDeps: true });
+    expect(() =>
+      (
+        integration as unknown as {
+          createEngine: () => unknown;
+        }
+      ).createEngine(),
+    ).not.toThrow(/cannot construct CloudCoreCommandIntegration/);
+  });
+});

src/test/suite/dbtCloudFactoryWiring.test.ts

@@ -0,0 +1,101 @@
+import {
+  DBTCloudProjectIntegration,
+  DBTDiagnosticData,
+  DeferConfig,
+} from "@altimateai/dbt-integration";
+import { describe, expect, it, jest } from "@jest/globals";
+
+// The shared vscode mock at src/test/mock/vscode.ts has no `env` or
+// `extensions` namespaces. Stub them in before importing inversify.config —
+// the Cloud factory transitively constructs TelemetryService (reads env.appName
+// + creates a TelemetryReporter, which calls env.createTelemetryLogger) and
+// VSCodeRuntimePythonEnvironmentProvider (reads extensions.getExtension).
+import * as vscodeMock from "../mock/vscode";
+const vscodeMockAny = vscodeMock as Record<string, unknown>;
+vscodeMockAny.env = {
+  appName: "vscode-test",
+  machineId: "test-machine",
+  sessionId: "test-session",
+  isTelemetryEnabled: false,
+  onDidChangeTelemetryEnabled: () => ({ dispose: () => {} }),
+  createTelemetryLogger: () => ({
+    logUsage: () => {},
+    logError: () => {},
+    dispose: () => {},
+    onDidChangeEnableStates: () => ({ dispose: () => {} }),
+  }),
+};
+// VSCodeDBTTerminal calls outputChannel.debug/info/warn/error — the shared
+// mock channel only has append/appendLine/clear/show/hide/dispose.
+const sharedWindow = vscodeMockAny.window as Record<string, unknown>;
+sharedWindow.createOutputChannel = jest.fn(() => ({
+  append: jest.fn(),
+  appendLine: jest.fn(),
+  clear: jest.fn(),
+  show: jest.fn(),
+  hide: jest.fn(),
+  dispose: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  trace: jest.fn(),
+  replace: jest.fn(),
+  name: "Log - dbt",
+  logLevel: 1,
+  onDidChangeLogLevel: () => ({ dispose: () => {} }),
+}));
+vscodeMockAny.extensions = {
+  getExtension: jest.fn(() => ({
+    isActive: true,
+    activate: () => Promise.resolve(),
+    exports: {
+      settings: {
+        getExecutionDetails: () => ({ execCommand: ["python"] }),
+        onDidChangeExecutionDetails: () => ({ dispose: () => {} }),
+      },
+      environment: {
+        getEnvironmentPaths: async () => [],
+        getEnvironmentDetails: async () => ({ executable: { uri: undefined } }),
+      },
+    },
+  })),
+};
+
+import { container } from "../../inversify.config";
+
+describe("Factory<DBTCloudProjectIntegration>", () => {
+  it("constructs the Cloud integration with coreEngineDependencies wired up so non-Fusion variants can build a CloudCoreCommandIntegration engine", () => {
+    type CloudFactory = (
+      projectRoot: string,
+      projectConfigDiagnostics: DBTDiagnosticData[],
+      deferConfig: DeferConfig,
+      onDiagnosticsChanged: () => void,
+    ) => DBTCloudProjectIntegration;
+
+    const factory = container.get<CloudFactory>(
+      "Factory<DBTCloudProjectIntegration>",
+    );
+    const integration = factory(
+      "/tmp/project",
+      [],
+      {} as DeferConfig,
+      () => {},
+    );
+
+    const deps = (
+      integration as unknown as {
+        coreEngineDependencies?: {
+          pythonDBTCommandExecutionStrategy: unknown;
+          dbtConfiguration: unknown;
+          dbtIntegrationClient: unknown;
+        };
+      }
+    ).coreEngineDependencies;
+
+    expect(deps).toBeDefined();
+    expect(deps?.pythonDBTCommandExecutionStrategy).toBeDefined();
+    expect(deps?.dbtConfiguration).toBeDefined();
+    expect(deps?.dbtIntegrationClient).toBeDefined();
+  });
+});