gitspace 0.2.0-rc.20 → 0.2.0-rc.21

package/src/core/__tests__/project-lifecycle.test.ts

@@ -1,137 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { applyProjectBundleState } from '../project-lifecycle';
-
-describe('project-lifecycle', () => {
-  it('persists input values, secret keys, and confirm history', async () => {
-    let config: any = {
-      repository: 'owner/repo',
-      bundleValues: {},
-      bundleSecretKeys: [],
-      bundleWorkspaceState: undefined,
-      bundleConfirmHistory: undefined,
-    };
-
-    const setSecretCalls: Array<{ projectName: string; key: string; value: string }> = [];
-
-    await applyProjectBundleState(
-      {
-        projectName: 'test-project',
-        bundle: {
-          version: '1.0',
-          name: 'Test Bundle',
-          onboarding: [
-            {
-              id: 'check-bun',
-              type: 'confirm',
-              title: 'Bun CLI',
-              description: 'Bun required',
-              checkCommand: 'bun',
-            },
-          ],
-        },
-        inputValues: { REGION: 'us-west-2' },
-        secretValues: { PULUMI_ACCESS_TOKEN: 'token-123' },
-        confirmResults: {
-          'check-bun': {
-            status: 'passed',
-            checkCommand: 'bun',
-          },
-        },
-      },
-      {
-        getProjectBaseDir: () => '/tmp/project/base',
-        readProjectConfig: () => config,
-        updateProjectConfig: (_projectName, updates) => {
-          config = { ...config, ...updates };
-          return config;
-        },
-        syncBundleWorkspaceState: () => ({
-          hasBundle: true,
-          scope: '__base__',
-          bundleHash: 'hash123',
-        }),
-        hashBundle: () => 'bundle-hash',
-        getConfirmStepFingerprint: () => 'fp-check-bun',
-        setProjectSecret: async (projectName, key, value) => {
-          setSecretCalls.push({ projectName, key, value });
-        },
-      }
-    );
-
-    expect(setSecretCalls).toEqual([
-      {
-        projectName: 'test-project',
-        key: 'PULUMI_ACCESS_TOKEN',
-        value: 'token-123',
-      },
-    ]);
-    expect(config.bundleValues).toEqual({ REGION: 'us-west-2' });
-    expect(config.bundleSecretKeys).toEqual(['PULUMI_ACCESS_TOKEN']);
-    expect(config.bundleConfirmHistory['fp-check-bun']).toMatchObject({
-      stepId: 'check-bun',
-      status: 'passed',
-      bundleHash: 'hash123',
-      scope: '__base__',
-    });
-  });
-
-  it('seeds base scope metadata when sync has no bundle', async () => {
-    let config: any = {
-      repository: 'owner/repo',
-      bundleValues: {},
-      bundleSecretKeys: [],
-      bundleWorkspaceState: undefined,
-      bundleConfirmHistory: undefined,
-    };
-
-    await applyProjectBundleState(
-      {
-        projectName: 'test-project',
-        bundle: {
-          version: '1.0',
-          name: 'Test Bundle',
-          onboarding: [
-            {
-              id: 'region',
-              type: 'input',
-              title: 'Region',
-              description: 'Region',
-              configKey: 'REGION',
-            },
-            {
-              id: 'pulumi-token',
-              type: 'secret',
-              title: 'Pulumi Token',
-              description: 'Token',
-              configKey: 'PULUMI_ACCESS_TOKEN',
-            },
-          ],
-        },
-      },
-      {
-        getProjectBaseDir: () => '/tmp/project/base',
-        readProjectConfig: () => config,
-        updateProjectConfig: (_projectName, updates) => {
-          config = { ...config, ...updates };
-          return config;
-        },
-        syncBundleWorkspaceState: () => ({
-          hasBundle: false,
-          scope: undefined,
-          bundleHash: undefined,
-        }),
-        hashBundle: () => 'bundle-hash',
-        getConfirmStepFingerprint: () => 'fp-check-bun',
-        setProjectSecret: async () => {},
-      }
-    );
-
-    expect(config.bundleWorkspaceState).toBeDefined();
-    expect(config.bundleWorkspaceState.__base__).toBeDefined();
-    expect(config.bundleWorkspaceState.__base__.requiredInputKeys).toEqual(['REGION']);
-    expect(config.bundleWorkspaceState.__base__.requiredSecretKeys).toEqual([
-      'PULUMI_ACCESS_TOKEN',
-    ]);
-    expect(config.bundleSecretKeys).toEqual(['PULUMI_ACCESS_TOKEN']);
-  });
-});

package/src/core/__tests__/workspace-lifecycle.test.ts

@@ -1,159 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test'
-
-let detectResult: any
-let planResult: any
-let syncParseError: string | undefined
-let syncCalls = 0
-let runCalls = 0
-let skipSecretDependentScripts = false
-
-mock.module('../bundle-refresh', () => ({
-  checkAndRefreshBundle: async () => true,
-  detectBundleChanges: () => detectResult,
-  getBundleRefreshPlan: async () => planResult,
-  formatBundleChangeDetails: () => 'Bundle details',
-  syncBundleWorkspaceState: () => {
-    syncCalls += 1
-    if (syncParseError) {
-      return { hasBundle: false, parseError: syncParseError }
-    }
-    return { hasBundle: true }
-  },
-}))
-
-mock.module('../config', () => ({
-  readProjectConfig: () => ({
-    repository: 'owner/repo',
-    bundleSecretKeys: [],
-  }),
-}))
-
-mock.module('../../utils/secrets', () => ({
-  preloadProjectSecrets: async () => {},
-}))
-
-mock.module('../secret-runtime', () => ({
-  shouldSkipSecretDependentScripts: () => skipSecretDependentScripts,
-}))
-
-mock.module('../../utils/run-workspace-scripts', () => ({
-  runWorkspaceScripts: async () => {
-    runCalls += 1
-    return { success: true }
-  },
-}))
-
-mock.module('../../utils/logger', () => ({
-  logger: {
-    info: () => {},
-    warning: () => {},
-  },
-}))
-
-import { prepareWorkspaceForSession } from '../workspace-lifecycle.js'
-
-describe('prepareWorkspaceForSession bundle checks', () => {
-  beforeEach(() => {
-    syncCalls = 0
-    runCalls = 0
-    syncParseError = undefined
-    skipSecretDependentScripts = false
-    detectResult = {
-      hasBundle: true,
-      hasChanged: false,
-      parseError: undefined,
-    }
-    planResult = {
-      hasBundle: true,
-      hasChanged: false,
-      details: 'No changes',
-      steps: [],
-    }
-  })
-
-  afterEach(() => {
-    mock.restore()
-  })
-
-  it('returns refresh-required without syncing state when bundle changed', async () => {
-    detectResult = {
-      hasBundle: true,
-      hasChanged: true,
-      parseError: undefined,
-    }
-
-    const result = await prepareWorkspaceForSession({
-      projectName: 'test-project',
-      workspacePath: '/tmp/test-workspace',
-      workspaceName: 'test-workspace',
-      repository: 'owner/repo',
-      bundleMode: 'error-if-changed',
-    })
-
-    expect(result.success).toBe(false)
-    expect('bundleNeedsRefresh' in result && result.bundleNeedsRefresh).toBe(true)
-    expect(syncCalls).toBe(0)
-    expect(runCalls).toBe(0)
-  })
-
-  it('syncs state and runs scripts when bundle is unchanged', async () => {
-    const result = await prepareWorkspaceForSession({
-      projectName: 'test-project',
-      workspacePath: '/tmp/test-workspace',
-      workspaceName: 'test-workspace',
-      repository: 'owner/repo',
-      bundleMode: 'error-if-changed',
-    })
-
-    expect(result.success).toBe(true)
-    expect(syncCalls).toBe(1)
-    expect(runCalls).toBe(1)
-  })
-
-  it('returns refresh-required when unchanged bundle is missing required onboarding', async () => {
-    planResult = {
-      hasBundle: true,
-      hasChanged: false,
-      details: 'Missing required secrets: PULUMI_ACCESS_TOKEN.',
-      steps: [
-        {
-          id: 'pulumi-token',
-          type: 'secret',
-          title: 'Pulumi access token',
-          description: 'Token',
-          configKey: 'PULUMI_ACCESS_TOKEN',
-          required: true,
-        },
-      ],
-    }
-
-    const result = await prepareWorkspaceForSession({
-      projectName: 'test-project',
-      workspacePath: '/tmp/test-workspace',
-      workspaceName: 'test-workspace',
-      repository: 'owner/repo',
-      bundleMode: 'error-if-changed',
-    })
-
-    expect(result.success).toBe(false)
-    expect('bundleNeedsRefresh' in result && result.bundleNeedsRefresh).toBe(true)
-    expect(syncCalls).toBe(0)
-    expect(runCalls).toBe(0)
-  })
-
-  it('syncs bundle state and skips scripts when secret loading is disabled', async () => {
-    skipSecretDependentScripts = true
-
-    const result = await prepareWorkspaceForSession({
-      projectName: 'test-project',
-      workspacePath: '/tmp/test-workspace',
-      workspaceName: 'test-workspace',
-      repository: 'owner/repo',
-      bundleMode: 'error-if-changed',
-    })
-
-    expect(result.success).toBe(true)
-    expect(syncCalls).toBe(1)
-    expect(runCalls).toBe(0)
-  })
-})

package/src/core/__tests__/workspace.test.ts

@@ -1,149 +0,0 @@
-/**
- * Tests for workspace.ts core deletion functions
- *
- * These tests mock dependencies to test the orchestration logic
- * without requiring a running tmux-lite server or actual git repos.
- */
-
-import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test';
-import { mkdirSync, rmSync, existsSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-// We'll test the module by creating a real file structure
-// but mocking the tmux-lite and git operations
-
-describe('deleteWorkspaceCore', () => {
-  let testDir: string;
-  let projectDir: string;
-  let workspacesDir: string;
-  let baseDir: string;
-
-  // Track mock state
-  let mockSessions: Array<{ id: string; name: string; cwd: string }>;
-  let killedSessions: string[];
-  let removedWorktrees: string[];
-  let deletedBranches: string[];
-  let serverRunning: boolean;
-
-  beforeEach(() => {
-    // Create test directory structure
-    testDir = join(tmpdir(), `workspace-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    projectDir = join(testDir, 'gitspace', 'test-project');
-    workspacesDir = join(projectDir, 'workspaces');
-    baseDir = join(projectDir, 'base');
-
-    mkdirSync(workspacesDir, { recursive: true });
-    mkdirSync(baseDir, { recursive: true });
-
-    // Create a fake workspace
-    mkdirSync(join(workspacesDir, 'my-workspace'));
-
-    // Create project config
-    writeFileSync(join(projectDir, '.config.json'), JSON.stringify({
-      repository: 'owner/test-repo',
-      baseBranch: 'main',
-    }));
-
-    // Reset mock state
-    mockSessions = [];
-    killedSessions = [];
-    removedWorktrees = [];
-    deletedBranches = [];
-    serverRunning = true;
-  });
-
-  afterEach(() => {
-    if (existsSync(testDir)) {
-      rmSync(testDir, { recursive: true, force: true });
-    }
-    mock.restore();
-  });
-
-  it('should export deleteWorkspaceCore function', async () => {
-    const { deleteWorkspaceCore } = await import('../workspace');
-    expect(typeof deleteWorkspaceCore).toBe('function');
-  });
-
-  it('should export deleteProjectCore function', async () => {
-    const { deleteProjectCore } = await import('../workspace');
-    expect(typeof deleteProjectCore).toBe('function');
-  });
-
-  it('should export DeleteWorkspaceOptions type', async () => {
-    // Type check - if this compiles, the type exists
-    const { deleteWorkspaceCore } = await import('../workspace');
-    const options: Parameters<typeof deleteWorkspaceCore>[2] = {
-      nonInteractive: true,
-      keepBranch: false,
-    };
-    expect(options.nonInteractive).toBe(true);
-  });
-
-  it('should export DeleteWorkspaceResult type', async () => {
-    const { deleteWorkspaceCore } = await import('../workspace');
-    // The return type should have these properties
-    type Result = Awaited<ReturnType<typeof deleteWorkspaceCore>>;
-    const checkType = (r: Result) => {
-      r.success;
-      r.workspaceName;
-      r.branch;
-      r.branchDeleted;
-      r.sessionsKilled;
-      r.error;
-    };
-    expect(typeof checkType).toBe('function');
-  });
-});
-
-describe('deleteProjectCore', () => {
-  it('should export DeleteProjectOptions type', async () => {
-    const { deleteProjectCore } = await import('../workspace');
-    const options: Parameters<typeof deleteProjectCore>[1] = {
-      nonInteractive: true,
-    };
-    expect(options.nonInteractive).toBe(true);
-  });
-
-  it('should export DeleteProjectResult type', async () => {
-    const { deleteProjectCore } = await import('../workspace');
-    type Result = Awaited<ReturnType<typeof deleteProjectCore>>;
-    const checkType = (r: Result) => {
-      r.success;
-      r.projectName;
-      r.workspacesDeleted;
-      r.sessionsKilled;
-      r.wasCurrentProject;
-      r.errors;
-    };
-    expect(typeof checkType).toBe('function');
-  });
-});
-
-describe('integration behavior', () => {
-  it('deleteWorkspaceCore should accept nonInteractive option', async () => {
-    // Verify the function signature accepts nonInteractive option
-    const { deleteWorkspaceCore } = await import('../workspace');
-    expect(typeof deleteWorkspaceCore).toBe('function');
-
-    // Verify the function's third parameter accepts the expected options
-    // This is a compile-time check - if it compiles, the type is correct
-    type Options = Parameters<typeof deleteWorkspaceCore>[2];
-    const options: Options = { nonInteractive: true, keepBranch: false };
-    expect(options.nonInteractive).toBe(true);
-    expect(options.keepBranch).toBe(false);
-
-    // Note: Full integration testing would require mocking many modules
-    // For now, we verify the API shape is correct
-  });
-
-  it('deleteProjectCore should accept nonInteractive option', async () => {
-    const { deleteProjectCore } = await import('../workspace');
-    expect(typeof deleteProjectCore).toBe('function');
-
-    // Verify the function's second parameter accepts the expected options
-    type Options = Parameters<typeof deleteProjectCore>[1];
-    const options: Options = { nonInteractive: true };
-    expect(options.nonInteractive).toBe(true);
-  });
-});