git-drive 0.1.6 → 0.1.7

package/dist/__tests__/config.test.js

@@ -1,150 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const memfs_1 = require("memfs");
-const path_1 = require("path");
-const config_js_1 = require("../config.js");
-// Mock fs and os modules
-jest.mock('fs', () => {
-    const { fs } = require('memfs');
-    return fs;
-});
-jest.mock('os', () => ({
-    homedir: () => '/home/testuser',
-}));
-describe('config', () => {
-    const configDir = '/home/testuser/.config/git-drive';
-    const configFile = (0, path_1.join)(configDir, 'config.json');
-    const linksFile = (0, path_1.join)(configDir, 'links.json');
-    beforeEach(() => {
-        memfs_1.vol.reset();
-    });
-    describe('loadConfig', () => {
-        it('should return null when config file does not exist', () => {
-            const result = (0, config_js_1.loadConfig)();
-            expect(result).toBeNull();
-        });
-        it('should load and parse valid config', () => {
-            const config = { drivePath: '/Volumes/TestDrive' };
-            memfs_1.vol.fromJSON({
-                [configFile]: JSON.stringify(config),
-            });
-            const result = (0, config_js_1.loadConfig)();
-            expect(result).toEqual(config);
-        });
-        it('should throw on malformed JSON', () => {
-            memfs_1.vol.fromJSON({
-                [configFile]: 'not valid json',
-            });
-            expect(() => (0, config_js_1.loadConfig)()).toThrow();
-        });
-    });
-    describe('saveConfig', () => {
-        it('should create config directory if it does not exist', () => {
-            const config = { drivePath: '/Volumes/MyDrive' };
-            (0, config_js_1.saveConfig)(config);
-            const files = memfs_1.vol.toJSON();
-            expect(files[configFile]).toBeDefined();
-        });
-        it('should save config with proper formatting', () => {
-            const config = { drivePath: '/Volumes/MyDrive' };
-            (0, config_js_1.saveConfig)(config);
-            const savedContent = memfs_1.vol.toJSON()[configFile];
-            expect(savedContent).toBe(JSON.stringify(config, null, 2) + '\n');
-        });
-        it('should overwrite existing config', () => {
-            const config1 = { drivePath: '/Volumes/Drive1' };
-            const config2 = { drivePath: '/Volumes/Drive2' };
-            (0, config_js_1.saveConfig)(config1);
-            (0, config_js_1.saveConfig)(config2);
-            const result = (0, config_js_1.loadConfig)();
-            expect(result).toEqual(config2);
-        });
-    });
-    describe('requireConfig', () => {
-        it('should return config when it exists', () => {
-            const config = { drivePath: '/Volumes/TestDrive' };
-            memfs_1.vol.fromJSON({
-                [configFile]: JSON.stringify(config),
-            });
-            const result = (0, config_js_1.requireConfig)();
-            expect(result).toEqual(config);
-        });
-        it('should throw GitDriveError when config does not exist', () => {
-            expect(() => (0, config_js_1.requireConfig)()).toThrow('No drive configured. Run: git drive init <path>');
-        });
-    });
-    describe('assertDriveMounted', () => {
-        it('should not throw when drive path exists', () => {
-            memfs_1.vol.fromJSON({
-                '/Volumes/TestDrive/.git-drive': '',
-            });
-            expect(() => (0, config_js_1.assertDriveMounted)('/Volumes/TestDrive')).not.toThrow();
-        });
-        it('should throw GitDriveError when drive path does not exist', () => {
-            expect(() => (0, config_js_1.assertDriveMounted)('/Volumes/NonExistent')).toThrow('Drive not found at /Volumes/NonExistent. Is it connected?');
-        });
-    });
-    describe('getDriveStorePath', () => {
-        it('should return the .git-drive path for a mountpoint', () => {
-            expect((0, config_js_1.getDriveStorePath)('/Volumes/MyDrive')).toBe('/Volumes/MyDrive/.git-drive');
-        });
-        it('should handle different path formats', () => {
-            expect((0, config_js_1.getDriveStorePath)('/mnt/usb')).toBe('/mnt/usb/.git-drive');
-        });
-    });
-    describe('loadLinks', () => {
-        it('should return empty object when links file does not exist', () => {
-            const result = (0, config_js_1.loadLinks)();
-            expect(result).toEqual({});
-        });
-        it('should load and parse valid links', () => {
-            const links = {
-                '/home/user/project1': {
-                    mountpoint: '/Volumes/Drive1',
-                    repoName: 'project1.git',
-                    linkedAt: '2024-01-01T00:00:00.000Z',
-                },
-            };
-            memfs_1.vol.fromJSON({
-                [linksFile]: JSON.stringify(links),
-            });
-            const result = (0, config_js_1.loadLinks)();
-            expect(result).toEqual(links);
-        });
-        it('should return empty object on malformed JSON', () => {
-            memfs_1.vol.fromJSON({
-                [linksFile]: 'invalid json',
-            });
-            const result = (0, config_js_1.loadLinks)();
-            expect(result).toEqual({});
-        });
-    });
-    describe('saveLink', () => {
-        it('should create links directory if it does not exist', () => {
-            (0, config_js_1.saveLink)('/home/user/project', '/Volumes/Drive', 'project.git');
-            const files = memfs_1.vol.toJSON();
-            expect(files[linksFile]).toBeDefined();
-        });
-        it('should save a new link', () => {
-            (0, config_js_1.saveLink)('/home/user/project', '/Volumes/Drive', 'project.git');
-            const result = (0, config_js_1.loadLinks)();
-            expect(result['/home/user/project']).toEqual({
-                mountpoint: '/Volumes/Drive',
-                repoName: 'project.git',
-                linkedAt: expect.any(String),
-            });
-        });
-        it('should update existing link', () => {
-            (0, config_js_1.saveLink)('/home/user/project', '/Volumes/Drive1', 'project.git');
-            (0, config_js_1.saveLink)('/home/user/project', '/Volumes/Drive2', 'project.git');
-            const result = (0, config_js_1.loadLinks)();
-            expect(result['/home/user/project'].mountpoint).toBe('/Volumes/Drive2');
-        });
-        it('should preserve other links when adding new one', () => {
-            (0, config_js_1.saveLink)('/home/user/project1', '/Volumes/Drive', 'project1.git');
-            (0, config_js_1.saveLink)('/home/user/project2', '/Volumes/Drive', 'project2.git');
-            const result = (0, config_js_1.loadLinks)();
-            expect(Object.keys(result)).toHaveLength(2);
-        });
-    });
-});

package/dist/__tests__/e2e.test.js

@@ -1,107 +0,0 @@
-"use strict";
-/**
- * E2E Tests for git-drive CLI
- *
- * These tests simulate full command workflows using mocked file systems
- * and git operations to test the complete flow of the CLI.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const memfs_1 = require("memfs");
-// Mock fs
-jest.mock('fs', () => {
-    const { fs } = require('memfs');
-    return fs;
-});
-// Mock child_process
-jest.mock('child_process', () => ({
-    execSync: jest.fn(),
-    spawn: jest.fn(() => ({
-        on: jest.fn(),
-        unref: jest.fn(),
-    })),
-}));
-// Mock node-disk-info
-jest.mock('node-disk-info', () => ({
-    getDiskInfo: jest.fn(),
-}));
-// Mock prompts
-jest.mock('prompts', () => ({
-    __esModule: true,
-    default: jest.fn(),
-}));
-// Mock os
-jest.mock('os', () => ({
-    homedir: () => '/home/testuser',
-    hostname: () => 'test-machine',
-    userInfo: () => ({ username: 'testuser' }),
-}));
-const node_disk_info_1 = require("node-disk-info");
-const child_process_1 = require("child_process");
-const mockExecSync = child_process_1.execSync;
-const mockGetDiskInfo = node_disk_info_1.getDiskInfo;
-describe('E2E: Full Workflow', () => {
-    let consoleSpy;
-    const originalPlatform = process.platform;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        memfs_1.vol.reset();
-        consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-        Object.defineProperty(process, 'platform', { value: 'darwin', writable: true });
-        mockGetDiskInfo.mockResolvedValue([
-            { mounted: '/Volumes/TestDrive', filesystem: 'TestDrive', blocks: 32000000, available: 16000000 },
-        ]);
-        mockExecSync.mockImplementation((cmd) => {
-            if (cmd.includes('rev-parse --show-toplevel'))
-                return '/home/testuser/my-project';
-            if (cmd.includes('branch --show-current'))
-                return 'main';
-            if (cmd.includes('rev-parse --is-inside-work-tree'))
-                return 'true';
-            return '';
-        });
-    });
-    afterEach(() => {
-        consoleSpy.mockRestore();
-        Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true });
-    });
-    describe('Complete Backup Workflow', () => {
-        it('should verify test infrastructure is working', async () => {
-            expect(true).toBe(true);
-        });
-        it('should mock disk info correctly', async () => {
-            const drives = await mockGetDiskInfo();
-            expect(drives).toHaveLength(1);
-            expect(drives[0].mounted).toBe('/Volumes/TestDrive');
-        });
-    });
-    describe('Error Recovery', () => {
-        it('should handle errors gracefully', async () => {
-            mockGetDiskInfo.mockRejectedValue(new Error('Failed to get drives'));
-            const drives = await mockGetDiskInfo().catch((e) => e.message);
-            expect(drives).toBe('Failed to get drives');
-        });
-    });
-    describe('Multi-Drive Support', () => {
-        it('should handle multiple drives', async () => {
-            mockGetDiskInfo.mockResolvedValue([
-                { mounted: '/Volumes/Drive1', filesystem: 'Drive1', blocks: 32000000, available: 16000000 },
-                { mounted: '/Volumes/Drive2', filesystem: 'Drive2', blocks: 64000000, available: 32000000 },
-            ]);
-            const drives = await mockGetDiskInfo();
-            expect(drives).toHaveLength(2);
-        });
-    });
-});
-describe('E2E: CLI Entry Point', () => {
-    it('should display help when no arguments provided', () => {
-        expect(true).toBe(true);
-    });
-    it('should display version with --version flag', () => {
-        expect(true).toBe(true);
-    });
-});
-describe('E2E: Server Startup', () => {
-    it('should start the web server', () => {
-        expect(true).toBe(true);
-    });
-});

package/dist/__tests__/errors.test.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_js_1 = require("../errors.js");
-describe('GitDriveError', () => {
-    it('should create an error with the correct message', () => {
-        const error = new errors_js_1.GitDriveError('Something went wrong');
-        expect(error).toBeInstanceOf(Error);
-        expect(error.message).toBe('Something went wrong');
-        expect(error.name).toBe('GitDriveError');
-    });
-    it('should create an error with an empty message', () => {
-        const error = new errors_js_1.GitDriveError('');
-        expect(error.message).toBe('');
-        expect(error.name).toBe('GitDriveError');
-    });
-});
-describe('handleError', () => {
-    let consoleSpy;
-    beforeEach(() => {
-        consoleSpy = jest.spyOn(console, 'error').mockImplementation();
-    });
-    afterEach(() => {
-        consoleSpy.mockRestore();
-    });
-    it('should handle GitDriveError', () => {
-        const error = new errors_js_1.GitDriveError('Custom git-drive error');
-        (0, errors_js_1.handleError)(error);
-        expect(consoleSpy).toHaveBeenCalledWith('error: Custom git-drive error');
-    });
-    it('should handle regular Error', () => {
-        const error = new Error('Regular error message');
-        (0, errors_js_1.handleError)(error);
-        expect(consoleSpy).toHaveBeenCalledWith('error: Regular error message');
-    });
-    it('should extract stderr from execSync error message', () => {
-        const error = new Error('Command failed: git push\nstderr: fatal: not a git repository');
-        (0, errors_js_1.handleError)(error);
-        expect(consoleSpy).toHaveBeenCalledWith('error: fatal: not a git repository');
-    });
-    it('should handle unknown error types', () => {
-        (0, errors_js_1.handleError)('string error');
-        expect(consoleSpy).toHaveBeenCalledWith('An unexpected error occurred.');
-    });
-    it('should handle null error', () => {
-        (0, errors_js_1.handleError)(null);
-        expect(consoleSpy).toHaveBeenCalledWith('An unexpected error occurred.');
-    });
-    it('should handle undefined error', () => {
-        (0, errors_js_1.handleError)(undefined);
-        expect(consoleSpy).toHaveBeenCalledWith('An unexpected error occurred.');
-    });
-    it('should handle object error', () => {
-        (0, errors_js_1.handleError)({ code: 'ERR_SOMETHING' });
-        expect(consoleSpy).toHaveBeenCalledWith('An unexpected error occurred.');
-    });
-});

package/dist/__tests__/git.test.js

@@ -1,184 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const git_js_1 = require("../git.js");
-// Mock child_process
-jest.mock('child_process', () => ({
-    execSync: jest.fn(),
-}));
-// Mock node-disk-info
-jest.mock('node-disk-info', () => ({
-    getDiskInfo: jest.fn(),
-}));
-const child_process_1 = require("child_process");
-const node_disk_info_1 = require("node-disk-info");
-const mockExecSync = child_process_1.execSync;
-const mockGetDiskInfo = node_disk_info_1.getDiskInfo;
-describe('git', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('git function', () => {
-        it('should execute git command and return trimmed output', () => {
-            mockExecSync.mockReturnValue('  output from git  \n');
-            const result = (0, git_js_1.git)('status --short');
-            expect(mockExecSync).toHaveBeenCalledWith('git status --short', {
-                cwd: undefined,
-                encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            expect(result).toBe('output from git');
-        });
-        it('should execute git command with cwd option', () => {
-            mockExecSync.mockReturnValue('output');
-            const result = (0, git_js_1.git)('status', '/path/to/repo');
-            expect(mockExecSync).toHaveBeenCalledWith('git status', {
-                cwd: '/path/to/repo',
-                encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            expect(result).toBe('output');
-        });
-        it('should propagate errors from git command', () => {
-            mockExecSync.mockImplementation(() => {
-                throw new Error('fatal: not a git repository');
-            });
-            expect(() => (0, git_js_1.git)('status')).toThrow('fatal: not a git repository');
-        });
-    });
-    describe('listDrives', () => {
-        const originalPlatform = process.platform;
-        afterEach(() => {
-            Object.defineProperty(process, 'platform', { value: originalPlatform });
-        });
-        it('should filter drives correctly on macOS', async () => {
-            Object.defineProperty(process, 'platform', { value: 'darwin' });
-            mockGetDiskInfo.mockResolvedValue([
-                { mounted: '/', filesystem: 'Macintosh HD', blocks: 500000000, available: 100000000 },
-                { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 32000000, available: 16000000 },
-                { mounted: '/Volumes/Recovery', filesystem: 'Recovery', blocks: 1000000, available: 500000 },
-                { mounted: '/Volumes/External', filesystem: 'External', blocks: 1000000000, available: 500000000 },
-            ]);
-            const result = await (0, git_js_1.listDrives)();
-            expect(result).toHaveLength(2);
-            expect(result.map((d) => d.mounted)).toEqual(['/Volumes/MyUSB', '/Volumes/External']);
-        });
-        it('should filter drives correctly on Linux', async () => {
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            mockGetDiskInfo.mockResolvedValue([
-                { mounted: '/', filesystem: 'root', blocks: 500000000, available: 100000000 },
-                { mounted: '/mnt/usb', filesystem: 'usbdrive', blocks: 32000000, available: 16000000 },
-                { mounted: '/sys', filesystem: 'sysfs', blocks: 0, available: 0 },
-                { mounted: '/proc', filesystem: 'proc', blocks: 0, available: 0 },
-                { mounted: '/run', filesystem: 'tmpfs', blocks: 1000000, available: 500000 },
-                { mounted: '/media/user/external', filesystem: 'external', blocks: 1000000000, available: 500000000 },
-            ]);
-            const result = await (0, git_js_1.listDrives)();
-            expect(result).toHaveLength(2);
-            expect(result.map((d) => d.mounted)).toEqual(['/mnt/usb', '/media/user/external']);
-        });
-        it('should filter out tmpfs and overlay filesystems', async () => {
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            mockGetDiskInfo.mockResolvedValue([
-                { mounted: '/mnt/real', filesystem: 'ext4', blocks: 1000000, available: 500000 },
-                { mounted: '/mnt/tmpfs', filesystem: 'tmpfs', blocks: 1000000, available: 500000 },
-                { mounted: '/mnt/devtmpfs', filesystem: 'devtmpfs', blocks: 1000000, available: 500000 },
-                { mounted: '/mnt/overlay', filesystem: 'overlay', blocks: 1000000, available: 500000 },
-                { mounted: '/mnt/udev', filesystem: 'udev', blocks: 1000000, available: 500000 },
-            ]);
-            const result = await (0, git_js_1.listDrives)();
-            expect(result).toHaveLength(1);
-            expect(result[0].mounted).toBe('/mnt/real');
-        });
-        it('should filter out drives without mountpoint', async () => {
-            Object.defineProperty(process, 'platform', { value: 'darwin' });
-            mockGetDiskInfo.mockResolvedValue([
-                { mounted: null, filesystem: 'nomount', blocks: 1000000, available: 500000 },
-                { mounted: '/Volumes/Valid', filesystem: 'valid', blocks: 1000000, available: 500000 },
-            ]);
-            const result = await (0, git_js_1.listDrives)();
-            expect(result).toHaveLength(1);
-        });
-        it('should filter out drives with mounted value of "100%"', async () => {
-            Object.defineProperty(process, 'platform', { value: 'darwin' });
-            mockGetDiskInfo.mockResolvedValue([
-                { mounted: '100%', filesystem: 'weird', blocks: 1000000, available: 500000 },
-                { mounted: '/Volumes/Valid', filesystem: 'valid', blocks: 1000000, available: 500000 },
-            ]);
-            const result = await (0, git_js_1.listDrives)();
-            expect(result).toHaveLength(1);
-        });
-        it('should return empty array when no drives match', async () => {
-            Object.defineProperty(process, 'platform', { value: 'darwin' });
-            mockGetDiskInfo.mockResolvedValue([
-                { mounted: '/', filesystem: 'system', blocks: 500000000, available: 100000000 },
-            ]);
-            const result = await (0, git_js_1.listDrives)();
-            expect(result).toHaveLength(0);
-        });
-        it('should filter out temporary paths with TemporaryItems', async () => {
-            Object.defineProperty(process, 'platform', { value: 'darwin' });
-            mockGetDiskInfo.mockResolvedValue([
-                { mounted: '/var/folders/2b/b7kfzb0s2v55m89_k9qvpj9w0000gn/T/TemporaryItems/NSIRD_screencaptureui_g99XDe', filesystem: 'tmpfs', blocks: 1000, available: 500 },
-            ]);
-            const result = await (0, git_js_1.listDrives)();
-            expect(result).toHaveLength(0);
-        });
-        it('should filter out /var/folders paths', async () => {
-            Object.defineProperty(process, 'platform', { value: 'darwin' });
-            mockGetDiskInfo.mockResolvedValue([
-                { mounted: '/var/folders/abc', filesystem: 'tmpfs', blocks: 1000, available: 500 },
-            ]);
-            const result = await (0, git_js_1.listDrives)();
-            expect(result).toHaveLength(0);
-        });
-    });
-    describe('getRepoRoot', () => {
-        it('should return the repo root path', () => {
-            mockExecSync.mockReturnValue('/path/to/repo\n');
-            const result = (0, git_js_1.getRepoRoot)();
-            expect(mockExecSync).toHaveBeenCalledWith('git rev-parse --show-toplevel', expect.any(Object));
-            expect(result).toBe('/path/to/repo');
-        });
-    });
-    describe('getProjectName', () => {
-        it('should return the basename of the repo root', () => {
-            mockExecSync.mockReturnValue('/path/to/my-project');
-            const result = (0, git_js_1.getProjectName)();
-            expect(result).toBe('my-project');
-        });
-        it('should handle nested paths', () => {
-            mockExecSync.mockReturnValue('/Users/developer/projects/awesome-app');
-            const result = (0, git_js_1.getProjectName)();
-            expect(result).toBe('awesome-app');
-        });
-    });
-    describe('getRemoteUrl', () => {
-        it('should return the remote URL if it exists', () => {
-            mockExecSync.mockReturnValue('/Volumes/MyDrive/.git-drive/my-project.git');
-            const result = (0, git_js_1.getRemoteUrl)('gd');
-            expect(mockExecSync).toHaveBeenCalledWith('git remote get-url gd', expect.any(Object));
-            expect(result).toBe('/Volumes/MyDrive/.git-drive/my-project.git');
-        });
-        it('should return null if remote does not exist', () => {
-            mockExecSync.mockImplementation(() => {
-                throw new Error('fatal: No such remote');
-            });
-            const result = (0, git_js_1.getRemoteUrl)('nonexistent');
-            expect(result).toBeNull();
-        });
-    });
-    describe('isGitRepo', () => {
-        it('should return true when in a git repository', () => {
-            mockExecSync.mockReturnValue('true');
-            const result = (0, git_js_1.isGitRepo)();
-            expect(result).toBe(true);
-        });
-        it('should return false when not in a git repository', () => {
-            mockExecSync.mockImplementation(() => {
-                throw new Error('fatal: not a git repository');
-            });
-            const result = (0, git_js_1.isGitRepo)();
-            expect(result).toBe(false);
-        });
-    });
-});