@superblocksteam/sdk 2.0.115 → 2.0.116-next.1

package/src/cli-replacement/dev-startup-git-before-dbfs-order.test.mts

@@ -0,0 +1,407 @@
+import * as fs from "node:fs/promises";
+import * as http from "node:http";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+  type Mock,
+} from "vitest";
+
+const execMock = vi.fn();
+vi.mock("node:child_process", () => ({
+  default: { exec: execMock },
+  exec: execMock,
+}));
+
+vi.mock("node:readline", () => ({
+  default: {
+    createInterface: vi.fn(() => ({ question: vi.fn(), close: vi.fn() })),
+  },
+  createInterface: vi.fn(() => ({ question: vi.fn(), close: vi.fn() })),
+}));
+
+vi.mock("fs-extra", () => ({
+  default: {
+    existsSync: vi.fn(() => true),
+    readFileSync: vi.fn(() => "{}"),
+  },
+}));
+
+vi.mock("package-manager-detector/detect", () => ({
+  detect: vi.fn(async () => ({
+    name: "npm",
+    agent: "npm",
+    version: "10.0.0",
+  })),
+}));
+
+vi.mock("package-manager-detector", () => ({
+  resolveCommand: vi.fn(() => ({
+    command: "npm",
+    args: ["install", "--fund=false", "--audit=false"],
+  })),
+}));
+
+vi.mock("read-pkg", () => ({
+  readPackage: vi.fn(async () => ({
+    name: "test-app",
+    dependencies: { "@superblocksteam/library": "1.0.0" },
+  })),
+}));
+
+const mockLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  debug: vi.fn(),
+};
+
+vi.mock("../telemetry/logging.js", () => ({
+  getLogger: () => mockLogger,
+  getErrorMeta: vi.fn(() => ({})),
+}));
+
+vi.mock("../telemetry/index.js", () => ({
+  getTracer: () => ({
+    startActiveSpan: vi.fn(
+      async (
+        _name: string,
+        fn: (span: {
+          end: () => void;
+          setStatus: () => void;
+        }) => Promise<unknown>,
+      ) => fn({ end: vi.fn(), setStatus: vi.fn() }),
+    ),
+  }),
+}));
+
+vi.mock("@opentelemetry/api", () => ({
+  SpanStatusCode: { ERROR: 2 },
+}));
+
+vi.mock("colorette", () => ({
+  green: (s: string) => s,
+}));
+
+vi.mock("@superblocksteam/shared", () => ({
+  buildGithubSuperblocksSyncWorkflow: vi.fn(),
+  buildGithubSuperblocksSyncWorkflowFromBaseUrl: vi.fn(),
+  ConflictError: class ConflictError extends Error {},
+  DEFAULT_NON_GIT_BRANCH: "__non_git__",
+  isGitHubRemoteUrl: vi.fn(() => false),
+  NotFoundError: class NotFoundError extends Error {},
+  SUPERBLOCKS_LIVE_GIT_BRANCH: "__live__",
+}));
+
+vi.mock("@superblocksteam/util", () => ({
+  maskUnixSignals: async function maskUnixSignals(fn: () => Promise<void>) {
+    return fn();
+  },
+}));
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/ai-service", () => ({
+  AiService: class {
+    initialize = vi.fn(async () => undefined);
+    removeIntegrationCache = vi.fn(async () => undefined);
+    chatSessionStore = { invalidateCache: vi.fn() };
+  },
+  AiServiceFeatureFlags: class {
+    static create = vi.fn(() => ({}));
+  },
+  SnapshotManager: class {
+    executePendingRestore = vi.fn(async () => false);
+  },
+  isSdkApiTemplate: vi.fn(() => false),
+}));
+
+const { startupOpLog, buildMockGitService } = vi.hoisted(() => {
+  const startupOpLog: string[] = [];
+  function buildMockGitService(cwd: string) {
+    return {
+      workDir: cwd,
+      configure: vi.fn(async () => {
+        startupOpLog.push("git:configure");
+      }),
+      init: vi.fn(async () => {
+        startupOpLog.push("git:init");
+      }),
+      addRemote: vi.fn(async () => {
+        startupOpLog.push("git:addRemote");
+      }),
+      fetch: vi.fn(async () => {
+        startupOpLog.push("git:fetch");
+      }),
+      raw: vi.fn(async (args: string | string[]) => {
+        const argv = Array.isArray(args) ? args : [args];
+        startupOpLog.push(`git:raw:${argv.join(" ")}`);
+        if (argv[0] === "ls-remote" && argv.includes("__live__")) {
+          return "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef\trefs/heads/__live__\n";
+        }
+        if (argv[0] === "branch" && argv.includes("--show-current")) {
+          return "__live__\n";
+        }
+        if (argv[0] === "commit") {
+          return "";
+        }
+        return "";
+      }),
+      push: vi.fn(async () => {
+        startupOpLog.push("git:push");
+      }),
+      getDefaultBranch: vi.fn(async () => "main"),
+      getRemotes: vi.fn(async () => [
+        { name: "origin", refs: { fetch: "https://example.test/repo.git" } },
+      ]),
+      remote: vi.fn(async () => {
+        startupOpLog.push("git:remote");
+      }),
+      revparse: vi.fn(async (ref: string) => {
+        startupOpLog.push(`git:revparse:${ref}`);
+        return "abc123\n";
+      }),
+      checkout: vi.fn(async () => {
+        startupOpLog.push("git:checkout");
+      }),
+      checkoutOrCreate: vi.fn(async () => {
+        startupOpLog.push("git:checkoutOrCreate");
+      }),
+    };
+  }
+  return { startupOpLog, buildMockGitService };
+});
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/git-service", () => ({
+  createGitService: vi.fn((cwd: string) => {
+    startupOpLog.push("createGitService");
+    return buildMockGitService(cwd);
+  }),
+}));
+
+const mockLockService = {
+  acquireLock: vi.fn(async () => undefined),
+  shutdown: vi.fn(async () => undefined),
+  shutdownAndExit: vi.fn(async () => undefined),
+  setIsRestarting: vi.fn(),
+  isLocked: false,
+  connectedUsers: [],
+  wasRecentlyActive: false,
+  timeSinceLastActivity: 0,
+};
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/lock-service", () => ({
+  LockService: class {
+    acquireLock = mockLockService.acquireLock;
+    shutdown = mockLockService.shutdown;
+    shutdownAndExit = mockLockService.shutdownAndExit;
+    setIsRestarting = mockLockService.setIsRestarting;
+    isLocked = mockLockService.isLocked;
+    connectedUsers = mockLockService.connectedUsers;
+    wasRecentlyActive = mockLockService.wasRecentlyActive;
+    timeSinceLastActivity = mockLockService.timeSinceLastActivity;
+  },
+  LockType: { CSB: "CSB", LOCAL: "LOCAL" },
+}));
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/operation-queue", () => ({
+  OperationQueue: class {
+    enqueue = vi.fn(async (fn: () => Promise<unknown>) => fn());
+  },
+}));
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/server-rpc", () => ({
+  AutoConnectingRpcClient: class {},
+}));
+
+const mockSyncService = {
+  downloadDirectory: vi.fn(async () => {
+    startupOpLog.push("dbfs:downloadDirectory");
+  }),
+  uploadDirectory: vi.fn(async () => undefined),
+  uploadDirectoryNowIfNeeded: vi.fn(async () => undefined),
+  cancelPendingSync: vi.fn(),
+};
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/sync-service", () => ({
+  SyncService: class {
+    downloadDirectory = mockSyncService.downloadDirectory;
+    uploadDirectory = mockSyncService.uploadDirectory;
+    uploadDirectoryNowIfNeeded = mockSyncService.uploadDirectoryNowIfNeeded;
+    cancelPendingSync = mockSyncService.cancelPendingSync;
+  },
+}));
+
+vi.mock("@superblocksteam/vite-plugin-file-sync/draft-interface", () => ({}));
+
+vi.mock("./version-detection.js", () => ({
+  getCurrentCliVersion: vi.fn(async () => ({
+    version: "2.0.0",
+    alias: undefined,
+  })),
+}));
+
+const mockCheckVersions = vi.fn(async () => ({
+  cliUpdated: false,
+  upgradePromises: [] as Promise<void>[],
+}));
+vi.mock("./automatic-upgrades.js", () => ({
+  checkVersionsAndWritePackageJson: (
+    ...args: Parameters<typeof mockCheckVersions>
+  ) => mockCheckVersions(...args),
+}));
+
+vi.mock("./git-repo-setup.mjs", () => ({
+  ensureRemoteHasDefaultBranch: vi.fn(async () => undefined),
+  getGitErrorFields: vi.fn(() => ({})),
+}));
+
+const mockCreateDevServer = vi.fn(async () => http.createServer());
+vi.mock("../dev-utils/dev-server.mjs", () => ({
+  createDevServer: (...args: Parameters<typeof mockCreateDevServer>) =>
+    mockCreateDevServer(...args),
+}));
+
+vi.mock("../index.js", () => ({
+  AUTO_UPGRADE_EXIT_CODE: 99,
+}));
+
+const SERVER_DBFS_HASH = "dbfs-head-after-clark";
+
+function buildMockSdk() {
+  const hashLocalDirectory = vi
+    .fn()
+    .mockImplementationOnce(async () => {
+      startupOpLog.push("sdk:hashLocalDirectory:before-dbfs");
+      return { hash: "git-tree-without-uncommitted-clark-change" };
+    })
+    .mockImplementationOnce(async () => {
+      startupOpLog.push("sdk:hashLocalDirectory:after-dbfs");
+      return { hash: SERVER_DBFS_HASH };
+    });
+
+  return {
+    hashLocalDirectory,
+    dbfsGetApplicationDirectoryHash: vi.fn(async () => SERVER_DBFS_HASH),
+    getApplicationGitConfig: vi.fn(async () => ({
+      gitRemoteUrl: "https://github.com/example/superblocks-app.git",
+      hasCredential: false,
+    })),
+    fetchCurrentUser: vi.fn(async () => ({
+      user: {
+        id: "user-1",
+        name: "Test User",
+        email: "test@example.com",
+        currentOrganizationId: "org-1",
+      },
+      organizations: [{ id: "org-1", pluginExecutionVersions: {} }],
+      flagBootstrap: {},
+    })),
+    getFeatureFlagsForCurrentUser: vi.fn(async () => ({
+      devServerCloudInactivityTimeoutMinutes: () => 30,
+      devServerLocalInactivityTimeoutMinutes: () => 30,
+      enableSessionRecording: () => false,
+    })),
+    getFeatureFlagsForUser: vi.fn(() => ({
+      devServerCloudInactivityTimeoutMinutes: () => 30,
+      devServerLocalInactivityTimeoutMinutes: () => 30,
+    })),
+  };
+}
+
+function buildDevOptions(cwd: string, overrides: Record<string, unknown> = {}) {
+  return {
+    cwd,
+    downloadFirst: true,
+    autoUpgradeMode: "skip-upgrade",
+    applicationConfig: {
+      id: "app-test",
+      branchName: "main",
+    },
+    tokenConfig: {
+      superblocksBaseUrl: "https://example.test",
+      token: "test-token",
+    },
+    tokenManager: {
+      getToken: vi.fn(() => "test-token"),
+      onTokenRefresh: vi.fn(),
+    },
+    getCurrentToken: vi.fn(() => "test-token"),
+    sdk: buildMockSdk(),
+    ...overrides,
+  };
+}
+
+function setupExecMock() {
+  execMock.mockImplementation(
+    (
+      _cmd: string,
+      _opts: unknown,
+      cb?: (err: null, result: { stdout: string }) => void,
+    ) => {
+      if (typeof _opts === "function") {
+        (_opts as (err: null, result: { stdout: string }) => void)(null, {
+          stdout: "installed",
+        });
+      } else if (cb) {
+        cb(null, { stdout: "installed" });
+      }
+    },
+  );
+}
+
+describe("dev startup: git reconciliation before DBFS download", () => {
+  let testCwd: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    startupOpLog.length = 0;
+    setupExecMock();
+    mockCheckVersions.mockResolvedValue({
+      cliUpdated: false,
+      upgradePromises: [],
+    });
+    testCwd = await fs.mkdtemp(path.join(os.tmpdir(), "sb-dev-git-dbfs-"));
+    const { readPackage } = await import("read-pkg");
+    (readPackage as Mock).mockResolvedValue({
+      name: "test-app",
+      dependencies: { "@superblocksteam/library": "1.0.0" },
+    });
+  });
+
+  afterEach(async () => {
+    await fs.rm(testCwd, { recursive: true, force: true });
+  });
+
+  it("runs git bootstrap before local hash and DBFS download when hashes differ (Clark-only DBFS change)", async () => {
+    const { dev } = await import("./dev.mjs");
+    const { createGitService } =
+      await import("@superblocksteam/vite-plugin-file-sync/git-service");
+
+    await dev(buildDevOptions(testCwd) as any);
+
+    const createIdx = startupOpLog.indexOf("createGitService");
+    const hashIdx = startupOpLog.indexOf("sdk:hashLocalDirectory:before-dbfs");
+    const downloadIdx = startupOpLog.indexOf("dbfs:downloadDirectory");
+    const postDownloadHashIdx = startupOpLog.indexOf(
+      "sdk:hashLocalDirectory:after-dbfs",
+    );
+
+    expect(createIdx).toBeGreaterThanOrEqual(0);
+    expect(hashIdx).toBeGreaterThanOrEqual(0);
+    expect(downloadIdx).toBeGreaterThanOrEqual(0);
+    expect(postDownloadHashIdx).toBeGreaterThanOrEqual(0);
+    expect(createIdx).toBeLessThan(hashIdx);
+    expect(hashIdx).toBeLessThan(downloadIdx);
+    expect(downloadIdx).toBeLessThan(postDownloadHashIdx);
+    expect(createGitService).toHaveBeenCalled();
+    expect(mockSyncService.downloadDirectory).toHaveBeenCalled();
+    expect(mockLogger.info).toHaveBeenCalledWith(
+      "[dev-startup] Post-download hash matches server",
+    );
+  });
+});