logancyang_obsidian-copilot/tests/encryptionService.test.ts

import EncryptionService from '@/encryptionService';
import { CopilotSettings } from '@/settings/SettingsPage';
import { Platform } from 'obsidian';

// Mocking Electron's safeStorage
jest.mock('electron', () => {
  return {
    remote: {
      safeStorage: {
        encryptString: jest.fn().mockImplementation((text) => `encrypted_${text}`),
        decryptString: jest.fn().mockImplementation((buffer) => buffer.toString().replace('encrypted_', '')),
        isEncryptionAvailable: jest.fn().mockReturnValue(true),
      },
    },
  }
});

describe('Platform-specific Tests', () => {
  it('should recognize the platform as desktop', () => {
    expect(Platform.isDesktop).toBe(true); // Directly using the mocked value
  });

  // Example of a conditional test based on the platform
  it('should only run certain logic on desktop', () => {
    if (Platform.isDesktop) {
      // Your desktop-specific logic here
      expect(true).toBe(true); // Replace with actual assertions
    } else {
      expect(true).toBe(false); // This line is just for demonstration and should be replaced
    }
  });
});

interface TestSettings extends CopilotSettings {
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  [key: string]: any;
}

describe('EncryptionService', () => {
  let service: EncryptionService;
  let settings: TestSettings;

  beforeEach(() => {
    jest.resetModules();
    settings = {
      enableEncryption: true,
      // Add other necessary settings here
    } as CopilotSettings;
    service = new EncryptionService(settings);
  });

  describe('getEncryptedKey', () => {
    it('should encrypt an API key', () => {
      const apiKey = 'testApiKey';
      const encryptedKey = service.getEncryptedKey(apiKey);
      expect(encryptedKey).toBe(`enc_encrypted_${apiKey}`);
    });

    it('should return the original key if encryption is not enabled', () => {
      settings.enableEncryption = false;
      const apiKey = 'testApiKey';
      const encryptedKey = service.getEncryptedKey(apiKey);
      expect(encryptedKey).toBe(apiKey);
    });

    it('should return the original key if already encrypted', () => {
      const apiKey = 'enc_testApiKey';
      const encryptedKey = service.getEncryptedKey(apiKey);
      expect(encryptedKey).toBe(apiKey);
    });
  });

  describe('getDecryptedKey', () => {
    it('should decrypt an encrypted API key', () => {
      const apiKey = 'testApiKey';
      const mockEncryptedKey = `encrypted_${apiKey}`;
      const base64Encoded = Buffer.from(mockEncryptedKey).toString('base64');
      const encryptedKey = `enc_${base64Encoded}`;

      const decryptedKey = service.getDecryptedKey(encryptedKey);
      expect(decryptedKey).toBe(apiKey);
    });

    it('should return the original key if it is in plain text', () => {
      const apiKey = 'testApiKey';
      const decryptedKey = service.getDecryptedKey(apiKey);
      expect(decryptedKey).toBe(apiKey);
    });
  });

  describe('encryptAllKeys', () => {
    beforeEach(() => {
      settings = {
        enableEncryption: true,
        someApiKey: 'testApiKey',
        anotherApiKey: 'anotherTestApiKey',
        nonKey: 'shouldBeIgnored',
      } as unknown as CopilotSettings;
      service = new EncryptionService(settings);
    });

    it('should encrypt all keys containing "apikey"', () => {
      service.encryptAllKeys();
      expect(settings.someApiKey).toBe('enc_encrypted_testApiKey');
      expect(settings.anotherApiKey).toBe('enc_encrypted_anotherTestApiKey');
      expect(settings.nonApiKey).toBe(undefined);
    });

    it('should not encrypt keys when encryption is not enabled', () => {
      settings.enableEncryption = false;
      service.encryptAllKeys();
      expect(settings.someApiKey).toBe('testApiKey');
      expect(settings.anotherApiKey).toBe('anotherTestApiKey');
    });
  });
});