test(rewards): add coverage for campaigns reducers and selectors

Add tests for setCampaigns/setCampaignsLoading/setCampaignsError reducers,
selectCampaigns/selectCampaignsLoading/selectCampaignsError state selectors,
selectCampaignsRewardsEnabledRawFlag/selectCampaignsRewardsEnabledFlag feature
flag selectors, and concurrent fetch guard in useRewardCampaigns hook.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: VGR-GIT

app/components/UI/Rewards/hooks/useRewardCampaigns.test.ts

@@ -273,6 +273,36 @@ describe('useRewardCampaigns', () => {
       expect(mockDispatch).toHaveBeenCalledWith(mockSetCampaignsLoading(false));
       expect(mockDispatch).toHaveBeenCalledWith(mockSetCampaignsError(false));
     });
+
+    it('does not trigger concurrent fetches when already loading', async () => {
+      setupSelectorMocks();
+      let resolveFirstFetch: (value: CampaignDto[]) => void;
+      const firstFetchPromise = new Promise<CampaignDto[]>((resolve) => {
+        resolveFirstFetch = resolve;
+      });
+      mockEngineCall.mockReturnValueOnce(firstFetchPromise);
+
+      const { result } = renderHook(() => useRewardCampaigns());
+
+      // Start first fetch without awaiting
+      act(() => {
+        result.current.fetchCampaigns();
+      });
+
+      // Attempt concurrent fetch — should be skipped
+      await act(async () => {
+        await result.current.fetchCampaigns();
+      });
+
+      // Engine should only be called once
+      expect(mockEngineCall).toHaveBeenCalledTimes(1);
+
+      // Resolve the first fetch
+      await act(async () => {
+        resolveFirstFetch([]);
+        await firstFetchPromise;
+      });
+    });
   });
 
   describe('useFocusEffect integration', () => {

app/reducers/rewards/index.test.ts

@@ -27,6 +27,9 @@ import rewardsReducer, {
   setSnapshots,
   setSnapshotsLoading,
   setSnapshotsError,
+  setCampaigns,
+  setCampaignsLoading,
+  setCampaignsError,
   bulkLinkStarted,
   bulkLinkAccountResult,
   bulkLinkCompleted,
@@ -43,6 +46,8 @@ import {
   RewardClaimStatus,
   PointsEventDto,
   SnapshotDto,
+  CampaignDto,
+  CampaignType,
 } from '../../core/Engine/controllers/rewards-controller/types';
 import { AccountGroupId } from '@metamask/account-api';
 
@@ -4779,3 +4784,151 @@ describe('setSnapshotsError', () => {
     expect(currentState.snapshotsError).toBe(true);
   });
 });
+
+const mockCampaign: CampaignDto = {
+  id: 'campaign-1',
+  type: 'ONDO_HOLDING' as CampaignType,
+  name: 'ONDO Holding Campaign',
+  startDate: '2025-01-01T00:00:00.000Z',
+  endDate: '2027-01-01T00:00:00.000Z',
+  termsAndConditions: null,
+  excludedRegions: [],
+  statusLabel: 'Active',
+};
+
+describe('setCampaigns', () => {
+  it('should set campaigns array', () => {
+    const action = setCampaigns([mockCampaign]);
+
+    const state = rewardsReducer(initialState, action);
+
+    expect(state.campaigns).toEqual([mockCampaign]);
+    expect(state.campaignsError).toBe(false);
+  });
+
+  it('should replace existing campaigns with new ones', () => {
+    const stateWithCampaigns: RewardsState = {
+      ...initialState,
+      campaigns: [mockCampaign],
+    };
+    const newCampaign: CampaignDto = { ...mockCampaign, id: 'campaign-2', name: 'New Campaign' };
+    const action = setCampaigns([newCampaign]);
+
+    const state = rewardsReducer(stateWithCampaigns, action);
+
+    expect(state.campaigns).toHaveLength(1);
+    expect(state.campaigns[0].id).toBe('campaign-2');
+  });
+
+  it('should set campaigns to empty array', () => {
+    const stateWithCampaigns: RewardsState = {
+      ...initialState,
+      campaigns: [mockCampaign],
+    };
+    const action = setCampaigns([]);
+
+    const state = rewardsReducer(stateWithCampaigns, action);
+
+    expect(state.campaigns).toEqual([]);
+    expect(state.campaignsError).toBe(false);
+  });
+
+  it('should reset campaignsError when setting campaigns', () => {
+    const stateWithError: RewardsState = {
+      ...initialState,
+      campaignsError: true,
+    };
+    const action = setCampaigns([mockCampaign]);
+
+    const state = rewardsReducer(stateWithError, action);
+
+    expect(state.campaigns).toEqual([mockCampaign]);
+    expect(state.campaignsError).toBe(false);
+  });
+});
+
+describe('setCampaignsLoading', () => {
+  it('should set campaignsLoading to true when no campaigns exist', () => {
+    const action = setCampaignsLoading(true);
+
+    const state = rewardsReducer(initialState, action);
+
+    expect(state.campaignsLoading).toBe(true);
+  });
+
+  it('should not set loading to true when campaigns already exist', () => {
+    const stateWithCampaigns: RewardsState = {
+      ...initialState,
+      campaigns: [mockCampaign],
+      campaignsLoading: false,
+    };
+    const action = setCampaignsLoading(true);
+
+    const state = rewardsReducer(stateWithCampaigns, action);
+
+    expect(state.campaignsLoading).toBe(false);
+  });
+
+  it('should set campaignsLoading to false when loading is true', () => {
+    const stateWithLoading: RewardsState = {
+      ...initialState,
+      campaignsLoading: true,
+    };
+    const action = setCampaignsLoading(false);
+
+    const state = rewardsReducer(stateWithLoading, action);
+
+    expect(state.campaignsLoading).toBe(false);
+  });
+
+  it('should set campaignsLoading to false even when campaigns exist', () => {
+    const stateWithCampaigns: RewardsState = {
+      ...initialState,
+      campaigns: [mockCampaign],
+      campaignsLoading: true,
+    };
+    const action = setCampaignsLoading(false);
+
+    const state = rewardsReducer(stateWithCampaigns, action);
+
+    expect(state.campaignsLoading).toBe(false);
+  });
+});
+
+describe('setCampaignsError', () => {
+  it('should set campaignsError to true', () => {
+    const action = setCampaignsError(true);
+
+    const state = rewardsReducer(initialState, action);
+
+    expect(state.campaignsError).toBe(true);
+  });
+
+  it('should set campaignsError to false', () => {
+    const stateWithError: RewardsState = {
+      ...initialState,
+      campaignsError: true,
+    };
+    const action = setCampaignsError(false);
+
+    const state = rewardsReducer(stateWithError, action);
+
+    expect(state.campaignsError).toBe(false);
+  });
+
+  it('should toggle error state correctly', () => {
+    let currentState = initialState;
+
+    let action = setCampaignsError(true);
+    currentState = rewardsReducer(currentState, action);
+    expect(currentState.campaignsError).toBe(true);
+
+    action = setCampaignsError(false);
+    currentState = rewardsReducer(currentState, action);
+    expect(currentState.campaignsError).toBe(false);
+
+    action = setCampaignsError(true);
+    currentState = rewardsReducer(currentState, action);
+    expect(currentState.campaignsError).toBe(true);
+  });
+});

app/reducers/rewards/selectors.test.ts

@@ -49,12 +49,17 @@ import {
   selectBulkLinkAccountProgress,
   selectSnapshotsLoading,
   selectSnapshotsError,
+  selectCampaigns,
+  selectCampaignsLoading,
+  selectCampaignsError,
 } from './selectors';
 import { OnboardingStep } from './types';
 import {
   RewardDto,
   SeasonTierDto,
   SeasonActivityTypeDto,
+  CampaignDto,
+  CampaignType,
   SeasonWayToEarnDto,
   PointsEventDto,
 } from '../../core/Engine/controllers/rewards-controller/types';
@@ -3174,4 +3179,105 @@ describe('Rewards selectors', () => {
       });
     });
   });
+
+  const mockCampaign: CampaignDto = {
+    id: 'campaign-1',
+    type: 'ONDO_HOLDING' as CampaignType,
+    name: 'ONDO Holding Campaign',
+    startDate: '2025-01-01T00:00:00.000Z',
+    endDate: '2027-01-01T00:00:00.000Z',
+    termsAndConditions: null,
+    excludedRegions: [],
+    statusLabel: 'Active',
+  };
+
+  describe('selectCampaigns', () => {
+    it('returns empty array when campaigns is empty', () => {
+      const mockState = { rewards: { campaigns: [] } };
+      mockedUseSelector.mockImplementation((selector) => selector(mockState));
+
+      const { result } = renderHook(() => useSelector(selectCampaigns));
+      expect(result.current).toEqual([]);
+    });
+
+    it('returns campaigns array when campaigns exist', () => {
+      const mockState = { rewards: { campaigns: [mockCampaign] } };
+      mockedUseSelector.mockImplementation((selector) => selector(mockState));
+
+      const { result } = renderHook(() => useSelector(selectCampaigns));
+      expect(result.current).toEqual([mockCampaign]);
+    });
+
+    describe('Direct selector calls', () => {
+      it('returns empty array when campaigns is empty', () => {
+        const state = createMockRootState({ campaigns: [] });
+        expect(selectCampaigns(state)).toEqual([]);
+      });
+
+      it('returns campaigns when they exist', () => {
+        const state = createMockRootState({ campaigns: [mockCampaign] });
+        expect(selectCampaigns(state)).toEqual([mockCampaign]);
+      });
+    });
+  });
+
+  describe('selectCampaignsLoading', () => {
+    it('returns false when campaigns are not loading', () => {
+      const mockState = { rewards: { campaignsLoading: false } };
+      mockedUseSelector.mockImplementation((selector) => selector(mockState));
+
+      const { result } = renderHook(() => useSelector(selectCampaignsLoading));
+      expect(result.current).toBe(false);
+    });
+
+    it('returns true when campaigns are loading', () => {
+      const mockState = { rewards: { campaignsLoading: true } };
+      mockedUseSelector.mockImplementation((selector) => selector(mockState));
+
+      const { result } = renderHook(() => useSelector(selectCampaignsLoading));
+      expect(result.current).toBe(true);
+    });
+
+    describe('Direct selector calls', () => {
+      it('returns false when campaignsLoading is false', () => {
+        const state = createMockRootState({ campaignsLoading: false });
+        expect(selectCampaignsLoading(state)).toBe(false);
+      });
+
+      it('returns true when campaignsLoading is true', () => {
+        const state = createMockRootState({ campaignsLoading: true });
+        expect(selectCampaignsLoading(state)).toBe(true);
+      });
+    });
+  });
+
+  describe('selectCampaignsError', () => {
+    it('returns false when there is no campaigns error', () => {
+      const mockState = { rewards: { campaignsError: false } };
+      mockedUseSelector.mockImplementation((selector) => selector(mockState));
+
+      const { result } = renderHook(() => useSelector(selectCampaignsError));
+      expect(result.current).toBe(false);
+    });
+
+    it('returns true when there is a campaigns error', () => {
+      const mockState = { rewards: { campaignsError: true } };
+      mockedUseSelector.mockImplementation((selector) => selector(mockState));
+
+      const { result } = renderHook(() => useSelector(selectCampaignsError));
+      expect(result.current).toBe(true);
+    });
+
+    describe('Direct selector calls', () => {
+      it('returns false when campaignsError is false', () => {
+        const state = createMockRootState({ campaignsError: false });
+        expect(selectCampaignsError(state)).toBe(false);
+      });
+
+      it('returns true when campaignsError is true', () => {
+        const state = createMockRootState({ campaignsError: true });
+        expect(selectCampaignsError(state)).toBe(true);
+      });
+    });
+  });
 });