test(clerk-js): add full SignIn parity and remove duplicate tests

Author: jacekradko

packages/clerk-js/src/core/__tests__/state.test.ts

@@ -165,40 +165,75 @@ describe('State', () => {
         expect(signInResourceSignal().resource).toBe(existingSignIn);
         expect(signInResourceSignal().resource?.id).toBe('signin_123');
       });
-    });
-  });
 
-  describe('Simulated client refresh scenarios', () => {
-    it('should allow null update after finalize sets canBeDiscarded to true', async () => {
-      // This test verifies that after finalize() is called,
-      // the null update IS allowed (because canBeDiscarded is true)
+      it('should allow null resource update when previous resource exists and canBeDiscarded is true', async () => {
+        // Arrange: Set up a SignIn with id and mock setActive
+        const mockSetActive = vi.fn().mockResolvedValue({});
+        SignIn.clerk = { setActive: mockSetActive, client: { sessions: [{ id: 'session_123' }] } } as any;
 
-      // Arrange
-      const mockSetActive = vi.fn().mockResolvedValue({});
-      SignUp.clerk = { setActive: mockSetActive } as any;
+        const existingSignIn = new SignIn({
+          id: 'signin_123',
+          status: 'complete',
+          created_session_id: 'session_123',
+        } as any);
+        expect(signInResourceSignal().resource).toBe(existingSignIn);
+        expect(existingSignIn.__internal_future.canBeDiscarded).toBe(false);
 
-      const signUp = new SignUp({
-        id: 'signup_123',
-        status: 'complete',
-        created_session_id: 'session_123',
-      } as any);
+        // Act: Call finalize() which sets canBeDiscarded to true
+        await existingSignIn.__internal_future.finalize();
 
-      expect(signUpResourceSignal().resource?.id).toBe('signup_123');
-      expect(signUp.__internal_future.canBeDiscarded).toBe(false);
+        expect(existingSignIn.__internal_future.canBeDiscarded).toBe(true);
+        expect(mockSetActive).toHaveBeenCalledWith({ session: 'session_123', navigate: undefined });
 
-      // Act: Call finalize - this sets canBeDiscarded to true
-      await signUp.__internal_future.finalize();
+        // Now emit a null resource update
+        const nullSignIn = new SignIn(null);
 
-      // Verify canBeDiscarded is now true
-      expect(signUp.__internal_future.canBeDiscarded).toBe(true);
+        // Assert: The null update SHOULD be allowed because canBeDiscarded is true
+        expect(signInResourceSignal().resource).toBe(nullSignIn);
+        expect(signInResourceSignal().resource?.id).toBeUndefined();
+      });
 
-      // Now simulate a null update
-      const nullSignUp = new SignUp(null);
+      it('should allow null resource update after reset() is called', async () => {
+        // Arrange: Set up mock client
+        let newSignInFromReset: SignIn | null = null;
+        const mockClient = {
+          signIn: new SignIn(null),
+          resetSignIn: vi.fn().mockImplementation(function (this: typeof mockClient) {
+            newSignInFromReset = new SignIn(null);
+            this.signIn = newSignInFromReset;
+            eventBus.emit('resource:error', { resource: newSignInFromReset, error: null });
+            eventBus.emit('resource:update', { resource: newSignInFromReset });
+          }),
+        };
+        SignIn.clerk = { client: mockClient } as any;
+
+        // Create a SignIn with id
+        const existingSignIn = new SignIn({ id: 'signin_123', status: 'needs_identifier' } as any);
+        expect(signInResourceSignal().resource?.id).toBe('signin_123');
+        expect(existingSignIn.__internal_future.canBeDiscarded).toBe(false);
+
+        // Act: Call reset()
+        await existingSignIn.__internal_future.reset();
 
-      // Assert: The null update SHOULD be allowed now
-      // Because canBeDiscarded is true, shouldIgnoreNullUpdate returns false
-      expect(signUpResourceSignal().resource).toBe(nullSignUp);
-      expect(signUpResourceSignal().resource?.id).toBeUndefined();
+        // Assert
+        expect(mockClient.resetSignIn).toHaveBeenCalled();
+        expect(existingSignIn.__internal_future.canBeDiscarded).toBe(true);
+        expect(signInResourceSignal().resource).toBe(newSignInFromReset);
+        expect(signInResourceSignal().resource?.id).toBeUndefined();
+      });
+
+      it('should allow resource update when new resource has an id (not a null update)', () => {
+        // Arrange: Set up a SignIn with id
+        const existingSignIn = new SignIn({ id: 'signin_123', status: 'needs_identifier' } as any);
+        expect(signInResourceSignal().resource?.id).toBe('signin_123');
+
+        // Act: Emit a resource update with a different SignIn that also has an id
+        const newSignIn = new SignIn({ id: 'signin_456', status: 'complete' } as any);
+
+        // Assert: Signal should be updated with the new SignIn
+        expect(signInResourceSignal().resource).toBe(newSignIn);
+        expect(signInResourceSignal().resource?.id).toBe('signin_456');
+      });
     });
   });