git-drive 0.1.5 → 0.1.6

package/packages/cli/src/__tests__/commands/init.test.ts

@@ -1,154 +0,0 @@
-import { init } from '../../commands/init.js';
-import { GitDriveError } from '../../errors.js';
-import { vol } from 'memfs';
-
-// Mock fs and path modules
-jest.mock('fs', () => {
-  const { fs } = require('memfs');
-  return fs;
-});
-
-// Mock prompts
-jest.mock('prompts', () => ({
-  __esModule: true,
-  default: jest.fn(),
-}));
-
-// Mock config
-jest.mock('../../config.js', () => ({
-  saveConfig: jest.fn(),
-  getDriveStorePath: jest.fn((drivePath: string) => `${drivePath}/.git-drive`),
-}));
-
-// Mock git
-jest.mock('../../git.js', () => ({
-  listDrives: jest.fn(),
-}));
-
-import prompts from 'prompts';
-import { listDrives } from '../../git.js';
-import { saveConfig, getDriveStorePath } from '../../config.js';
-
-const mockPrompts = prompts as unknown as jest.Mock;
-const mockListDrives = listDrives as jest.Mock;
-const mockSaveConfig = saveConfig as jest.Mock;
-const mockGetDriveStorePath = getDriveStorePath as jest.Mock;
-
-describe('init command', () => {
-  let consoleSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    vol.reset();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-    mockGetDriveStorePath.mockImplementation((drivePath: string) => `${drivePath}/.git-drive`);
-  });
-
-  afterEach(() => {
-    consoleSpy.mockRestore();
-  });
-
-  describe('with path argument', () => {
-    it('should initialize git-drive on specified path', async () => {
-      const drivePath = '/Volumes/TestDrive';
-      vol.fromJSON({
-        [drivePath]: '',
-      });
-
-      await init([drivePath]);
-
-      expect(mockSaveConfig).toHaveBeenCalledWith({ drivePath: expect.stringContaining('TestDrive') });
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Git Drive initialized'));
-    });
-
-    it('should throw error if path does not exist', async () => {
-      await expect(init(['/Volumes/NonExistent'])).rejects.toThrow(GitDriveError);
-      await expect(init(['/Volumes/NonExistent'])).rejects.toThrow('Path not found');
-    });
-
-    it('should throw error if path is not a directory', async () => {
-      vol.fromJSON({
-        '/Volumes/SomeFile': 'file content',
-      });
-
-      await expect(init(['/Volumes/SomeFile'])).rejects.toThrow('Path is not a directory');
-    });
-
-    it('should resolve relative paths', async () => {
-      vol.fromJSON({
-        '/current/dir/TestDrive': '',
-      });
-
-      // Mock cwd to return a specific directory
-      const originalCwd = process.cwd;
-      process.cwd = jest.fn(() => '/current/dir');
-
-      await init(['./TestDrive']);
-
-      expect(mockSaveConfig).toHaveBeenCalled();
-
-      process.cwd = originalCwd;
-    });
-  });
-
-  describe('without path argument (interactive)', () => {
-    it('should throw error when no drives found', async () => {
-      mockListDrives.mockResolvedValue([]);
-
-      await expect(init([])).rejects.toThrow('No external drives found');
-    });
-
-    it('should prompt user to select a drive', async () => {
-      mockListDrives.mockResolvedValue([
-        { mounted: '/Volumes/Drive1', filesystem: 'Drive1', blocks: 1000000, available: 500000 },
-        { mounted: '/Volumes/Drive2', filesystem: 'Drive2', blocks: 2000000, available: 1000000 },
-      ]);
-
-      mockPrompts.mockResolvedValue({
-        selectedDrive: '/Volumes/Drive1',
-      });
-
-      vol.fromJSON({
-        '/Volumes/Drive1': '',
-      });
-
-      await init([]);
-
-      expect(mockPrompts).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'select',
-          name: 'selectedDrive',
-        })
-      );
-    });
-
-    it('should handle user cancellation', async () => {
-      mockListDrives.mockResolvedValue([
-        { mounted: '/Volumes/Drive1', filesystem: 'Drive1', blocks: 1000000, available: 500000 },
-      ]);
-
-      mockPrompts.mockResolvedValue({
-        selectedDrive: undefined,
-      });
-
-      await init([]);
-
-      expect(consoleSpy).toHaveBeenCalledWith('Operation cancelled.');
-      expect(mockSaveConfig).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('store directory creation', () => {
-    it('should create .git-drive directory if it does not exist', async () => {
-      const drivePath = '/Volumes/TestDrive';
-      vol.fromJSON({
-        [drivePath]: '',
-      });
-
-      await init([drivePath]);
-
-      // The store path should have been requested
-      expect(mockGetDriveStorePath).toHaveBeenCalled();
-    });
-  });
-});

package/packages/cli/src/__tests__/commands/list.test.ts

@@ -1,118 +0,0 @@
-import { vol } from 'memfs';
-
-// Mock fs
-jest.mock('fs', () => {
-  const { fs } = require('memfs');
-  return fs;
-});
-
-// Mock node-disk-info
-jest.mock('node-disk-info', () => ({
-  getDiskInfo: jest.fn(),
-}));
-
-// Mock server
-jest.mock('../../server.js', () => ({
-  ensureServerRunning: jest.fn(),
-}));
-
-// Mock os
-jest.mock('os', () => ({
-  homedir: () => '/home/testuser',
-}));
-
-import { getDiskInfo } from 'node-disk-info';
-import { list } from '../../commands/list.js';
-
-const mockGetDiskInfo = getDiskInfo as jest.Mock;
-
-describe('list command', () => {
-  let consoleSpy: jest.SpyInstance;
-  const originalPlatform = process.platform;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    vol.reset();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-    Object.defineProperty(process, 'platform', { value: 'darwin', writable: true });
-  });
-
-  afterEach(() => {
-    consoleSpy.mockRestore();
-    Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true });
-  });
-
-  it('should display no drives message when no external drives found', async () => {
-    mockGetDiskInfo.mockResolvedValue([]);
-
-    vol.fromJSON({
-      '/home/testuser/.config/git-drive/links.json': '{}',
-    });
-
-    await list([]);
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No external drives detected'));
-  });
-
-  it('should list connected drives with git-drive status', async () => {
-    mockGetDiskInfo.mockResolvedValue([
-      { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 32000000, available: 16000000 },
-      { mounted: '/Volumes/External', filesystem: 'External', blocks: 1000000000, available: 500000000 },
-    ]);
-
-    vol.fromJSON({
-      '/home/testuser/.config/git-drive/links.json': '{}',
-      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
-      '/Volumes/External': '',
-    });
-
-    await list([]);
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('/Volumes/MyUSB'));
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('/Volumes/External'));
-  });
-
-  it('should count repositories on initialized drives', async () => {
-    mockGetDiskInfo.mockResolvedValue([
-      { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 32000000, available: 16000000 },
-    ]);
-
-    vol.fromJSON({
-      '/home/testuser/.config/git-drive/links.json': '{}',
-      '/Volumes/MyUSB/.git-drive/project1.git/HEAD': '',
-      '/Volumes/MyUSB/.git-drive/project2.git/HEAD': '',
-      '/Volumes/MyUSB/.git-drive/project3.git/HEAD': '',
-    });
-
-    await list([]);
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Repositories: 3'));
-  });
-
-  it('should display drive size in GB', async () => {
-    mockGetDiskInfo.mockResolvedValue([
-      { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 97656250, available: 50000000 },
-    ]);
-
-    vol.fromJSON({
-      '/home/testuser/.config/git-drive/links.json': '{}',
-      '/Volumes/MyUSB': '',
-    });
-
-    await list([]);
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('GB'));
-  });
-
-  it('should handle errors when detecting drives', async () => {
-    mockGetDiskInfo.mockRejectedValue(new Error('Failed to detect drives'));
-
-    vol.fromJSON({
-      '/home/testuser/.config/git-drive/links.json': '{}',
-    });
-
-    await list([]);
-
-    expect(consoleSpy).toHaveBeenCalledWith('Error detecting drives:', expect.any(Error));
-  });
-});

package/packages/cli/src/__tests__/commands/push.test.ts

@@ -1,155 +0,0 @@
-import { push } from '../../commands/push.js';
-import { GitDriveError } from '../../errors.js';
-import { vol } from 'memfs';
-
-// Mock fs
-jest.mock('fs', () => {
-  const { fs } = require('memfs');
-  return fs;
-});
-
-// Mock prompts
-jest.mock('prompts', () => ({
-  __esModule: true,
-  default: jest.fn(),
-}));
-
-// Mock git
-jest.mock('../../git.js', () => ({
-  git: jest.fn(),
-  getRemoteUrl: jest.fn(),
-  isGitRepo: jest.fn(),
-}));
-
-// Mock server
-jest.mock('../../server.js', () => ({
-  ensureServerRunning: jest.fn(),
-}));
-
-import prompts from 'prompts';
-import { git, getRemoteUrl, isGitRepo } from '../../git.js';
-
-const mockPrompts = prompts as unknown as jest.Mock;
-const mockGit = git as jest.Mock;
-const mockGetRemoteUrl = getRemoteUrl as jest.Mock;
-const mockIsGitRepo = isGitRepo as jest.Mock;
-
-describe('push command', () => {
-  let consoleSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    vol.reset();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-    mockIsGitRepo.mockReturnValue(true);
-    mockGetRemoteUrl.mockReturnValue('/Volumes/TestDrive/.git-drive/my-repo.git');
-    mockGit.mockImplementation((cmd: string) => {
-      if (cmd.includes('branch --show-current')) return 'main';
-      return '';
-    });
-  });
-
-  afterEach(() => {
-    consoleSpy.mockRestore();
-  });
-
-  it('should throw error when not in a git repository', async () => {
-    mockIsGitRepo.mockReturnValue(false);
-
-    await expect(push([])).rejects.toThrow(GitDriveError);
-    await expect(push([])).rejects.toThrow('Not in a git repository');
-  });
-
-  it('should throw error when no git-drive linked', async () => {
-    mockIsGitRepo.mockReturnValue(true);
-    mockGetRemoteUrl.mockReturnValue(null);
-
-    await expect(push([])).rejects.toThrow("No git-drive linked for this project");
-  });
-
-  describe('push modes', () => {
-    beforeEach(() => {
-      vol.fromJSON({
-        '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
-      });
-    });
-
-    it('should push current branch with --current flag', async () => {
-      await push(['--current']);
-
-      expect(mockGit).toHaveBeenCalledWith(expect.stringContaining('push gd main'));
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Successfully pushed'));
-    });
-
-    it('should push all branches and tags with --all flag', async () => {
-      await push(['--all']);
-
-      expect(mockGit).toHaveBeenCalledWith('push gd --all');
-      expect(mockGit).toHaveBeenCalledWith('push gd --tags');
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('all branches and tags'));
-    });
-
-    it('should prompt for push mode when no flags provided', async () => {
-      mockPrompts.mockResolvedValue({ pushMode: 'current' });
-
-      await push([]);
-
-      expect(mockPrompts).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'select',
-          name: 'pushMode',
-        })
-      );
-    });
-
-    it('should handle user cancellation in interactive mode', async () => {
-      mockPrompts.mockResolvedValue({ pushMode: undefined });
-
-      await push([]);
-
-      // Should not have pushed anything beyond the prompt
-      expect(mockGit).not.toHaveBeenCalledWith(expect.stringContaining('push gd'));
-    });
-  });
-
-  describe('pushlog', () => {
-    it('should write pushlog on successful push', async () => {
-      vol.fromJSON({
-        '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
-      });
-
-      await push(['--current']);
-
-      // Check that the pushlog file was created
-      const files = vol.toJSON();
-      const pushlogPath = '/Volumes/TestDrive/.git-drive/my-repo.git/git-drive-pushlog.json';
-      // The pushlog should exist if the remote URL path exists
-      // This is tested indirectly through the code path
-    });
-
-    it('should handle pushlog write errors silently', async () => {
-      // Create a scenario where writing the pushlog would fail
-      vol.fromJSON({
-        '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
-      });
-
-      // This should not throw even if pushlog writing fails
-      await expect(push(['--current'])).resolves.not.toThrow();
-    });
-  });
-
-  describe('error handling', () => {
-    it('should throw GitDriveError when git push fails', async () => {
-      vol.fromJSON({
-        '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
-      });
-
-      mockGit.mockImplementation((cmd: string) => {
-        if (cmd.includes('branch --show-current')) return 'main';
-        throw new Error('fatal: failed to push');
-      });
-
-      await expect(push(['--current'])).rejects.toThrow(GitDriveError);
-    });
-  });
-});

package/packages/cli/src/__tests__/commands/restore.test.ts

@@ -1,134 +0,0 @@
-import { restore } from '../../commands/restore.js';
-import { GitDriveError } from '../../errors.js';
-import { vol } from 'memfs';
-
-// Mock fs
-jest.mock('fs', () => {
-  const { fs } = require('memfs');
-  return fs;
-});
-
-// Mock config
-jest.mock('../../config.js', () => ({
-  requireConfig: jest.fn(),
-  assertDriveMounted: jest.fn(),
-  getDriveStorePath: jest.fn((drivePath: string) => `${drivePath}/.git-drive`),
-}));
-
-// Mock git
-jest.mock('../../git.js', () => ({
-  git: jest.fn(),
-}));
-
-// Mock server
-jest.mock('../../server.js', () => ({
-  ensureServerRunning: jest.fn(),
-}));
-
-import { git } from '../../git.js';
-import { requireConfig, assertDriveMounted } from '../../config.js';
-
-const mockGit = git as jest.Mock;
-const mockRequireConfig = requireConfig as jest.Mock;
-const mockAssertDriveMounted = assertDriveMounted as jest.Mock;
-
-describe('restore command', () => {
-  let consoleSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    vol.reset();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-    mockRequireConfig.mockReturnValue({ drivePath: '/Volumes/MyUSB' });
-    mockAssertDriveMounted.mockImplementation(() => {});
-    mockGit.mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    consoleSpy.mockRestore();
-  });
-
-  it('should throw error when no project name provided', () => {
-    expect(() => restore([])).toThrow(GitDriveError);
-    expect(() => restore([])).toThrow('Usage: git drive restore <project-name> [target-dir]');
-  });
-
-  it('should throw error when project not found on drive', () => {
-    vol.fromJSON({
-      '/Volumes/MyUSB/.git-drive': '',
-    });
-
-    expect(() => restore(['nonexistent-project'])).toThrow(GitDriveError);
-    expect(() => restore(['nonexistent-project'])).toThrow("Project 'nonexistent-project' not found on drive.");
-  });
-
-  it('should throw error when target directory already exists', () => {
-    vol.fromJSON({
-      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
-      '/home/user/my-project': '',
-    });
-
-    expect(() => restore(['my-project', '/home/user/my-project'])).toThrow(GitDriveError);
-    expect(() => restore(['my-project', '/home/user/my-project'])).toThrow('Directory already exists');
-  });
-
-  it('should clone the bare repo to target directory', () => {
-    vol.fromJSON({
-      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
-    });
-
-    restore(['my-project', '/home/user/restored-project']);
-
-    expect(mockGit).toHaveBeenCalledWith(
-      expect.stringContaining('clone /Volumes/MyUSB/.git-drive/my-project.git')
-    );
-  });
-
-  it('should rename origin remote to drive', () => {
-    vol.fromJSON({
-      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
-    });
-
-    restore(['my-project', '/home/user/restored-project']);
-
-    expect(mockGit).toHaveBeenCalledWith(
-      expect.stringContaining('remote rename origin drive'),
-      expect.any(String)
-    );
-  });
-
-  it('should use project name as target directory if not specified', () => {
-    vol.fromJSON({
-      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
-    });
-
-    restore(['my-project']);
-
-    // Should call git clone with the project name
-    expect(mockGit).toHaveBeenCalledWith(
-      expect.stringMatching(/clone.*my-project\.git/),
-      undefined
-    );
-  });
-
-  it('should log success message', () => {
-    vol.fromJSON({
-      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
-    });
-
-    restore(['my-project']);
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Restored'));
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('my-project'));
-  });
-
-  it('should work with custom target directory', () => {
-    vol.fromJSON({
-      '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
-    });
-
-    restore(['my-project', '/custom/target']);
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('/custom/target'));
-  });
-});