test: restore branch coverage above 80% after merging main

Merging main's newer code nudged global branch coverage to 79.93%. Cover the gaps:
- debugLogsStore: ring-buffer cap + clear (was 0%).
- proLicenseService: resetProIdentityForTesting (anonymous/non-anonymous/error)
  and activateProByEmail error paths (logIn failure, miss + logOut failure).

Branch coverage back to 80.06%.

Co-Authored-By: Dishit Karia <hanmadishit74@gmail.com>

Author: dishit-wednesday

__tests__/unit/services/proLicenseService.test.ts

@@ -6,6 +6,7 @@ import {
   revalidatePro,
   clearProForTesting,
   configureRevenueCat,
+  resetProIdentityForTesting,
 } from '../../../src/services/proLicenseService';
 
 jest.mock('react-native-purchases', () => ({
@@ -170,4 +171,45 @@ describe('proLicenseService', () => {
       expect(mockSetHasRegisteredPro).toHaveBeenCalledWith(false);
     });
   });
+
+  describe('resetProIdentityForTesting()', () => {
+    it('logs out a non-anonymous user, clears the keychain, and resets the flag', async () => {
+      Purchases.getCustomerInfo.mockResolvedValueOnce({ originalAppUserId: 'someone@example.com' });
+      mockResetGenericPassword.mockResolvedValueOnce(true);
+      await resetProIdentityForTesting();
+      expect(Purchases.logOut).toHaveBeenCalledTimes(1);
+      expect(mockResetGenericPassword).toHaveBeenCalledTimes(1);
+      expect(mockSetHasRegisteredPro).toHaveBeenCalledWith(false);
+    });
+
+    it('skips logOut for an anonymous user but still clears the keychain', async () => {
+      Purchases.getCustomerInfo.mockResolvedValueOnce({ originalAppUserId: '$RCAnonymousID:abc123' });
+      mockResetGenericPassword.mockResolvedValueOnce(true);
+      await resetProIdentityForTesting();
+      expect(Purchases.logOut).not.toHaveBeenCalled();
+      expect(mockResetGenericPassword).toHaveBeenCalledTimes(1);
+      expect(mockSetHasRegisteredPro).toHaveBeenCalledWith(false);
+    });
+
+    it('still clears local state when getCustomerInfo throws', async () => {
+      Purchases.getCustomerInfo.mockRejectedValueOnce(new Error('offline'));
+      mockResetGenericPassword.mockResolvedValueOnce(true);
+      await resetProIdentityForTesting();
+      expect(mockResetGenericPassword).toHaveBeenCalledTimes(1);
+      expect(mockSetHasRegisteredPro).toHaveBeenCalledWith(false);
+    });
+  });
+
+  describe('activateProByEmail() error paths', () => {
+    it('rethrows when logIn fails', async () => {
+      Purchases.logIn.mockRejectedValueOnce(new Error('network'));
+      await expect(activateProByEmail('x@example.com')).rejects.toThrow('network');
+    });
+
+    it('returns false on a miss and tolerates a logOut failure', async () => {
+      Purchases.logIn.mockResolvedValueOnce({ customerInfo: customerWith(null) });
+      Purchases.logOut.mockRejectedValueOnce(new Error('logout fail'));
+      await expect(activateProByEmail('x@example.com')).resolves.toBe(false);
+    });
+  });
 });

__tests__/unit/stores/debugLogsStore.test.ts

@@ -0,0 +1,27 @@
+import { useDebugLogsStore } from '../../../src/stores/debugLogsStore';
+
+describe('debugLogsStore', () => {
+  beforeEach(() => useDebugLogsStore.getState().clearLogs());
+
+  it('appends log entries in order', () => {
+    useDebugLogsStore.getState().addLog({ timestamp: 1, level: 'log', message: 'a' });
+    useDebugLogsStore.getState().addLog({ timestamp: 2, level: 'warn', message: 'b' });
+    expect(useDebugLogsStore.getState().logs.map(l => l.message)).toEqual(['a', 'b']);
+  });
+
+  it('caps the buffer at the in-memory limit, dropping the oldest', () => {
+    for (let i = 0; i < 520; i++) {
+      useDebugLogsStore.getState().addLog({ timestamp: i, level: 'log', message: `m${i}` });
+    }
+    const { logs } = useDebugLogsStore.getState();
+    expect(logs.length).toBe(500);
+    expect(logs[0].message).toBe('m20'); // oldest 20 dropped
+    expect(logs[logs.length - 1].message).toBe('m519'); // newest kept
+  });
+
+  it('clearLogs empties the buffer', () => {
+    useDebugLogsStore.getState().addLog({ timestamp: 1, level: 'error', message: 'x' });
+    useDebugLogsStore.getState().clearLogs();
+    expect(useDebugLogsStore.getState().logs).toEqual([]);
+  });
+});