floatnote 1.0.0

package/tests/cli/floatnote.test.js

@@ -0,0 +1,167 @@
+// Tests for bin/floatnote.js CLI
+
+const fs = require('fs');
+const path = require('path');
+
+// Mock fs module
+jest.mock('fs', () => ({
+  existsSync: jest.fn(),
+  readFileSync: jest.fn(),
+  writeFileSync: jest.fn(),
+  mkdirSync: jest.fn(),
+  rmSync: jest.fn(),
+  unlinkSync: jest.fn(),
+  createWriteStream: jest.fn(() => ({
+    on: jest.fn((event, cb) => {
+      if (event === 'finish') setTimeout(cb, 0);
+      return { on: jest.fn() };
+    }),
+    close: jest.fn()
+  }))
+}));
+
+// Mock https module
+jest.mock('https', () => ({
+  get: jest.fn()
+}));
+
+// Mock child_process
+jest.mock('child_process', () => ({
+  spawn: jest.fn(() => ({
+    unref: jest.fn()
+  })),
+  execSync: jest.fn()
+}));
+
+describe('CLI utility functions', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Reset process.argv
+    process.argv = ['node', 'floatnote'];
+  });
+
+  describe('formatBytes', () => {
+    // We can't directly test formatBytes since it's not exported,
+    // but we can test it indirectly through the download progress
+    test('should handle byte formatting logic', () => {
+      // Test the logic that would be in formatBytes
+      const formatBytes = (bytes) => {
+        if (bytes < 1024) return bytes + ' B';
+        if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+        return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+      };
+
+      expect(formatBytes(500)).toBe('500 B');
+      expect(formatBytes(1024)).toBe('1.0 KB');
+      expect(formatBytes(1536)).toBe('1.5 KB');
+      expect(formatBytes(1048576)).toBe('1.0 MB');
+      expect(formatBytes(2621440)).toBe('2.5 MB');
+    });
+  });
+
+  describe('log function', () => {
+    test('should format log messages correctly', () => {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      // Test the log function logic
+      const log = (message) => {
+        console.log(`[floatnote] ${message}`);
+      };
+
+      log('test message');
+      expect(consoleSpy).toHaveBeenCalledWith('[floatnote] test message');
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('APP_DIR and paths', () => {
+    test('should use correct paths', () => {
+      const APP_NAME = 'Floatnote';
+      const APP_DIR = path.join(process.env.HOME, '.floatnote');
+      const APP_PATH = path.join(APP_DIR, `${APP_NAME}.app`);
+      const VERSION_FILE = path.join(APP_DIR, 'version');
+
+      expect(APP_DIR).toContain('.floatnote');
+      expect(APP_PATH).toContain('Floatnote.app');
+      expect(VERSION_FILE).toContain('version');
+    });
+  });
+});
+
+describe('CLI argument handling', () => {
+  test('--version flag should be recognized', () => {
+    const args = ['--version'];
+    expect(args.includes('--version') || args.includes('-v')).toBe(true);
+  });
+
+  test('-v flag should be recognized', () => {
+    const args = ['-v'];
+    expect(args.includes('--version') || args.includes('-v')).toBe(true);
+  });
+
+  test('--help flag should be recognized', () => {
+    const args = ['--help'];
+    expect(args.includes('--help') || args.includes('-h')).toBe(true);
+  });
+
+  test('-h flag should be recognized', () => {
+    const args = ['-h'];
+    expect(args.includes('--help') || args.includes('-h')).toBe(true);
+  });
+
+  test('--update flag should be recognized', () => {
+    const args = ['--update'];
+    expect(args.includes('--update')).toBe(true);
+  });
+
+  test('--uninstall flag should be recognized', () => {
+    const args = ['--uninstall'];
+    expect(args.includes('--uninstall')).toBe(true);
+  });
+});
+
+describe('GitHub API integration', () => {
+  test('should construct correct API URL', () => {
+    const GITHUB_REPO = 'josmanvis/floatnote';
+    const apiPath = `/repos/${GITHUB_REPO}/releases/latest`;
+    expect(apiPath).toBe('/repos/josmanvis/floatnote/releases/latest');
+  });
+
+  test('should use correct User-Agent header', () => {
+    const headers = { 'User-Agent': 'floatnote-cli' };
+    expect(headers['User-Agent']).toBe('floatnote-cli');
+  });
+});
+
+describe('File operations', () => {
+  test('should check if app directory exists', () => {
+    fs.existsSync.mockReturnValue(false);
+    const result = fs.existsSync('/mock/.floatnote');
+    expect(result).toBe(false);
+    expect(fs.existsSync).toHaveBeenCalled();
+  });
+
+  test('should create app directory if not exists', () => {
+    fs.existsSync.mockReturnValue(false);
+    fs.mkdirSync('/mock/.floatnote', { recursive: true });
+    expect(fs.mkdirSync).toHaveBeenCalledWith('/mock/.floatnote', { recursive: true });
+  });
+
+  test('should read version file', () => {
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue('v1.0.0');
+    const version = fs.readFileSync('/mock/.floatnote/version', 'utf8');
+    expect(version).toBe('v1.0.0');
+  });
+
+  test('should write version file', () => {
+    fs.writeFileSync('/mock/.floatnote/version', 'v1.0.1');
+    expect(fs.writeFileSync).toHaveBeenCalledWith('/mock/.floatnote/version', 'v1.0.1');
+  });
+
+  test('should remove directory on uninstall', () => {
+    fs.rmSync('/mock/.floatnote', { recursive: true });
+    expect(fs.rmSync).toHaveBeenCalledWith('/mock/.floatnote', { recursive: true });
+  });
+});

package/tests/main/main.test.js

@@ -0,0 +1,287 @@
+// Tests for src/main.js - Main Process
+
+describe('Main Process', () => {
+  let mockBrowserWindow;
+  let mockApp;
+  let mockDialog;
+  let mockScreen;
+  let mockShell;
+  let mockFs;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Create fresh mocks for each test
+    mockBrowserWindow = {
+      loadFile: jest.fn(),
+      show: jest.fn(),
+      hide: jest.fn(),
+      focus: jest.fn(),
+      close: jest.fn(),
+      destroy: jest.fn(),
+      isDestroyed: jest.fn(() => false),
+      isMinimized: jest.fn(() => false),
+      isVisible: jest.fn(() => true),
+      restore: jest.fn(),
+      setAlwaysOnTop: jest.fn(),
+      setVisibleOnAllWorkspaces: jest.fn(),
+      setVibrancy: jest.fn(),
+      setBackgroundColor: jest.fn(),
+      setBounds: jest.fn(),
+      getBounds: jest.fn(() => ({ x: 0, y: 0, width: 800, height: 600 })),
+      on: jest.fn(),
+      webContents: {
+        send: jest.fn()
+      }
+    };
+
+    mockApp = {
+      getPath: jest.fn((name) => {
+        if (name === 'userData') return '/mock/userData';
+        if (name === 'home') return '/mock/home';
+        return '/mock/path';
+      }),
+      requestSingleInstanceLock: jest.fn(() => true)
+    };
+
+    mockDialog = {
+      showMessageBox: jest.fn(() => Promise.resolve({ response: 0 })),
+      showSaveDialog: jest.fn(() => Promise.resolve({ canceled: false, filePath: '/test/path.png' }))
+    };
+
+    mockScreen = {
+      getCursorScreenPoint: jest.fn(() => ({ x: 500, y: 500 })),
+      getDisplayNearestPoint: jest.fn(() => ({
+        workAreaSize: { width: 1920, height: 1080 },
+        workArea: { x: 0, y: 0 }
+      }))
+    };
+
+    mockShell = {
+      openPath: jest.fn(() => Promise.resolve(''))
+    };
+
+    mockFs = {
+      existsSync: jest.fn(() => false),
+      readFileSync: jest.fn(() => '{}'),
+      writeFileSync: jest.fn(),
+      mkdirSync: jest.fn()
+    };
+  });
+
+  describe('Data storage paths', () => {
+    test('should use correct user data path', () => {
+      const userDataPath = mockApp.getPath('userData');
+      expect(userDataPath).toBe('/mock/userData');
+    });
+
+    test('should use correct home path', () => {
+      const homePath = mockApp.getPath('home');
+      expect(homePath).toBe('/mock/home');
+    });
+  });
+
+  describe('Single instance lock', () => {
+    test('should request single instance lock', () => {
+      const gotLock = mockApp.requestSingleInstanceLock();
+      expect(gotLock).toBe(true);
+    });
+  });
+
+  describe('Window creation', () => {
+    test('window should load correct file', () => {
+      mockBrowserWindow.loadFile('src/index.html');
+      expect(mockBrowserWindow.loadFile).toHaveBeenCalledWith('src/index.html');
+    });
+
+    test('window should set always on top', () => {
+      mockBrowserWindow.setAlwaysOnTop(true, 'floating', 1);
+      expect(mockBrowserWindow.setAlwaysOnTop).toHaveBeenCalledWith(true, 'floating', 1);
+    });
+
+    test('window should be visible on all workspaces', () => {
+      mockBrowserWindow.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+      expect(mockBrowserWindow.setVisibleOnAllWorkspaces).toHaveBeenCalledWith(true, { visibleOnFullScreen: true });
+    });
+  });
+
+  describe('IPC handlers', () => {
+    test('save-data handler should write file', () => {
+      const data = { notes: [], settings: {} };
+      mockFs.writeFileSync('/mock/userData/floatnote-data.json', JSON.stringify(data, null, 2));
+      expect(mockFs.writeFileSync).toHaveBeenCalled();
+    });
+
+    test('load-data handler should read file when exists', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue('{"notes":[],"settings":{}}');
+
+      if (mockFs.existsSync('/mock/userData/floatnote-data.json')) {
+        const data = mockFs.readFileSync('/mock/userData/floatnote-data.json', 'utf-8');
+        expect(data).toBeDefined();
+      }
+    });
+
+    test('load-data handler should return null when file does not exist', () => {
+      mockFs.existsSync.mockReturnValue(false);
+      const exists = mockFs.existsSync('/mock/userData/floatnote-data.json');
+      expect(exists).toBe(false);
+    });
+  });
+
+  describe('Export to ~/.floatnote', () => {
+    test('should create folder if not exists', () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const floatnoteFolder = '/mock/home/.floatnote';
+      if (!mockFs.existsSync(floatnoteFolder)) {
+        mockFs.mkdirSync(floatnoteFolder, { recursive: true });
+      }
+
+      expect(mockFs.mkdirSync).toHaveBeenCalledWith(floatnoteFolder, { recursive: true });
+    });
+
+    test('should write note file', () => {
+      const noteData = { id: '123', lines: [], textItems: [] };
+      const filePath = '/mock/home/.floatnote/note-123.json';
+      mockFs.writeFileSync(filePath, JSON.stringify(noteData, null, 2));
+      expect(mockFs.writeFileSync).toHaveBeenCalled();
+    });
+  });
+
+  describe('Open folder in Finder', () => {
+    test('should call shell.openPath', async () => {
+      const floatnoteFolder = '/mock/home/.floatnote';
+      await mockShell.openPath(floatnoteFolder);
+      expect(mockShell.openPath).toHaveBeenCalledWith(floatnoteFolder);
+    });
+  });
+
+  describe('Export PNG', () => {
+    test('should show save dialog', async () => {
+      await mockDialog.showSaveDialog(mockBrowserWindow, {
+        title: 'Export Note as PNG',
+        defaultPath: 'floatnote.png',
+        filters: [{ name: 'PNG Images', extensions: ['png'] }]
+      });
+      expect(mockDialog.showSaveDialog).toHaveBeenCalled();
+    });
+
+    test('should write PNG file', () => {
+      const base64Data = 'iVBORw0KGgo=';
+      mockFs.writeFileSync('/test/path.png', Buffer.from(base64Data, 'base64'));
+      expect(mockFs.writeFileSync).toHaveBeenCalled();
+    });
+  });
+
+  describe('Screen utilities', () => {
+    test('should get cursor screen point', () => {
+      const point = mockScreen.getCursorScreenPoint();
+      expect(point).toEqual({ x: 500, y: 500 });
+    });
+
+    test('should get display nearest to cursor', () => {
+      const point = mockScreen.getCursorScreenPoint();
+      const display = mockScreen.getDisplayNearestPoint(point);
+      expect(display.workAreaSize).toBeDefined();
+      expect(display.workArea).toBeDefined();
+    });
+  });
+
+  describe('Window size presets', () => {
+    test('should calculate small size (33% x 50%)', () => {
+      const screenWidth = 1920;
+      const screenHeight = 1080;
+      const newWidth = Math.round(screenWidth * 0.33);
+      const newHeight = Math.round(screenHeight * 0.5);
+      expect(newWidth).toBe(634);
+      expect(newHeight).toBe(540);
+    });
+
+    test('should calculate medium size (33% x 100%)', () => {
+      const screenWidth = 1920;
+      const screenHeight = 1080;
+      const newWidth = Math.round(screenWidth * 0.33);
+      const newHeight = screenHeight;
+      expect(newWidth).toBe(634);
+      expect(newHeight).toBe(1080);
+    });
+
+    test('should calculate large size (100% x 100%)', () => {
+      const screenWidth = 1920;
+      const screenHeight = 1080;
+      const newWidth = screenWidth;
+      const newHeight = screenHeight;
+      expect(newWidth).toBe(1920);
+      expect(newHeight).toBe(1080);
+    });
+  });
+
+  describe('Background modes', () => {
+    test('blur mode should set vibrancy', () => {
+      mockBrowserWindow.setVibrancy('fullscreen-ui');
+      mockBrowserWindow.setBackgroundColor('#00000000');
+      expect(mockBrowserWindow.setVibrancy).toHaveBeenCalledWith('fullscreen-ui');
+      expect(mockBrowserWindow.setBackgroundColor).toHaveBeenCalledWith('#00000000');
+    });
+
+    test('dark mode should clear vibrancy', () => {
+      mockBrowserWindow.setVibrancy(null);
+      mockBrowserWindow.setBackgroundColor('#00000000');
+      expect(mockBrowserWindow.setVibrancy).toHaveBeenCalledWith(null);
+    });
+
+    test('transparent mode should clear vibrancy', () => {
+      mockBrowserWindow.setVibrancy(null);
+      mockBrowserWindow.setBackgroundColor('#00000000');
+      expect(mockBrowserWindow.setVibrancy).toHaveBeenCalledWith(null);
+    });
+  });
+
+  describe('Left edge resize', () => {
+    test('should calculate new bounds correctly', () => {
+      const bounds = { x: 1000, y: 0, width: 400, height: 600 };
+      const deltaX = 50;
+      const minWidth = 200;
+      const newWidth = bounds.width - deltaX;
+
+      if (newWidth >= minWidth) {
+        const newBounds = {
+          x: bounds.x + deltaX,
+          y: bounds.y,
+          width: newWidth,
+          height: bounds.height
+        };
+        expect(newBounds.x).toBe(1050);
+        expect(newBounds.width).toBe(350);
+      }
+    });
+
+    test('should not resize below minimum width', () => {
+      const bounds = { x: 1000, y: 0, width: 250, height: 600 };
+      const deltaX = 100;
+      const minWidth = 200;
+      const newWidth = bounds.width - deltaX;
+
+      expect(newWidth).toBe(150);
+      expect(newWidth < minWidth).toBe(true);
+    });
+  });
+});
+
+describe('Dialog interactions', () => {
+  test('close confirmation dialog should have correct options', async () => {
+    const mockDialog = {
+      showMessageBox: jest.fn(() => Promise.resolve({ response: 0 }))
+    };
+
+    const result = await mockDialog.showMessageBox({}, {
+      type: 'warning',
+      buttons: ['Close', 'Cancel'],
+      defaultId: 1,
+      title: 'Close Floatnote?',
+      message: 'Are you sure you want to close Floatnote?'
+    });
+    expect(result.response).toBe(0);
+  });
+});

package/tests/mocks/electron.js

@@ -0,0 +1,126 @@
+// Mock Electron for testing
+
+const mockBrowserWindow = {
+  loadFile: jest.fn(),
+  show: jest.fn(),
+  hide: jest.fn(),
+  focus: jest.fn(),
+  close: jest.fn(),
+  destroy: jest.fn(),
+  isDestroyed: jest.fn(() => false),
+  isMinimized: jest.fn(() => false),
+  isVisible: jest.fn(() => true),
+  restore: jest.fn(),
+  setAlwaysOnTop: jest.fn(),
+  setVisibleOnAllWorkspaces: jest.fn(),
+  setVibrancy: jest.fn(),
+  setBackgroundColor: jest.fn(),
+  setBounds: jest.fn(),
+  getBounds: jest.fn(() => ({ x: 0, y: 0, width: 800, height: 600 })),
+  on: jest.fn(),
+  webContents: {
+    send: jest.fn()
+  }
+};
+
+const BrowserWindow = jest.fn(() => mockBrowserWindow);
+BrowserWindow.fromWebContents = jest.fn(() => mockBrowserWindow);
+
+const mockTray = {
+  setToolTip: jest.fn(),
+  on: jest.fn(),
+  popUpContextMenu: jest.fn()
+};
+
+const Tray = jest.fn(() => mockTray);
+
+const Menu = {
+  buildFromTemplate: jest.fn(() => ({}))
+};
+
+const nativeImage = {
+  createFromDataURL: jest.fn(() => ({
+    setTemplateImage: jest.fn()
+  }))
+};
+
+const dialog = {
+  showMessageBox: jest.fn(() => Promise.resolve({ response: 0 })),
+  showSaveDialog: jest.fn(() => Promise.resolve({ canceled: false, filePath: '/test/path.png' }))
+};
+
+const ipcMain = {
+  on: jest.fn(),
+  handle: jest.fn()
+};
+
+const ipcRenderer = {
+  on: jest.fn(),
+  send: jest.fn(),
+  invoke: jest.fn(() => Promise.resolve({ success: true }))
+};
+
+const globalShortcut = {
+  register: jest.fn(),
+  unregisterAll: jest.fn()
+};
+
+const screen = {
+  getCursorScreenPoint: jest.fn(() => ({ x: 500, y: 500 })),
+  getDisplayNearestPoint: jest.fn(() => ({
+    workAreaSize: { width: 1920, height: 1080 },
+    workArea: { x: 0, y: 0 }
+  }))
+};
+
+const shell = {
+  openPath: jest.fn(() => Promise.resolve(''))
+};
+
+const clipboard = {
+  availableFormats: jest.fn(() => []),
+  readImage: jest.fn(() => ({
+    isEmpty: jest.fn(() => true),
+    toDataURL: jest.fn(() => ''),
+    getSize: jest.fn(() => ({ width: 0, height: 0 }))
+  })),
+  readText: jest.fn(() => '')
+};
+
+const contextBridge = {
+  exposeInMainWorld: jest.fn()
+};
+
+const app = {
+  getPath: jest.fn((name) => {
+    if (name === 'userData') return '/mock/userData';
+    if (name === 'home') return '/mock/home';
+    return '/mock/path';
+  }),
+  whenReady: jest.fn(() => Promise.resolve()),
+  on: jest.fn(),
+  quit: jest.fn(),
+  requestSingleInstanceLock: jest.fn(() => true),
+  dock: {
+    setIcon: jest.fn()
+  }
+};
+
+module.exports = {
+  app,
+  BrowserWindow,
+  Tray,
+  Menu,
+  nativeImage,
+  dialog,
+  ipcMain,
+  ipcRenderer,
+  globalShortcut,
+  screen,
+  shell,
+  clipboard,
+  contextBridge,
+  // Export mocks for direct access in tests
+  mockBrowserWindow,
+  mockTray
+};

package/tests/mocks/fs.js

@@ -0,0 +1,17 @@
+// Mock fs module for testing
+
+const mockFs = {
+  existsSync: jest.fn(() => false),
+  readFileSync: jest.fn(() => '{}'),
+  writeFileSync: jest.fn(),
+  mkdirSync: jest.fn(),
+  rmSync: jest.fn(),
+  unlinkSync: jest.fn(),
+  readdirSync: jest.fn(() => []),
+  statSync: jest.fn(() => ({
+    isDirectory: jest.fn(() => false),
+    isFile: jest.fn(() => true)
+  }))
+};
+
+module.exports = mockFs;