test: add concrete assertions to verify null-update handling in shouldIgnoreNullUpdate tests

Author: jacekradko

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

@@ -59,51 +59,71 @@ describe('State', () => {
         expect(signUpResourceSignal().resource?.id).toBe('signup_123');
       });
 
-      it('should allow null resource update when previous resource exists and canBeDiscarded is true', () => {
-        // Arrange: Set up a SignUp with id
+      it('should allow null resource update when previous resource exists and canBeDiscarded is true', async () => {
+        // Arrange: Set up a SignUp with id and mock setActive
+        const mockSetActive = vi.fn().mockResolvedValue({});
+        SignUp.clerk = { setActive: mockSetActive } as any;
+
         const existingSignUp = new SignUp({
           id: 'signup_123',
           status: 'complete',
           created_session_id: 'session_123',
         } as any);
         expect(signUpResourceSignal().resource).toBe(existingSignUp);
+        expect(existingSignUp.__internal_future.canBeDiscarded).toBe(false);
 
-        // Simulate finalize() being called - which sets canBeDiscarded to true
-        // We need to access the private field, so we'll use a workaround
-        // by calling the internal method that sets it
-        const mockSetActive = vi.fn().mockResolvedValue({});
-        SignUp.clerk = { setActive: mockSetActive } as any;
+        // Act: Call finalize() which sets canBeDiscarded to true
+        await existingSignUp.__internal_future.finalize();
+
+        // Verify canBeDiscarded is now true
+        expect(existingSignUp.__internal_future.canBeDiscarded).toBe(true);
+        expect(mockSetActive).toHaveBeenCalledWith({ session: 'session_123', navigate: undefined });
 
-        // Note: We can't easily call finalize() here because it's async and calls setActive
-        // Instead, let's directly test the scenario by creating a new SignUp and checking behavior
+        // Now emit a null resource update (simulating client refresh with null sign_up)
+        const nullSignUp = new SignUp(null);
 
-        // For this test, we'll verify the opposite case is working
-        // The null update should be blocked when canBeDiscarded is false
+        // Assert: The null update SHOULD be allowed because canBeDiscarded is true
+        // shouldIgnoreNullUpdate returns false when canBeDiscarded is true
+        expect(signUpResourceSignal().resource).toBe(nullSignUp);
+        expect(signUpResourceSignal().resource?.id).toBeUndefined();
       });
 
       it('should allow null resource update after reset() is called', async () => {
-        // Arrange: Set up mock client
+        // Arrange: Set up mock client that tracks the new SignUp created during reset
+        let newSignUpFromReset: SignUp | null = null;
         const mockClient = {
           signUp: new SignUp(null),
           resetSignUp: vi.fn().mockImplementation(function (this: typeof mockClient) {
-            const newSignUp = new SignUp(null);
-            this.signUp = newSignUp;
-            eventBus.emit('resource:error', { resource: newSignUp, error: null });
+            newSignUpFromReset = new SignUp(null);
+            this.signUp = newSignUpFromReset;
+            // reset() emits resource:error to clear errors, but the signal update
+            // happens via resource:update when the new SignUp is created
+            eventBus.emit('resource:error', { resource: newSignUpFromReset, error: null });
+            // Emit resource:update to update the signal (simulating what happens in real flow)
+            eventBus.emit('resource:update', { resource: newSignUpFromReset });
           }),
         };
         SignUp.clerk = { client: mockClient } as any;
 
         // Create a SignUp with id
         const existingSignUp = new SignUp({ id: 'signup_123', status: 'missing_requirements' } as any);
         expect(signUpResourceSignal().resource?.id).toBe('signup_123');
+        expect(existingSignUp.__internal_future.canBeDiscarded).toBe(false);
 
         // Act: Call reset() - this sets canBeDiscarded to true before resetting
         await existingSignUp.__internal_future.reset();
 
-        // Assert: After reset, the signal should have a new null SignUp
-        // Note: reset() calls client.resetSignUp() which emits resource:error, not resource:update
-        // So the signal update happens through a different path
+        // Assert: Verify reset was called
         expect(mockClient.resetSignUp).toHaveBeenCalled();
+
+        // Assert: Verify canBeDiscarded was set to true on the original SignUp
+        expect(existingSignUp.__internal_future.canBeDiscarded).toBe(true);
+
+        // Assert: Verify the signal was updated with a new SignUp that has no id
+        // The previous id 'signup_123' should be gone
+        expect(signUpResourceSignal().resource).toBe(newSignUpFromReset);
+        expect(signUpResourceSignal().resource?.id).toBeUndefined();
+        expect(signUpResourceSignal().resource).not.toBe(existingSignUp);
       });
 
       it('should allow resource update when new resource has an id (not a null update)', () => {