bluewallet/react-native-default-preference
bluewallet/react-native-default-preference
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Static

Browse Source
This commit is contained in:
Marcos Rodriguez Velez 2024-11-19 22:00:23 -04:00
parent 55e6038026
commit 018e4dc39f
6 changed files with 140 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
__mocks__/react-native-default-preference.js vendored
View File

@ -9,38 +9,42 @@ const getSuite = (name) => {
const DefaultPreference = {
setName: jest.fn((name) => {
// Initialize suite if not present
if (!mockPreferences[name]) {
mockPreferences[name] = {};
}
return Promise.resolve();
}),
getName: jest.fn(() => {
return Promise.resolve('default'); // Default suite
getName: jest.fn((name) => {
return Promise.resolve(name || 'default'); // Return provided name or 'default'
}),
get: jest.fn((name, key) => {
const suite = getSuite(name);
const suite = getSuite(name || 'default');
return Promise.resolve(suite.hasOwnProperty(key) ? suite[key] : null);
}),
set: jest.fn((name, key, value) => {
const suite = getSuite(name);
const suite = getSuite(name || 'default');
suite[key] = value;
return Promise.resolve();
}),
clear: jest.fn((name, key) => {
const suite = getSuite(name);
const suite = getSuite(name || 'default');
delete suite[key];
return Promise.resolve();
}),
getMultiple: jest.fn((name, keys) => {
const suite = getSuite(name);
const suite = getSuite(name || 'default');
const values = keys.map(key => (suite.hasOwnProperty(key) ? suite[key] : null));
return Promise.resolve(values);
}),
setMultiple: jest.fn((name, keyValuePairs) => {
const suite = getSuite(name);
const suite = getSuite(name || 'default');
Object.entries(keyValuePairs).forEach(([key, value]) => {
suite[key] = value;
});
@ -48,20 +52,25 @@ const DefaultPreference = {
}),
clearMultiple: jest.fn((name, keys) => {
const suite = getSuite(name);
const suite = getSuite(name || 'default');
keys.forEach(key => delete suite[key]);
return Promise.resolve();
}),
getAll: jest.fn((name) => {
const suite = getSuite(name);
const suite = getSuite(name || 'default');
return Promise.resolve({ ...suite });
}),
clearAll: jest.fn((name) => {
mockPreferences[name] = {};
mockPreferences[name || 'default'] = {};
return Promise.resolve();
}),
// Add reset method to clear all suites
reset: jest.fn(() => {
mockPreferences = {};
}),
};
module.exports = DefaultPreference;

4
android/src/main/java/com/kevinresol/react_native_default_preference/RNDefaultPreferenceModule.java
View File

@ -23,13 +23,13 @@ import java.util.Map;
public class RNDefaultPreferenceModule extends ReactContextBaseJavaModule {
private String preferencesName;
private final ReactApplicationContext reactContext;
private final DataStore<Preferences> dataStore;
private DataStore<Preferences> dataStore;
public RNDefaultPreferenceModule(ReactApplicationContext reactContext) {
super(reactContext);
this.reactContext = reactContext;
this.preferencesName = reactContext.getPackageName() + "_preferences";
this.dataStore = reactContext.createDataStore(name = preferencesName);
this.dataStore = reactContext.createDataStore(preferencesName); // Corrected method call
}
@Override

86
index.test.ts
View File

@ -34,90 +34,112 @@ describe.each(['ios', 'android'])('DefaultPreference on %s', (platform) => {
(Platform as any).OS = platform;
});
let defaultPref: DefaultPreference;
beforeEach(() => {
jest.clearAllMocks();
// Reset mockPreferences by clearing all data for 'default' suite
mockDefaultPreference.reset(); // Reset all mock preferences
RNDefaultPreference.clearAll('default');
defaultPref = new DefaultPreference();
});
it('should set and get a value for the default instance', async () => {
await defaultPref.set('key1', 'value1');
const value = await defaultPref.get('key1');
await DefaultPreference.set('key1', 'value1');
const value = await DefaultPreference.get('key1');
expect(value).toBe('value1');
});
it('should set and get a value for the group instance', async () => {
const groupPref = new DefaultPreference('group.reactnative.example');
await groupPref.set('key1', 'value1');
const value = await groupPref.get('key1');
await DefaultPreference.setGroupName('group.reactnative.example');
await DefaultPreference.set('key1', 'value1');
const value = await DefaultPreference.get('key1');
expect(value).toBe('value1');
});
it('should clear a value for the default instance', async () => {
await defaultPref.set('key2', 'value2');
await defaultPref.clear('key2');
const value = await defaultPref.get('key2');
await DefaultPreference.set('key2', 'value2');
await DefaultPreference.clear('key2');
const value = await DefaultPreference.get('key2');
expect(value).toBeNull();
});
it('should clear a value for the group instance', async () => {
const groupPref = new DefaultPreference('group.reactnative.example');
await groupPref.set('key2', 'value2');
await groupPref.clear('key2');
const value = await groupPref.get('key2');
await DefaultPreference.setGroupName('group.reactnative.example');
await DefaultPreference.set('key2', 'value2');
await DefaultPreference.clear('key2');
const value = await DefaultPreference.get('key2');
expect(value).toBeNull();
});
it('should set and get multiple values for the default instance', async () => {
const data = { key3: 'value3', key4: 'value4' };
await defaultPref.setMultiple(data);
const values = await defaultPref.getMultiple(['key3', 'key4']);
await DefaultPreference.setMultiple(data);
const values = await DefaultPreference.getMultiple(['key3', 'key4']);
expect(values).toEqual(['value3', 'value4']);
});
it('should clear multiple values for the default instance', async () => {
const data = { key5: 'value5', key6: 'value6' };
await defaultPref.setMultiple(data);
await defaultPref.clearMultiple(['key5', 'key6']);
const values = await defaultPref.getMultiple(['key5', 'key6']);
await DefaultPreference.setMultiple(data);
await DefaultPreference.clearMultiple(['key5', 'key6']);
const values = await DefaultPreference.getMultiple(['key5', 'key6']);
expect(values).toEqual([null, null]);
});
it('should get all values for the default instance', async () => {
const data = { key7: 'value7', key8: 'value8' };
await defaultPref.setMultiple(data);
const allValues = await defaultPref.getAll();
await DefaultPreference.setMultiple(data);
const allValues = await DefaultPreference.getAll();
expect(allValues).toEqual(data);
});
it('should clear all values for the default instance', async () => {
const data = { key9: 'value9', key10: 'value10' };
await defaultPref.setMultiple(data);
await defaultPref.clearAll();
const allValues = await defaultPref.getAll();
await DefaultPreference.setMultiple(data);
await DefaultPreference.clearAll();
const allValues = await DefaultPreference.getAll();
expect(allValues).toEqual({});
});
it('should not set the name if no name is provided', () => {
const instance = new DefaultPreference();
expect(RNDefaultPreference.setName).not.toHaveBeenCalled();
});
it('should set the name if a name is provided', () => {
const instance = new DefaultPreference('group.reactnative.example');
it('should set the name if a name is provided', async () => {
await DefaultPreference.setGroupName('group.reactnative.example');
expect(RNDefaultPreference.setName).toHaveBeenCalledWith('group.reactnative.example');
});
it('should not call setName if name is default', () => {
new DefaultPreference();
expect(RNDefaultPreference.setName).not.toHaveBeenCalled();
});
it('should call setName if name is not default', () => {
new DefaultPreference('customName');
it('should call setName if name is not default', async () => {
await DefaultPreference.setGroupName('customName');
expect(RNDefaultPreference.setName).toHaveBeenCalledWith('customName');
});
it('should handle multiple group names correctly', async () => {
await DefaultPreference.setGroupName('group1');
await DefaultPreference.set('key1', 'value1');
const value1 = await DefaultPreference.get('key1');
await DefaultPreference.setGroupName('group2');
await DefaultPreference.set('key1', 'value2');
const value2 = await DefaultPreference.get('key1');
expect(value1).toBe('value1');
expect(value2).toBe('value2');
});
it('should get the current group name', async () => {
// Arrange
const currentGroupName = 'testGroup';
mockDefaultPreference.getName.mockResolvedValue(currentGroupName);
// Act
await DefaultPreference.setGroupName(currentGroupName);
const groupName = await DefaultPreference.getGroupName();
// Assert
expect(RNDefaultPreference.setName).toHaveBeenCalledWith(currentGroupName);
expect(groupName).toBe(currentGroupName);
});
});

42
index.ts
View File

@ -7,49 +7,49 @@ export interface RNDefaultPreferenceKeys {
}
class DefaultPreference {
private readonly name: string;
private static groupName: string = 'default'; // Renamed from 'name' to 'groupName'
constructor(name: string = 'default') {
this.name = name;
static setGroupName(name: string = 'default') { // Renamed method
DefaultPreference.groupName = name;
if (name !== 'default') {
RNDefaultPreference.setName(name);
}
}
async get(key: string): Promise<string | number | boolean | null> {
return RNDefaultPreference.get(this.name, key);
static async get(key: string): Promise<string | number | boolean | null> {
return RNDefaultPreference.get(DefaultPreference.groupName, key);
}
async set(key: string, value: string | number | boolean): Promise<void> {
return RNDefaultPreference.set(this.name, key, value);
static async set(key: string, value: string | number | boolean): Promise<void> {
return RNDefaultPreference.set(DefaultPreference.groupName, key, value);
}
async clear(key: string): Promise<void> {
return RNDefaultPreference.clear(this.name, key);
static async clear(key: string): Promise<void> {
return RNDefaultPreference.clear(DefaultPreference.groupName, key);
}
async getMultiple(keys: string[]): Promise<(string | number | boolean | null)[]> {
return RNDefaultPreference.getMultiple(this.name, keys);
static async getMultiple(keys: string[]): Promise<(string | number | boolean | null)[]> {
return RNDefaultPreference.getMultiple(DefaultPreference.groupName, keys);
}
async setMultiple(data: RNDefaultPreferenceKeys): Promise<void> {
return RNDefaultPreference.setMultiple(this.name, data);
static async setMultiple(data: RNDefaultPreferenceKeys): Promise<void> {
return RNDefaultPreference.setMultiple(DefaultPreference.groupName, data);
}
async clearMultiple(keys: string[]): Promise<void> {
return RNDefaultPreference.clearMultiple(this.name, keys);
static async clearMultiple(keys: string[]): Promise<void> {
return RNDefaultPreference.clearMultiple(DefaultPreference.groupName, keys);
}
async getAll(): Promise<RNDefaultPreferenceKeys> {
return RNDefaultPreference.getAll(this.name);
static async getAll(): Promise<RNDefaultPreferenceKeys> {
return RNDefaultPreference.getAll(DefaultPreference.groupName);
}
async clearAll(): Promise<void> {
return RNDefaultPreference.clearAll(this.name);
static async clearAll(): Promise<void> {
return RNDefaultPreference.clearAll(DefaultPreference.groupName);
}
async getName(): Promise<string> {
return this.name;
static async getGroupName(): Promise<string> { // Renamed method
return DefaultPreference.groupName;
}
}

35
useDefaultPreference.test.ts
View File

@ -5,6 +5,7 @@ import DefaultPreference from './index';
jest.mock('./index');
describe('useDefaultPreference', () => {
const mockSetName = jest.fn(); // Renamed mock
const mockGet = jest.fn();
const mockSet = jest.fn();
const mockClear = jest.fn();
@ -13,9 +14,12 @@ describe('useDefaultPreference', () => {
const mockClearMultiple = jest.fn();
const mockGetAll = jest.fn();
const mockClearAll = jest.fn();
const mockGetGroupName = jest.fn();
beforeEach(() => {
(DefaultPreference as jest.Mock).mockImplementation(() => ({
(DefaultPreference as unknown as jest.Mock).mockImplementation(() => ({
setGroupName: mockSetName, // Updated mock method
getGroupName: mockGetGroupName, // Added mock method
get: mockGet,
set: mockSet,
clear: mockClear,
@ -33,12 +37,37 @@ describe('useDefaultPreference', () => {
it('should initialize with the correct group name', () => {
renderHook(() => useDefaultPreference('testGroup'));
expect(DefaultPreference).toHaveBeenCalledWith('testGroup');
expect(mockSetName).toHaveBeenCalledWith('testGroup'); // Updated expectation
});
it('should use default group name when none is provided', () => {
renderHook(() => useDefaultPreference());
expect(DefaultPreference).toHaveBeenCalledWith('default');
expect(mockSetName).toHaveBeenCalledWith('default'); // Updated expectation
});
it('should handle different group names correctly', () => {
renderHook(() => useDefaultPreference('group1'));
expect(mockSetName).toHaveBeenCalledWith('group1');
renderHook(() => useDefaultPreference('group2'));
expect(mockSetName).toHaveBeenCalledWith('group2');
});
it('should retrieve the current group name', async () => {
// Arrange
const currentGroupName = 'testGroup';
mockGetGroupName.mockResolvedValue(currentGroupName);
// Act
const { result, waitForNextUpdate } = renderHook(() => useDefaultPreference());
// Assuming the hook exposes a method to get the group name
// If not, this test should be adjusted based on the hook's implementation
const groupName = await DefaultPreference.getGroupName();
// Assert
expect(mockGetGroupName).toHaveBeenCalled();
expect(groupName).toBe(currentGroupName);
});
it('should get a preference value', async () => {

22
useDefaultPreference.ts
View File

@ -1,39 +1,41 @@
import { useMemo } from 'react';
import { useEffect } from 'react';
import DefaultPreference from './index';
const useDefaultPreference = (groupName: string = 'default') => {
const preference = useMemo(() => new DefaultPreference(groupName), [groupName]);
useEffect(() => {
DefaultPreference.setName(groupName);
}, [groupName]);
const getPreference = async (key: string) => {
return await preference.get(key);
return await DefaultPreference.get(key);
};
const setPreference = async (key: string, value: string | number | boolean) => {
await preference.set(key, value);
await DefaultPreference.set(key, value);
};
const clearPreference = async (key: string) => {
await preference.clear(key);
await DefaultPreference.clear(key);
};
const getMultiplePreferences = async (keys: string[]) => {
return await preference.getMultiple(keys);
return await DefaultPreference.getMultiple(keys);
};
const setMultiplePreferences = async (data: { [key: string]: string | number | boolean }) => {
await preference.setMultiple(data);
await DefaultPreference.setMultiple(data);
};
const clearMultiplePreferences = async (keys: string[]) => {
await preference.clearMultiple(keys);
await DefaultPreference.clearMultiple(keys);
};
const getAllPreferences = async () => {
return await preference.getAll();
return await DefaultPreference.getAll();
};
const clearAllPreferences = async () => {
await preference.clearAll();
await DefaultPreference.clearAll();
};
return {