core test flake (#2143)

* test fix

Author: aryanku-dev

packages/core/test/discovery.test.js

@@ -3094,64 +3094,46 @@ describe('Discovery', () => {
     it('skips validation when hostname validation is already pending', async () => {
       await percy.stop();
 
-      let validationCallCount = 0;
-      let validationResolvers = [];
-
-      // Mock validation to hang so we can test concurrent requests
+      let validationAttempted = false;
+      // Track if validation is attempted (it shouldn't be)
       validationMock.and.callFake(() => {
-        validationCallCount++;
-        return new Promise(resolve => {
-          validationResolvers.push(resolve);
-        });
+        validationAttempted = true;
+        return Promise.resolve({ accessible: false });
       });
 
       percy = await Percy.start({
         token: 'PERCY_TOKEN',
-        discovery: {
-          autoConfigureAllowedHostnames: true
-        }
+        discovery: { autoConfigureAllowedHostnames: true }
       });
 
+      // Set worker URL (not used since we populate pending)
       percy.domainValidation.workerUrl = 'https://winter-morning-fa32.shobhit-k.workers.dev';
 
-      // Take two snapshots with the same external domain
-      let snapshot1Promise = percy.snapshot({
-        name: 'test snapshot 1',
-        url: 'http://localhost:8000',
-        domSnapshot: testExternalDOM,
-        widths: [1000]
-      });
+      // Pre-populate pending with a resolved promise for the hostname (ex.localhost:8001 from testExternalDOM)
+      // This ensures the mutex path (pending.has/get) is taken instead of calling validation
+      percy.domainValidation.pending.set('ex.localhost:8001', Promise.resolve(true));
 
-      let snapshot2Promise = percy.snapshot({
-        name: 'test snapshot 2',
+      await percy.snapshot({
+        name: 'test snapshot pre-populated pending',
         url: 'http://localhost:8000',
         domSnapshot: testExternalDOM,
         widths: [1000]
       });
 
-      // Wait for validation to be called at least once (with timeout)
-      let attempts = 0;
-      // eslint-disable-next-line no-unmodified-loop-condition
-      while (validationCallCount === 0 && attempts < 50) {
-        await new Promise(resolve => setTimeout(resolve, 10));
-        attempts++;
-      }
-
-      // Validation should only be called once (not twice for concurrent requests)
-      expect(validationCallCount).toBe(1);
-
-      // Resolve the validation
-      if (validationResolvers.length > 0) {
-        validationResolvers[0]([200, { accessible: false }]);
-      }
-
-      await Promise.all([snapshot1Promise, snapshot2Promise]);
       await percy.idle();
 
-      // Still only one validation call even after both snapshots complete
-      expect(validationCallCount).toBe(1);
+      // Validation endpoint should not have been called because pending was pre-populated
+      expect(validationAttempted).toBe(false);
+      expect(validationMock).not.toHaveBeenCalled();
+      // Resource should be captured because the pending promise resolved to truthy
+      expect(captured[0]).toContain(
+        jasmine.objectContaining({
+          attributes: jasmine.objectContaining({
+            'resource-url': 'http://ex.localhost:8001/img.gif'
+          })
+        })
+      );
     });
-
     it('returns the same promise for concurrent validation requests to the same hostname', async () => {
       await percy.stop();