refactor(ramps): streamline RampsController reset and abort logic

packages/ramps-controller/CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- Refactor: Consolidate reset logic with a shared resetResource helper and fix abort handling for dependent resources ([#7818](https://github.com/MetaMask/core/pull/7818))
 - **BREAKING:** Restructure `RampsControllerState` to use nested `ResourceState` objects for each resource with `data`, `selected`, `isLoading`, and `error` ([#7779](https://github.com/MetaMask/core/pull/7779))
 
 ## [5.1.0]

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

@@ -470,6 +470,61 @@ describe('RampsController', () => {
         );
       });
     });
+
+    it('returns providers for region when state has providers (fetches and returns result)', async () => {
+      await withController(
+        {
+          options: {
+            state: {
+              userRegion: createMockUserRegion('us-ca'),
+              providers: createResourceState(mockProviders, null),
+            },
+          },
+        },
+        async ({ controller, rootMessenger }) => {
+          let serviceCalled = false;
+          rootMessenger.registerActionHandler(
+            'RampsService:getProviders',
+            async () => {
+              serviceCalled = true;
+              return { providers: mockProviders };
+            },
+          );
+
+          const result = await controller.getProviders('us-ca');
+
+          expect(serviceCalled).toBe(true);
+          expect(result.providers).toStrictEqual(mockProviders);
+        },
+      );
+    });
+
+    it('calls service when getProviders is called with filter options even if state has providers', async () => {
+      await withController(
+        {
+          options: {
+            state: {
+              userRegion: createMockUserRegion('us-ca'),
+              providers: createResourceState(mockProviders, null),
+            },
+          },
+        },
+        async ({ controller, rootMessenger }) => {
+          let serviceCalled = false;
+          rootMessenger.registerActionHandler(
+            'RampsService:getProviders',
+            async () => {
+              serviceCalled = true;
+              return { providers: mockProviders };
+            },
+          );
+
+          await controller.getProviders('us-ca', { provider: 'moonpay' });
+
+          expect(serviceCalled).toBe(true);
+        },
+      );
+    });
   });
 
   describe('metadata', () => {
@@ -1369,6 +1424,50 @@ describe('RampsController', () => {
         );
       });
     });
+
+    it('calls getTokens and getProviders when hydrating even if state has data', async () => {
+      const existingProviders: Provider[] = [
+        {
+          id: '/providers/test',
+          name: 'Test Provider',
+          environmentType: 'STAGING',
+          description: 'Test',
+          hqAddress: '123 Test St',
+          links: [],
+          logos: { light: '', dark: '', height: 24, width: 77 },
+        },
+      ];
+      await withController(
+        {
+          options: {
+            state: {
+              userRegion: createMockUserRegion('us-ca'),
+              providers: createResourceState(existingProviders, null),
+            },
+          },
+        },
+        async ({ controller, rootMessenger }) => {
+          let providersCalled = false;
+          rootMessenger.registerActionHandler(
+            'RampsService:getTokens',
+            async () => ({ topTokens: [], allTokens: [] }),
+          );
+          rootMessenger.registerActionHandler(
+            'RampsService:getProviders',
+            async () => {
+              providersCalled = true;
+              return { providers: [] };
+            },
+          );
+
+          controller.hydrateState();
+
+          await new Promise((resolve) => setTimeout(resolve, 10));
+
+          expect(providersCalled).toBe(true);
+        },
+      );
+    });
   });
 
   describe('setUserRegion', () => {
@@ -2069,6 +2168,8 @@ describe('RampsController', () => {
           expect(controller.state.providers.selected).toBeNull();
           expect(controller.state.paymentMethods.data).toStrictEqual([]);
           expect(controller.state.paymentMethods.selected).toBeNull();
+          expect(controller.state.paymentMethods.isLoading).toBe(false);
+          expect(controller.state.paymentMethods.error).toBeNull();
         },
       );
     });
@@ -2263,6 +2364,8 @@ describe('RampsController', () => {
           expect(controller.state.tokens.selected).toBeNull();
           expect(controller.state.paymentMethods.data).toStrictEqual([]);
           expect(controller.state.paymentMethods.selected).toBeNull();
+          expect(controller.state.paymentMethods.isLoading).toBe(false);
+          expect(controller.state.paymentMethods.error).toBeNull();
         },
       );
     });
@@ -2637,6 +2740,61 @@ describe('RampsController', () => {
       });
     });
 
+    it('returns tokens for region when state has tokens (fetches and returns result)', async () => {
+      await withController(
+        {
+          options: {
+            state: {
+              userRegion: createMockUserRegion('us-ca'),
+              tokens: createResourceState(mockTokens, null),
+            },
+          },
+        },
+        async ({ controller, rootMessenger }) => {
+          let serviceCalled = false;
+          rootMessenger.registerActionHandler(
+            'RampsService:getTokens',
+            async () => {
+              serviceCalled = true;
+              return mockTokens;
+            },
+          );
+
+          const result = await controller.getTokens('us-ca', 'buy');
+
+          expect(serviceCalled).toBe(true);
+          expect(result).toStrictEqual(mockTokens);
+        },
+      );
+    });
+
+    it('calls service when getTokens is called with provider filter even if state has tokens', async () => {
+      await withController(
+        {
+          options: {
+            state: {
+              userRegion: createMockUserRegion('us-ca'),
+              tokens: createResourceState(mockTokens, null),
+            },
+          },
+        },
+        async ({ controller, rootMessenger }) => {
+          let serviceCalled = false;
+          rootMessenger.registerActionHandler(
+            'RampsService:getTokens',
+            async () => {
+              serviceCalled = true;
+              return mockTokens;
+            },
+          );
+
+          await controller.getTokens('us-ca', 'buy', { provider: 'moonpay' });
+
+          expect(serviceCalled).toBe(true);
+        },
+      );
+    });
+
     it('prefers provided region over userRegion in state', async () => {
       await withController(
         {
@@ -3402,10 +3560,10 @@ describe('RampsController', () => {
           );
 
           controller.setSelectedToken(tokenB.assetId);
-          await new Promise((resolve) => setTimeout(resolve, 10));
 
           resolveTokenARequest({ payments: paymentMethodsForTokenA });
           await tokenAPaymentMethodsPromise;
+          await new Promise((resolve) => setTimeout(resolve, 10));
 
           expect(controller.state.tokens.selected).toStrictEqual(tokenB);
           expect(controller.state.paymentMethods.data).toStrictEqual(
@@ -3510,10 +3668,10 @@ describe('RampsController', () => {
           );
 
           controller.setSelectedProvider(providerB.id);
-          await new Promise((resolve) => setTimeout(resolve, 10));
 
           resolveProviderARequest({ payments: paymentMethodsForProviderA });
           await providerAPaymentMethodsPromise;
+          await new Promise((resolve) => setTimeout(resolve, 10));
 
           expect(controller.state.providers.selected).toStrictEqual(providerB);
           expect(controller.state.paymentMethods.data).toStrictEqual(