Skip to content

Commit edd14c6

Browse files
JKobrynskiJKobrynski
committed
address review comments
1 parent f00b48f commit edd14c6

2 files changed

Lines changed: 176 additions & 66 deletions

File tree

‎tests/unit/onyxTest.ts‎

Lines changed: 55 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -3115,17 +3115,6 @@ describe('Onyx.init', () => {
31153115

31163116
// Separate describe block to control Onyx.init() per-test so we can pre-seed storage before init.
31173117
describe('RAM-only keys should not read from storage', () => {
3118-
const RAM_ONLY_KEYS = {
3119-
TEST_KEY: 'test',
3120-
OTHER_TEST: 'otherTest',
3121-
COLLECTION: {
3122-
TEST_KEY: 'test_',
3123-
RAM_ONLY_COLLECTION: 'ramOnlyCollection_',
3124-
},
3125-
RAM_ONLY_KEY: 'ramOnlyKey',
3126-
RAM_ONLY_WITH_INITIAL_VALUE: 'ramOnlyWithInitialValue',
3127-
};
3128-
31293118
let cache: typeof OnyxCache;
31303119

31313120
beforeEach(() => {
@@ -3140,46 +3129,46 @@ describe('RAM-only keys should not read from storage', () => {
31403129

31413130
it('should not return stale storage data for a RAM-only key via get', async () => {
31423131
// Simulate stale data left in storage from before the key was RAM-only
3143-
await StorageMock.setItem(RAM_ONLY_KEYS.RAM_ONLY_KEY, 'stale_value');
3132+
await StorageMock.setItem(ONYX_KEYS.RAM_ONLY_TEST_KEY, 'stale_value');
31443133

31453134
Onyx.init({
3146-
keys: RAM_ONLY_KEYS,
3147-
ramOnlyKeys: [RAM_ONLY_KEYS.RAM_ONLY_KEY, RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION, RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
3135+
keys: ONYX_KEYS,
3136+
ramOnlyKeys: [ONYX_KEYS.RAM_ONLY_TEST_KEY, ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION, ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
31483137
});
31493138
await act(async () => waitForPromisesToResolve());
31503139

31513140
let receivedValue: unknown;
31523141
const connection = Onyx.connect({
3153-
key: RAM_ONLY_KEYS.RAM_ONLY_KEY,
3142+
key: ONYX_KEYS.RAM_ONLY_TEST_KEY,
31543143
callback: (value) => {
31553144
receivedValue = value;
31563145
},
31573146
});
31583147
await act(async () => waitForPromisesToResolve());
31593148

31603149
expect(receivedValue).toBeUndefined();
3161-
expect(cache.get(RAM_ONLY_KEYS.RAM_ONLY_KEY)).toBeUndefined();
3150+
expect(cache.get(ONYX_KEYS.RAM_ONLY_TEST_KEY)).toBeUndefined();
31623151

31633152
Onyx.disconnect(connection);
31643153
});
31653154

31663155
it('should not return stale storage data for RAM-only collection members via multiGet', async () => {
3167-
const collectionMember1 = `${RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION}1`;
3168-
const collectionMember2 = `${RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION}2`;
3156+
const collectionMember1 = `${ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION}1`;
3157+
const collectionMember2 = `${ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION}2`;
31693158

31703159
// Simulate stale collection members in storage
31713160
await StorageMock.setItem(collectionMember1, {name: 'stale_1'});
31723161
await StorageMock.setItem(collectionMember2, {name: 'stale_2'});
31733162

31743163
Onyx.init({
3175-
keys: RAM_ONLY_KEYS,
3176-
ramOnlyKeys: [RAM_ONLY_KEYS.RAM_ONLY_KEY, RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION, RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
3164+
keys: ONYX_KEYS,
3165+
ramOnlyKeys: [ONYX_KEYS.RAM_ONLY_TEST_KEY, ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION, ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
31773166
});
31783167
await act(async () => waitForPromisesToResolve());
31793168

31803169
let receivedCollection: OnyxCollection<unknown>;
31813170
const connection = Onyx.connect({
3182-
key: RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION,
3171+
key: ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION,
31833172
callback: (value) => {
31843173
receivedCollection = value;
31853174
},
@@ -3196,67 +3185,67 @@ describe('RAM-only keys should not read from storage', () => {
31963185

31973186
it('should not include stale RAM-only keys in getAllKeys results', async () => {
31983187
// Simulate stale data in storage
3199-
await StorageMock.setItem(RAM_ONLY_KEYS.RAM_ONLY_KEY, 'stale_value');
3200-
await StorageMock.setItem(`${RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION}1`, {stale: 'member'});
3201-
await StorageMock.setItem(RAM_ONLY_KEYS.OTHER_TEST, 'normal_value');
3188+
await StorageMock.setItem(ONYX_KEYS.RAM_ONLY_TEST_KEY, 'stale_value');
3189+
await StorageMock.setItem(`${ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION}1`, {stale: 'member'});
3190+
await StorageMock.setItem(ONYX_KEYS.OTHER_TEST, 'normal_value');
32023191

32033192
Onyx.init({
3204-
keys: RAM_ONLY_KEYS,
3205-
ramOnlyKeys: [RAM_ONLY_KEYS.RAM_ONLY_KEY, RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION, RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
3193+
keys: ONYX_KEYS,
3194+
ramOnlyKeys: [ONYX_KEYS.RAM_ONLY_TEST_KEY, ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION, ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
32063195
});
32073196
await act(async () => waitForPromisesToResolve());
32083197

32093198
const keys = await OnyxUtils.getAllKeys();
32103199

3211-
expect(keys.has(RAM_ONLY_KEYS.RAM_ONLY_KEY)).toBe(false);
3212-
expect(keys.has(`${RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION}1`)).toBe(false);
3200+
expect(keys.has(ONYX_KEYS.RAM_ONLY_TEST_KEY)).toBe(false);
3201+
expect(keys.has(`${ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION}1`)).toBe(false);
32133202
// Normal keys should still be present
3214-
expect(keys.has(RAM_ONLY_KEYS.OTHER_TEST)).toBe(true);
3203+
expect(keys.has(ONYX_KEYS.OTHER_TEST)).toBe(true);
32153204
});
32163205

32173206
it('should not read stale storage data for RAM-only keys during initializeWithDefaultKeyStates', async () => {
32183207
// Simulate stale data for a RAM-only key that also has a default key state
3219-
await StorageMock.setItem(RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE, 'stale_value');
3208+
await StorageMock.setItem(ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE, 'stale_value');
32203209

32213210
Onyx.init({
3222-
keys: RAM_ONLY_KEYS,
3211+
keys: ONYX_KEYS,
32233212
initialKeyStates: {
3224-
[RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE]: 'default_value',
3213+
[ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE]: 'default_value',
32253214
},
3226-
ramOnlyKeys: [RAM_ONLY_KEYS.RAM_ONLY_KEY, RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION, RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
3215+
ramOnlyKeys: [ONYX_KEYS.RAM_ONLY_TEST_KEY, ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION, ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
32273216
});
32283217
await act(async () => waitForPromisesToResolve());
32293218

32303219
// The cache should have the default value, not the stale storage value
3231-
expect(cache.get(RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE)).toEqual('default_value');
3220+
expect(cache.get(ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE)).toEqual('default_value');
32323221
});
32333222

32343223
it('should not use stale storage data as merge base for RAM-only keys', async () => {
32353224
// Simulate stale data in storage
3236-
await StorageMock.setItem(RAM_ONLY_KEYS.RAM_ONLY_KEY, {name: 'stale', token: 'old_token'});
3225+
await StorageMock.setItem(ONYX_KEYS.RAM_ONLY_TEST_KEY, {name: 'stale', token: 'old_token'});
32373226

32383227
Onyx.init({
3239-
keys: RAM_ONLY_KEYS,
3240-
ramOnlyKeys: [RAM_ONLY_KEYS.RAM_ONLY_KEY, RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION, RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
3228+
keys: ONYX_KEYS,
3229+
ramOnlyKeys: [ONYX_KEYS.RAM_ONLY_TEST_KEY, ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION, ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
32413230
});
32423231
await act(async () => waitForPromisesToResolve());
32433232

32443233
// Merge new data — should NOT merge with stale storage value
3245-
await Onyx.merge(RAM_ONLY_KEYS.RAM_ONLY_KEY, {name: 'new'});
3234+
await Onyx.merge(ONYX_KEYS.RAM_ONLY_TEST_KEY, {name: 'new'});
32463235

32473236
// The result should only contain the merged value, not the stale token
3248-
expect(cache.get(RAM_ONLY_KEYS.RAM_ONLY_KEY)).toEqual({name: 'new'});
3237+
expect(cache.get(ONYX_KEYS.RAM_ONLY_TEST_KEY)).toEqual({name: 'new'});
32493238
});
32503239

32513240
it('should not read stale storage data when subscribing to individual RAM-only collection members', async () => {
3252-
const collectionMember = `${RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION}1`;
3241+
const collectionMember = `${ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION}1`;
32533242

32543243
// Simulate stale data in storage
32553244
await StorageMock.setItem(collectionMember, {data: 'stale'});
32563245

32573246
Onyx.init({
3258-
keys: RAM_ONLY_KEYS,
3259-
ramOnlyKeys: [RAM_ONLY_KEYS.RAM_ONLY_KEY, RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION, RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
3247+
keys: ONYX_KEYS,
3248+
ramOnlyKeys: [ONYX_KEYS.RAM_ONLY_TEST_KEY, ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION, ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
32603249
});
32613250
await act(async () => waitForPromisesToResolve());
32623251

@@ -3277,26 +3266,26 @@ describe('RAM-only keys should not read from storage', () => {
32773266

32783267
it('should still work correctly for normal keys when RAM-only keys have stale storage data', async () => {
32793268
// Simulate both normal and RAM-only stale data in storage
3280-
await StorageMock.setItem(RAM_ONLY_KEYS.TEST_KEY, 'normal_value');
3281-
await StorageMock.setItem(RAM_ONLY_KEYS.RAM_ONLY_KEY, 'stale_ram_value');
3269+
await StorageMock.setItem(ONYX_KEYS.TEST_KEY, 'normal_value');
3270+
await StorageMock.setItem(ONYX_KEYS.RAM_ONLY_TEST_KEY, 'stale_ram_value');
32823271

32833272
Onyx.init({
3284-
keys: RAM_ONLY_KEYS,
3285-
ramOnlyKeys: [RAM_ONLY_KEYS.RAM_ONLY_KEY, RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION, RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
3273+
keys: ONYX_KEYS,
3274+
ramOnlyKeys: [ONYX_KEYS.RAM_ONLY_TEST_KEY, ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION, ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
32863275
});
32873276
await act(async () => waitForPromisesToResolve());
32883277

32893278
let normalValue: unknown;
32903279
let ramOnlyValue: unknown;
32913280

32923281
const connection1 = Onyx.connect({
3293-
key: RAM_ONLY_KEYS.TEST_KEY,
3282+
key: ONYX_KEYS.TEST_KEY,
32943283
callback: (value) => {
32953284
normalValue = value;
32963285
},
32973286
});
32983287
const connection2 = Onyx.connect({
3299-
key: RAM_ONLY_KEYS.RAM_ONLY_KEY,
3288+
key: ONYX_KEYS.RAM_ONLY_TEST_KEY,
33003289
callback: (value) => {
33013290
ramOnlyValue = value;
33023291
},
@@ -3314,8 +3303,8 @@ describe('RAM-only keys should not read from storage', () => {
33143303

33153304
it('should not sync RAM-only keys from other instances via keepInstancesSync', async () => {
33163305
Onyx.init({
3317-
keys: RAM_ONLY_KEYS,
3318-
ramOnlyKeys: [RAM_ONLY_KEYS.RAM_ONLY_KEY, RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION, RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
3306+
keys: ONYX_KEYS,
3307+
ramOnlyKeys: [ONYX_KEYS.RAM_ONLY_TEST_KEY, ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION, ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
33193308
shouldSyncMultipleInstances: true,
33203309
});
33213310
await act(async () => waitForPromisesToResolve());
@@ -3326,32 +3315,32 @@ describe('RAM-only keys should not read from storage', () => {
33263315

33273316
let receivedValue: unknown;
33283317
const connection = Onyx.connect({
3329-
key: RAM_ONLY_KEYS.RAM_ONLY_KEY,
3318+
key: ONYX_KEYS.RAM_ONLY_TEST_KEY,
33303319
callback: (value) => {
33313320
receivedValue = value;
33323321
},
33333322
});
33343323
await act(async () => waitForPromisesToResolve());
33353324

33363325
// Simulate another tab syncing a stale RAM-only key value
3337-
syncCallback(RAM_ONLY_KEYS.RAM_ONLY_KEY, 'synced_stale_value');
3326+
syncCallback(ONYX_KEYS.RAM_ONLY_TEST_KEY, 'synced_stale_value');
33383327
await act(async () => waitForPromisesToResolve());
33393328

33403329
// The RAM-only key should NOT have been updated from the sync
33413330
expect(receivedValue).toBeUndefined();
3342-
expect(cache.get(RAM_ONLY_KEYS.RAM_ONLY_KEY)).toBeUndefined();
3331+
expect(cache.get(ONYX_KEYS.RAM_ONLY_TEST_KEY)).toBeUndefined();
33433332

33443333
// Verify that normal keys still sync correctly
33453334
let normalValue: unknown;
33463335
const connection2 = Onyx.connect({
3347-
key: RAM_ONLY_KEYS.OTHER_TEST,
3336+
key: ONYX_KEYS.OTHER_TEST,
33483337
callback: (value) => {
33493338
normalValue = value;
33503339
},
33513340
});
33523341
await act(async () => waitForPromisesToResolve());
33533342

3354-
syncCallback(RAM_ONLY_KEYS.OTHER_TEST, 'synced_normal_value');
3343+
syncCallback(ONYX_KEYS.OTHER_TEST, 'synced_normal_value');
33553344
await act(async () => waitForPromisesToResolve());
33563345

33573346
expect(normalValue).toEqual('synced_normal_value');
@@ -3361,16 +3350,16 @@ describe('RAM-only keys should not read from storage', () => {
33613350
});
33623351

33633352
it('should serve RAM-only keys from cache and normal keys from storage in multiGet', async () => {
3364-
const ramOnlyMember = `${RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION}1`;
3365-
const normalMember = `${RAM_ONLY_KEYS.COLLECTION.TEST_KEY}1`;
3353+
const ramOnlyMember = `${ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION}1`;
3354+
const normalMember = `${ONYX_KEYS.COLLECTION.TEST_KEY}1`;
33663355

33673356
// Pre-seed storage with stale data for both normal and RAM-only keys
33683357
await StorageMock.setItem(normalMember, 'normal_from_storage');
33693358
await StorageMock.setItem(ramOnlyMember, {data: 'stale_collection_member'});
33703359

33713360
Onyx.init({
3372-
keys: RAM_ONLY_KEYS,
3373-
ramOnlyKeys: [RAM_ONLY_KEYS.RAM_ONLY_KEY, RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION, RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
3361+
keys: ONYX_KEYS,
3362+
ramOnlyKeys: [ONYX_KEYS.RAM_ONLY_TEST_KEY, ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION, ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
33743363
});
33753364
await act(async () => waitForPromisesToResolve());
33763365

@@ -3387,20 +3376,20 @@ describe('RAM-only keys should not read from storage', () => {
33873376
});
33883377

33893378
it('should return cached value for RAM-only key after set then connect', async () => {
3390-
await StorageMock.setItem(RAM_ONLY_KEYS.RAM_ONLY_KEY, 'stale_value');
3379+
await StorageMock.setItem(ONYX_KEYS.RAM_ONLY_TEST_KEY, 'stale_value');
33913380

33923381
Onyx.init({
3393-
keys: RAM_ONLY_KEYS,
3394-
ramOnlyKeys: [RAM_ONLY_KEYS.RAM_ONLY_KEY, RAM_ONLY_KEYS.COLLECTION.RAM_ONLY_COLLECTION, RAM_ONLY_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
3382+
keys: ONYX_KEYS,
3383+
ramOnlyKeys: [ONYX_KEYS.RAM_ONLY_TEST_KEY, ONYX_KEYS.COLLECTION.RAM_ONLY_COLLECTION, ONYX_KEYS.RAM_ONLY_WITH_INITIAL_VALUE],
33953384
});
33963385
await act(async () => waitForPromisesToResolve());
33973386

33983387
// Write a fresh value to the RAM-only key
3399-
await Onyx.set(RAM_ONLY_KEYS.RAM_ONLY_KEY, 'fresh_value');
3388+
await Onyx.set(ONYX_KEYS.RAM_ONLY_TEST_KEY, 'fresh_value');
34003389

34013390
let receivedValue: unknown;
34023391
const connection = Onyx.connect({
3403-
key: RAM_ONLY_KEYS.RAM_ONLY_KEY,
3392+
key: ONYX_KEYS.RAM_ONLY_TEST_KEY,
34043393
callback: (value) => {
34053394
receivedValue = value;
34063395
},
@@ -3409,10 +3398,10 @@ describe('RAM-only keys should not read from storage', () => {
34093398

34103399
// Should get the fresh cached value, not the stale storage value
34113400
expect(receivedValue).toEqual('fresh_value');
3412-
expect(cache.get(RAM_ONLY_KEYS.RAM_ONLY_KEY)).toEqual('fresh_value');
3401+
expect(cache.get(ONYX_KEYS.RAM_ONLY_TEST_KEY)).toEqual('fresh_value');
34133402

34143403
// Verify storage was NOT written to
3415-
const storageValue = await StorageMock.getItem(RAM_ONLY_KEYS.RAM_ONLY_KEY);
3404+
const storageValue = await StorageMock.getItem(ONYX_KEYS.RAM_ONLY_TEST_KEY);
34163405
expect(storageValue).toEqual('stale_value');
34173406

34183407
Onyx.disconnect(connection);

0 commit comments

Comments
 (0)