🌟 Welcome

🌟 Welcome to the @fizzwiz/mockchain Blog

“Control the unpredictable — test the asynchronous.”

Welcome to the home of @fizzwiz/mockchain, a mockable Promise library built for testing asynchronous operations in distributed and event-driven systems. Here, we explore how to bring determinism, clarity, and control to the world of asynchronous programming — without losing its expressive power.

🔍 What You’ll Discover

  • ⚙️ Deep Dives — understand how MockChain extends native Promises with mockability and controlled resolution.
  • 🧪 Hands-on Tutorials — see how to test fetch requests, WebSocket messages, and events with full control.
  • 🚀 Real-world Scenarios — explore how mockable chains simplify debugging, integration testing, and CI pipelines.

🤝 Who This Blog is For

This blog is made for:

  • Developers testing async code across distributed nodes — servers, peers, and browsers alike.
  • Engineers who need fine-grained control over asynchronous operations during development or CI.
  • Anyone who’s ever thought: “I wish I could just resolve this Promise myself.”

If you love cleaner, testable, and predictable asynchronous logic — this is your place.

📌 Stay Updated

Each release comes with a dedicated post explaining new features, design decisions, and examples to help you adopt them effortlessly.

“Master the flow of time — one Promise at a time.”
— @fizzwiz ✨

Comments

Post a Comment

Popular posts from this blog

🔑 Why MockChain Is a Chain

🔑 Why   MockChain   Is a Chain When testing asynchronous methods, you often want to   control behavior without rewriting the method logic .   MockChain   allows you to inject and observe behavior at   any point in a promise chain , not just at the start. 🧩 Two Ends of the Chain Consider a typical async method: function fetchData ( url, opts, autoStart = true ) { return MockChain . fromResponse (url, opts, autoStart) . then ( res => res. json ()) . then ( obj => obj. ok ); } There are   three promises   involved: Root node ( root )   — the initial wrapped promise (e.g.,   fetch() ) resolving to a Response object. Mid node   — the in-between promise resolving to the JSON object. Leaf node ( end )   — the last node resolving to a Boolean flag. In tests, you usually mock the   root   to trigger the   end   manually: const chain = fetchData ( undefined , undefined , false ); // don’t awai...
Read more

🏁 The autostart Flag

🏁 The   autostart   Flag — Designing Testable Async Methods Async functions are convenient, but they hide execution inside native Promises — which can’t be intercepted or mocked. To preserve control, every asynchronous method in a distributed system should expose a   autostart   flag . This simple addition enables you to decide   when   asynchronous execution actually happens, giving your tests full deterministic control while keeping production behavior untouched. 🎯 The Idea Instead of rewriting async logic for testing, let each function decide whether to execute its asynchronous flow immediately or defer it. A   mockable method : Runs normally in production ( autostart = true ). Defers execution in tests ( autostart = false ), allowing   MockChain   to intercept and control outcomes. ⚙️ Implementation Pattern import { MockChain } from '@fizzwiz/mockchain' ; /** * Fetch data from a URL. * @param { string } url * @param { boolean ...
Read more

⚠️ Async Functions Are Not Mockable

  ⚠️ Async Functions Are Not Mockable Async functions are convenient in JavaScript, but they are   incompatible with mockable Promises   like   MockChain . This post explains   why   async functions break mockability and how to preserve control over promise chains. ❌ Why Async Functions Break Mockability An   async   function always returns a   native Promise , even if you return another Promise (as a   MockChain ) inside it. async function example ( ) { const chain = MockChain . resolve ( 42 ); return chain; // You think you're returning a MockChain... } const result = example (); console . log (result instanceof MockChain ); // ❌ false Why this happens:   ECMAScript’s   Promise assimilation   wraps any thenable in a new native Promise, so the original instance is lost. Consequences: Custom subclass methods ( .mock() ,   .fail() ,   .root ,   .parent ) disappear. Any attached metadata ( promise...
Read more