Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
14 changes: 12 additions & 2 deletions packages/sdk/electron/__tests__/index.test.ts
Original file line number Diff line number Diff line change
@@ -1,3 +1,13 @@
it('can run tests', () => {
expect(true).toBe(true);
import type { LDElectronStorage } from '../src';

it('exports the LDElectronStorage type for custom storage implementations', () => {
const storage: LDElectronStorage = {
get: async () => null,
set: async () => undefined,
clear: async () => undefined,
};

expect(typeof storage.get).toBe('function');
expect(typeof storage.set).toBe('function');
expect(typeof storage.clear).toBe('function');
});
83 changes: 83 additions & 0 deletions packages/sdk/electron/__tests__/options.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -141,3 +141,86 @@ it('filters to base options', () => {
expect(logger.warn).not.toHaveBeenCalled();
expect(logger.error).not.toHaveBeenCalled();
});

it('applies a custom storage implementation with get, set and clear functions', () => {
const logger = createMockLogger();
const storage = { get: jest.fn(), set: jest.fn(), clear: jest.fn() };

const opts = validateOptions({ storage }, logger);

expect(opts.storage).toBe(storage);
expect(logger.warn).not.toHaveBeenCalled();
});

it('leaves storage undefined by default', () => {
const logger = createMockLogger();
const opts = validateOptions({}, logger);

expect(opts.storage).toBeUndefined();
});

it('warns and falls back to the default storage when storage is not an object', () => {
const logger = createMockLogger();

// @ts-ignore
const opts = validateOptions({ storage: 'disk' }, logger);

expect(opts.storage).toBeUndefined();
expect(logger.warn).toHaveBeenCalledWith(
'Config option "storage" should be of type LDElectronStorage ({ get, set, clear }), got string, using default value',
);
});

it('warns and falls back to the default storage when storage lacks the required functions', () => {
const logger = createMockLogger();

// @ts-ignore
const opts = validateOptions({ storage: { get: jest.fn() } }, logger);

expect(opts.storage).toBeUndefined();
expect(logger.warn).toHaveBeenCalledWith(
'Config option "storage" should be of type LDElectronStorage ({ get, set, clear }), got object, using default value',
);
});

it('applies encryptStorage when set', () => {
const logger = createMockLogger();
const opts = validateOptions({ encryptStorage: true }, logger);

expect(opts.encryptStorage).toBe(true);
expect(logger.warn).not.toHaveBeenCalled();
});

it('defaults encryptStorage to false', () => {
const logger = createMockLogger();
const opts = validateOptions({}, logger);

expect(opts.encryptStorage).toBe(false);
});

it('warns for invalid encryptStorage type', () => {
const logger = createMockLogger();

validateOptions(
{
// @ts-ignore
encryptStorage: 'yes',
},
logger,
);

expect(logger.warn).toHaveBeenCalledWith(
'Config option "encryptStorage" should be of type boolean, got string, using default value',
);
});

it('warns that encryptStorage has no effect when a custom storage is provided', () => {
const logger = createMockLogger();
const storage = { get: jest.fn(), set: jest.fn(), clear: jest.fn() };

const opts = validateOptions({ storage, encryptStorage: true }, logger);

expect(opts.storage).toBe(storage);
expect(logger.warn).toHaveBeenCalledTimes(1);
expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('encryptStorage'));
});
18 changes: 18 additions & 0 deletions packages/sdk/electron/__tests__/platform/ElectronInfo.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -88,3 +88,21 @@ describe('given an information instance with mock data', () => {
expect(data.os?.name).toEqual(processed);
});
});

describe('given a wrapper name and version', () => {
it('includes them in sdkData', () => {
const info = new ElectronInfo({ wrapperName: 'my-wrapper', wrapperVersion: '1.2.3' });

const sdkInfo = info.sdkData();
expect(sdkInfo.wrapperName).toEqual('my-wrapper');
expect(sdkInfo.wrapperVersion).toEqual('1.2.3');
});

it('omits them from sdkData when not provided', () => {
const info = new ElectronInfo();

const sdkInfo = info.sdkData();
expect(sdkInfo.wrapperName).toBeUndefined();
expect(sdkInfo.wrapperVersion).toBeUndefined();
});
});
121 changes: 98 additions & 23 deletions packages/sdk/electron/__tests__/platform/ElectronPlatform.test.ts
Original file line number Diff line number Diff line change
@@ -1,16 +1,17 @@
import type { LDLogger } from '@launchdarkly/js-client-sdk-common';

import ElectronInfo from '../../src/platform/ElectronInfo';
import ElectronPlatform from '../../src/platform/ElectronPlatform';
import ElectronRequests from '../../src/platform/ElectronRequests';
import { getElectronStorage } from '../../src/platform/ElectronStorage';

const failingStorage = {
get: jest.fn().mockRejectedValue(new Error('disk read failed')),
set: jest.fn().mockRejectedValue(new Error('disk write failed')),
clear: jest.fn().mockRejectedValue(new Error('disk clear failed')),
};
const storageInstance = { get: jest.fn(), set: jest.fn(), clear: jest.fn() };

jest.mock('../../src/platform/ElectronStorage', () => ({
getElectronStorage: () => failingStorage,
getElectronStorage: jest.fn(() => storageInstance),
}));
jest.mock('../../src/platform/ElectronInfo');
jest.mock('../../src/platform/ElectronRequests');

const logger: LDLogger = {
debug: jest.fn(),
Expand All @@ -19,34 +20,108 @@ const logger: LDLogger = {
error: jest.fn(),
};

let platform: ElectronPlatform;

beforeEach(() => {
jest.clearAllMocks();
platform = new ElectronPlatform(logger, {});
});

it('logs error and returns null when storage get fails', async () => {
const result = await platform.storage!.get('some-key');
it('uses the shared ElectronStorage singleton without encryption by default', () => {
const platform = new ElectronPlatform(logger, {});

expect(result).toBeNull();
expect(logger.error).toHaveBeenCalledWith(
expect.stringContaining('Error getting key from storage: some-key'),
);
expect(getElectronStorage).toHaveBeenCalledWith(logger, { encrypt: false });
expect(platform.storage).toBe(storageInstance);
});

it('logs error and swallows when storage set fails', async () => {
await platform.storage!.set('some-key', 'some-value');
it('requests an encrypted shared cache when encryptStorage is true', () => {
// eslint-disable-next-line no-new
new ElectronPlatform(logger, { encryptStorage: true });

expect(logger.error).toHaveBeenCalledWith(
expect.stringContaining('Error setting key in storage: some-key'),
);
expect(getElectronStorage).toHaveBeenCalledWith(logger, { encrypt: true });
});

it('ignores encryptStorage when a custom storage is provided', async () => {
const customStorage = {
get: jest.fn().mockResolvedValue(null),
set: jest.fn().mockResolvedValue(undefined),
clear: jest.fn().mockResolvedValue(undefined),
};

const platform = new ElectronPlatform(logger, { storage: customStorage, encryptStorage: true });
await platform.storage.set('k', 'v');

expect(customStorage.set).toHaveBeenCalledWith('k', 'v');
expect(getElectronStorage).not.toHaveBeenCalled();
});

it('threads wrapperName/wrapperVersion into ElectronInfo', () => {
// eslint-disable-next-line no-new
new ElectronPlatform(logger, { wrapperName: 'my-wrapper', wrapperVersion: '1.2.3' });

expect(ElectronInfo).toHaveBeenCalledWith({
wrapperName: 'my-wrapper',
wrapperVersion: '1.2.3',
});
});

it('constructs ElectronRequests with enableEventCompression', () => {
// eslint-disable-next-line no-new
new ElectronPlatform(logger, {
enableEventCompression: true,
});

expect(ElectronRequests).toHaveBeenCalledWith(true);
});

it('logs error and swallows when storage clear fails', async () => {
await platform.storage!.clear('some-key');
it('uses the custom storage and never creates the built-in storage when storage is provided', async () => {
const customStorage = {
get: jest.fn().mockResolvedValue('custom-value'),
set: jest.fn().mockResolvedValue(undefined),
clear: jest.fn().mockResolvedValue(undefined),
};

const platform = new ElectronPlatform(logger, { storage: customStorage });

await expect(platform.storage.get('test-key')).resolves.toBe('custom-value');
await platform.storage.set('test-key', 'val');
await platform.storage.clear('test-key');

expect(customStorage.get).toHaveBeenCalledWith('test-key');
expect(customStorage.set).toHaveBeenCalledWith('test-key', 'val');
expect(customStorage.clear).toHaveBeenCalledWith('test-key');
expect(getElectronStorage).not.toHaveBeenCalled();
});

it('logs errors from the custom storage and keeps running', async () => {
const failingStorage = {
get: jest.fn().mockRejectedValue(new Error('custom get failed')),
set: jest.fn().mockRejectedValue(new Error('custom set failed')),
clear: jest.fn().mockRejectedValue(new Error('custom clear failed')),
};

const platform = new ElectronPlatform(logger, { storage: failingStorage });

await expect(platform.storage.get('key')).resolves.toBeNull();
await expect(platform.storage.set('key', 'val')).resolves.toBeUndefined();
await expect(platform.storage.clear('key')).resolves.toBeUndefined();

expect(logger.error).toHaveBeenCalledWith(
expect.stringContaining('Error clearing key from storage: some-key'),
expect.stringContaining('Error getting key from storage: key'),
);
expect(logger.error).toHaveBeenCalledWith(
expect.stringContaining('Error setting key in storage: key'),
);
expect(logger.error).toHaveBeenCalledWith(
expect.stringContaining('Error clearing key from storage: key'),
);
});

it('returns null when the custom storage resolves a non-string value', async () => {
const oddStorage = {
get: jest.fn().mockResolvedValue(42),
set: jest.fn().mockResolvedValue(undefined),
clear: jest.fn().mockResolvedValue(undefined),
};

const platform = new ElectronPlatform(logger, { storage: oddStorage });

await expect(platform.storage.get('key')).resolves.toBeNull();
});
Loading
Loading