chore: changelog and test updates from cursor review

Author: georgeweiler

packages/ramps-controller/CHANGELOG.md

@@ -7,9 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Changed
+### Added
 
-- Bump `@metamask/controller-utils` from `^11.16.0` to `^11.17.0` ([#7534](https://github.com/MetaMask/core/pull/7534))
+- Add request caching infrastructure with TTL, deduplication, and abort support ([#7536](https://github.com/MetaMask/core/pull/7536))
 
 ## [2.0.0]
 

packages/ramps-controller/src/RampsController.test.ts

@@ -324,6 +324,57 @@ describe('RampsController', () => {
         await expect(requestPromise).rejects.toThrow('Request was aborted');
       });
     });
+
+    it('does not delete newer pending request when aborted request settles', async () => {
+      await withController(async ({ controller }) => {
+        let requestASettled = false;
+        let requestBCallCount = 0;
+
+        // Request A: will be aborted but takes time to settle
+        const fetcherA = async (signal: AbortSignal): Promise<string> => {
+          return new Promise<string>((resolve, reject) => {
+            signal.addEventListener('abort', () => {
+              // Simulate async cleanup delay before rejecting
+              setTimeout(() => {
+                requestASettled = true;
+                reject(new Error('Request A aborted'));
+              }, 50);
+            });
+          });
+        };
+
+        // Request B: normal request that should deduplicate correctly
+        const fetcherB = async (): Promise<string> => {
+          requestBCallCount += 1;
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          return 'result-b';
+        };
+
+        // Start request A
+        const promiseA = controller.executeRequest('race-key', fetcherA);
+
+        // Abort request A (removes from pendingRequests, triggers abort)
+        controller.abortRequest('race-key');
+
+        // Start request B with the same key before request A settles
+        expect(requestASettled).toBe(false);
+        const promiseB = controller.executeRequest('race-key', fetcherB);
+
+        // Start request C with same key - should deduplicate with B
+        const promiseC = controller.executeRequest('race-key', fetcherB);
+
+        // Wait for request A to finish settling (its finally block runs)
+        await expect(promiseA).rejects.toThrow('Request A aborted');
+        expect(requestASettled).toBe(true);
+
+        // Requests B and C should still work correctly (deduplication intact)
+        const [resultB, resultC] = await Promise.all([promiseB, promiseC]);
+
+        expect(resultB).toBe('result-b');
+        expect(resultC).toBe('result-b');
+        expect(requestBCallCount).toBe(1);
+      });
+    });
   });
 
   describe('cache eviction', () => {

packages/ramps-controller/src/RampsController.ts

@@ -272,7 +272,11 @@ export class RampsController extends BaseController<
         );
         throw error;
       } finally {
-        this.#pendingRequests.delete(cacheKey);
+        // Only delete if this is still our entry (not replaced by a new request)
+        const currentPending = this.#pendingRequests.get(cacheKey);
+        if (currentPending?.abortController === abortController) {
+          this.#pendingRequests.delete(cacheKey);
+        }
       }
     })();
 

packages/ramps-controller/src/RequestCache.test.ts

@@ -12,7 +12,7 @@ describe('RequestCache', () => {
   describe('createCacheKey', () => {
     it('creates a cache key from method and empty params', () => {
       const key = createCacheKey('updateGeolocation', []);
-      expect(key).toBe('getGeolocation:[]');
+      expect(key).toBe('updateGeolocation:[]');
     });
 
     it('creates a cache key from method and params', () => {