Jasmine fake timers and Node.js DNS lookup callback timing

Short answer

Jasmine’s jasmine.clock() only patches JavaScript timers. It cannot intercept libuv‑based I/O such as dns.lookup or tls.connect. Extending the clock to fake those callbacks would break existing suites, hide real‑world latency and error paths, and introduce hard‑to‑debug regressions. The recommended approach is to stub or mock dns.lookup (or the whole dns module) with a synchronous implementation that immediately calls the callback, then use jasmine.clock().tick() to drive any timers in your code.

Why faking libuv would hurt test fidelity

• Hidden timing bugs: Real DNS lookups can time out, return NXDOMAIN, or be delayed by network jitter. A fake clock would mask those conditions, making tests pass when the production code would fail.
• Breaks backward compatibility: Existing tests that rely on the actual order of events between timers and I/O would start firing in a different sequence, potentially causing false positives or negatives.
• Complex integration: libuv runs in a native thread pool. Patching it would require deep integration with Node’s C++ internals, a maintenance burden that outweighs the benefits for most projects.

Practical workaround: stub dns.lookup

1. Install a stubbing library (e.g., sinon or proxyquire) that can replace the dns module before your code under test is required.
2. Define a synchronous stub:

   const sinon = require('sinon');
   const dnsStub = sinon.stub();
   dnsStub.withArgs('example.com', sinon.match.any, sinon.match.func).callsFake((host, opts, cb) => {
     // Immediately invoke the callback with a fake address.
     cb(null, '127.0.0.1', 4);
   });
   

3. Use proxyquire to inject the stub:

   const myModule = proxyquire('./myModule', { dns: { lookup: dnsStub } });
   

4. Run your test with jasmine.clock().install(), execute the code, then jasmine.clock().tick() any timers you need to advance. The DNS callback will fire synchronously, keeping the test deterministic.
5. Optionally, restore the original dns.lookup after the test with dnsStub.restore().

When you might still need real DNS behavior

If your code path depends on DNS errors (e.g., handling ENOTFOUND or timeouts), you can configure the stub to call the callback with an error for specific hosts:

dnsStub.withArgs('bad-host', sinon.match.any, sinon.match.func).callsFake((host, opts, cb) => {
  cb(new Error('ENOTFOUND')); // or cb({ code: 'ENOTFOUND' });
});

In such cases, the stub still runs synchronously, but you exercise the error handling logic.

Ask for missing diagnostic detail

Do you need to assert on actual DNS latency or error propagation in your tests? If so, a stub that mimics latency (e.g., using setTimeout) or an integration test with a real DNS server might be more appropriate.

Summary

Jasmine’s fake timers are intentionally limited to JavaScript timers. Extending them to cover libuv I/O would degrade test reliability and maintainability. The safest path is to stub dns.lookup (or the entire dns module) with a synchronous implementation, then use the fake timer to drive any timers in your code. This keeps tests fast, deterministic, and faithful to the real I/O behavior your code expects.