 Courses from Artem Zakharchenko

Mock Service Worker is an API mocking library that allows you to write client-agnostic mocks and reuse them across any frameworks, tools, and environments.



Mocking WebSocket APIs with Mock Service Worker

In tests, mocking gives us a way to reproduce different network-related scenarios. Like in this lesson, we will create a runtime event handler for our WebSocket client messages to test a scenario when another user responds to a sent message in the chat.

## Resources

- [`server.use()` API](https://mswjs.io/docs/api/setup-server/use)


Override WebSocket Event Handling in Tests with MSW

Override WebSocket event handling on a per-test basis in Vitest using Mock Service Worker.

Let's write an end-to-end test for our chat application using Playwright. For this one, we will reuse the browser integration of Mock Service Worker to also run during the automated test.

## Resources

- [Playwright](https://playwright.dev/)


Test WebSockets in Playwright with MSW

Write an end-to-end (E2E) test for a WebSocket application in Playwright using Mock Service Worker.

Let's write an integration test for our `<Chat/>` component in Vitest and React Testing Library. 

The WebSocket interception in MSW requires a global `WebSocket` class. You are covered if you're using Node.js v22 or higher since that global class exists there. But for older versions, we will create a custom Vitest environment to polyfill it using `undici`.

## Resources

- [Vitest](https://vitest.dev/)
- [Undici](https://github.com/nodejs/undici)
- [Testing Library](https://testing-library.com/)


Test WebSockets in Vitest with MSW

Write an integration test for a WebSocket component in Vitest and React Testing Library (RTL) using Mock Service Worker.

When mocking a WebSocket connection in the browser, MSW takes charge of logging WebSocket events in the console. In this one, we explore the different log types and learn how to read the log output of your WebSocket links.

## Resources

- [WebSocket logging](https://mswjs.io/docs/basics/handling-websocket-events#logging)


Understand WebSocket Logs in MSW

Read the WebSocket logging in the browser when mocking APIs with Mock Service Worker.

Mocking WebSocket APIs resembles how you use them in the actual code. This means that you can control the event flow for your client and server events as you normally would when using `EventTarget`. Let's explore how to use `event.stopPropagation()` and `event.stopImmediatePropagation()` to achieve behavior layering when mocking WebSocket events. 

## Resources

- [WebSocket event flow](https://mswjs.io/docs/basics/handling-websocket-events#event-flow)


Prevent WebSocket Event Propagation Between Listeners with MSW

Control WebSocket event propagation between different listeners with Mock Service Worker.

Sicne we're involving an actual WebSocket server in our mock, what happens if that server disconnects? Well, the client connection will close, which is a bummer. Let's see how to listen and prevent original server's `close` event, and also conditionally fallback to MSW to act as the server if that happens.

## Resources

- [`server.addEventListener()`](https://mswjs.io/docs/api/ws#addeventlistenerevent-listener-options-1)


Prevent WebSocket Server Close Event with MSW

Prevent original WebSocket server closures with Mock Service Worker.

The WebSocket client events are also being forwarded to the original WebSocket server since we've called `server.connect()`. Luckily, to opt-out from this forwarding we have to do just the same—call `event.preventDefault()` on any client event we don't want to be forwarded to the server.

## Resources

- [WebSocket client-to-server forwarding](https://mswjs.io/docs/basics/handling-websocket-events#client-to-server-forwarding)


Send Mocked WebSocket Client Messages to the Original Server with MSW

Send mocked WebSocket client messages to the original WebSocket server using Mock Service Worker.

By default, once we establish the actual WebSocket server connection in the mock, all the server events will be forwarded to the client. You can opt-out from this default behavior by calling `event.preventDefault()` on any intercepted server event.

## Resources

- [WebSocket server-to-client forwarding](https://mswjs.io/docs/basics/handling-websocket-events#server-to-client-forwarding)


Prevent Server-to-client Message Forwarding in MSW

Prevent the default forwarding of the original WebSocket server events in mocks with Mock Service Worker.

Now that we have the connection to the actual WebSocket server established, we can listen to any events sent from the server to the client. The thing is, our event handler in MSW will receive those events before the client does.

## Resources

- [Intercepting WebSocket server events](https://mswjs.io/docs/basics/handling-websocket-events#intercepting-server-events)


Intercept WebSocket Server Events with MSW

Listen to the actual WebSocket server events using Mock Service Worker.

Event handlers in MSW represent a WebSocket server. And it so happened a single server may manage a communication across multiple clients. Let's see how we can close multiple WebSocket client connections at once!

We can get access to the set of all connected WebSocket clients in the `chat.clients` property. From then, it's a matter of iterating over them and calling `client.close()` on individual clients.

## Resources

- [`.clients`](https://mswjs.io/docs/api/ws#clients)
- [`client.close()` API](https://mswjs.io/docs/api/ws#closecode-reason)


Close Multiple WebSocket Clients with MSW

Close multiple connected WebSocket clients at once using Mock Service Worker.

With MSW, you can use custom close codes that are otherwise unusable on the client. For example, in this lesson we will emulate a WebSocket connection closure due to a 1003 status code, which means that the server is unable to process the incoming data.

## Resource

- [`client.close()` API](https://mswjs.io/docs/api/ws#closecode-reason)


Use a Custom Close Code to Close a WebSocket Connection with MSW

Close a WebSocket client connection with a custom, non-configurable close code using Mock Service Worker.

Let's see how our WebSocket client reacts to the connection being closed. Use the `client.close()` method in the event handler to reliably reproduce client connection closures.

## Resources

- [Closing WebSocket client connections](https://mswjs.io/docs/basics/handling-websocket-events#closing-client-connections)
- [`client.close()` API](https://mswjs.io/docs/api/ws#closecode-reason)


Close a WebSocket Client Connection with Mock Service Worker

Close an intercepted WebSocket client via `client.close()` in Mock Service Worker.

As we send and handle more and more WebSocket events, it would be great to bring some type safety to the mix. But type safety along won't cut it. We need the runtime safety as well.

Luckily, `zod` is to the rescue. In this one, we will use `zod` to create a chat message schema and use it to create `createChangeMessage` and `parseChatMessage` utilities to help us develop and mock our WebSocket API.

## Resources

- [Zod](https://zod.dev/)


Make a Type-safe and Runtime-safe WebSocket Communication with Zod

Ensure runtime and type-safety of a WebSocket communication using Zod.

One of the reasons to mock any API is to get control over it. In this one, we will replay a chat conversation between two non-existing users by empoying everything we've learned so far.  To replay that conversation for a particular WebSocket client, we will use the `client.send()` API.

## Resources

- [`client.send()` API](https://mswjs.io/docs/api/ws#senddata)


Replay a WebSocket Chat Conversation with Mock Service Worker

Reproduce different WebSocket clients communicating using Mock Service Worker.

Listening to the outgoing WebSocket client events is nice, but how about we _modify_ them?

Let's parse the incoming `MessageEvent` data using `JSON.parse`, modify it, and provide its stringified version to the `chat.broadcast()` call to broadcast a different data.

## Resources

- [`.broadcast()` API](https://mswjs.io/docs/api/ws#broadcastdata)


Modify WebSocket Client Events with Mock Service Worker

Modify intercepted WebSocket client messages using Mock Service Worker.

Letting you know about the WebSocket connections isn't the only thing a WebSocket link can do. In fact, it also gives you a `broadcast()` method to send a message to all the connected clients. Let's use that to broadcast a chat message in our app across multiple open browser tabs.

## Resources

- [Broadcasting data to clients](https://mswjs.io/docs/basics/handling-websocket-events#broadcasting-data-to-clients)
- [`.broadcast()` API](https://mswjs.io/docs/api/ws#broadcastdata)


Broadcast a Mocked Message to All WebSocket Clients

Broadcast data to multiple WebSocket clients using Mock Service Worker.

The `connection` event listener of your WebSocket link exposes a bunch of useful parameters to you. One of those parameters is the `client` object that represents the intercepted WebSocket client that establishes the connection. 

Add a `message` event listener on that `client` to know when it sends any messages in your application. And yes, this is a regular event listener! This means you get a `MessageEvent` instance as a parameter, and can observe the data sent via WebSocket.

## Resources

- [Intercepting WebSocket client events](https://mswjs.io/docs/basics/handling-websocket-events#intercepting-client-events)


Intercept WebSocket Client Events with Mock Service Worker

Intercept a "message" WebSocket client event using Mock Service Worker.

To intercept any WebSocket connection in your app, create a _WebSocket link_ using the `ws.link()` API from MSW. Provide it a URL predicate and store the link in a variable. Then, add the `connection` event listener to your WebSocket link to know when a connection is being established. Provide the result of that event listener to your `handlers` array, and you're good to go!

## Resources

- [Intercepting WebSocket connections](https://mswjs.io/docs/basics/handling-websocket-events#intercepting-connections)
- [The `ws` API](https://mswjs.io/docs/api/ws)


Intercept a WebSocket connection with Mock Service Worker

Intercept a WebSocket connection in a Remix app using Mock Service Worker.

Set up Mock Service Worker in the browser, (1) generate a worker script via the `npx msw init` command; (2) create `mocks/borwser.ts` and use `setupWorker()` to create a worker instance; (3) defer your application's rendering in `entry.client.tsx` by introducing an `enableMocking()` function that calls `await worker.start()`.

## Resources

- [Browser integration of MSW](https://mswjs.io/docs/integrations/browser)
- [`setupWorker()`](https://mswjs.io/docs/api/setup-worker)
- [ `worker.start()`](https://mswjs.io/docs/api/setup-worker/start)


Set Up Mock Service Worker in the Browser

Install Mock Service Worker (MSW)

When comparing two visually similar websites, it can often be challenging to precisely identify the subtle differences between them. To facilitate a rapid analysis of these discrepancies, a practical technique involves leveraging Chrome's integrated developer tools to capture full-page screenshots of each site. Subsequently, these screenshots can be uploaded to a platform like AI Studio. There, the AI can analyze the images and generate a report detailing the variations. This entire process, leveraging a few quick shortcuts, can be completed in under a minute, delivering a comprehensive breakdown of the differences for efficient comparison and analysis.

Quickly Compare Two Sites Using AI Studio with Chrome Full Page Screenshots

It's fairly trivial to create a React project, but there's always a big hurdle between creating it locally and making it shareable so that someone else can run it. This lesson walks you through the process of automating creating a React project locally, creating the repository where it's going to be hosted, and creating shareable links where it can be run so that you can quickly and easily create single one-off demos and shoot them over to your friends and coworkers for sharing your code ideas in a working environment.


```bash
share-react-project() {
  if [[ -z "$1" ]]; then
    echo "Usage: share-react-project <project_name>"
    return 1
  fi

  local project_name="$1"
  local github_username=$(gh api /user --jq '.login')

  echo "Creating Vite project: $project_name"
  pnpm create vite "$project_name" --template react

  cd "$project_name"

  echo "Initializing Git repository"
  git init

  echo "Adding all files to Git"
  git add .

  echo "Creating initial commit"
  git commit -m "Initial commit"

  local codesandbox_link="https://codesandbox.io/p/github/${github_username}/${project_name}"

  echo "Adding CodeSandbox link to README.md"
  echo "" >> README.md
  echo "## CodeSandbox" >> README.md
  echo "[![Open in CodeSandbox](https://assets.codesandbox.io/github/button-edit-blue.svg)](${codesandbox_link})" >> README.md

  echo "Adding README.md to Git"
  git add README.md

  echo "Committing README.md changes"
  git commit -m "Add CodeSandbox link"

  echo "Creating GitHub repository: $github_username/$project_name"
  gh repo create "$github_username/$project_name" --public

  echo "Pushing to remote 'origin'"
  git push -u origin main

  echo "Project '$project_name' created successfully!"
  echo "GitHub repository: https://github.com/$github_username/$project_name"
  echo "CodeSandbox link: $codesandbox_link"
}
```

Automate Creating a Local React Project, GitHub Repository, and Live Hosted Demo in a Single Command

[Verdaccio](https://verdaccio.org/) is a fully featured NPM registry that you can run locally on your machine. It’s a great tool for testing your release process, running end-to-end tests, and simulating real-world scenarios like deploying packages, installing them, and verifying functionality as an end user would.

Nx includes a [generator](https://nx.dev/features/generate-code) that simplifies setting up Verdaccio. To configure it, run:

```shell
npx nx g @nx/js:setup-verdaccio   
```

This command installs the necessary NPM packages and creates a `project.json` file with a `local-registry` target. To start the local registry, open a new terminal window and run:

```shell
npx nx local-registry
```

This will:
- Launch the Verdaccio registry.
- Configure NPM to point to the local Verdaccio server at `http://localhost:4873`.

> **Note:** A `project.json` file provides an advanced way to define scripts, offering more flexibility than a traditional `package.json` for managing complex targets.

Setup local Verdaccio server to release NPM packages

Learn how to spin up a local NPM registry powered by Verdaccio to test deploy your NPM packages.

In TypeScript, developers often begin by defining the structure of their data using type definitions or interfaces, which is a powerful way to ensure type safety. However, as applications grow and become more complex, simply defining the shape of an object might not be enough to guarantee its consistent creation and behavior throughout the codebase. This often leads to situations where objects that are intended to be of a certain "type" might be missing crucial properties or have incorrect data, which can be difficult to track down and debug.

This lesson tackles the question of when and why to move beyond basic type definitions and embrace classes in TypeScript. It demonstrates how classes provide a more robust mechanism for defining object structure, enforcing type constraints, and ensuring consistent object creation. By establishing a clear blueprint for objects, classes not only improve compile-time type safety but also offer runtime benefits and better code organization, ultimately helping developers avoid common pitfalls associated with loosely structured objects in larger TypeScript projects.

Stop Avoiding Classes in TypeScript

Karabiner isn't only for your keyboard. It can also hijack your mouse buttons and enable them to be similar to layers on your keyboard, where holding down a mouse button can allow you to tap keys on your keyboard to trigger commands and macros that can completely revolutionize your workflows. For example, you can hold down the right mouse button and tap on R to go to references in VS Code. Or hold down the right mouse button and tap the left mouse button to chop up videos and Screenflow.

This completely unlocks a whole new world of possibilities and use cases for your mouse as you can hover your mouse over anywhere on the page. And just tapping keys on your keyboard allows you to trigger mouse actions, to trigger keyboard actions, or to trigger macros and applications and terminal commands. and anything that your imagination can come up with. 

Karabiner: Rethinking Right-Click as a Macro Command Center

Make an HTML table more readable on mobile devices by using the ::before pseudo-element. We add labels to each cell, so they appear like cards when the table is viewed on smaller screens. The ::before content is set using a data-label attribute for each cell to enhance mobile viewability without horizontal scrolling.



Create a mobile friendly table with the before pseudo-element

Learn to use CSS ::before pseudo-element for mobile-friendly HTML tables. Add labels to cells for enhanced readability on mobile, avoiding horizontal scroll.

Any app of a decent size has event flows and messages being passed around. At a certain point it becomes complicated to explain it through prose and you want to turn towards diagrams. Now setting aside the time to create diagrams that accurately describe what's happening in your codebase can be quite time consuming. Luckily, with today's AI tools, we can now just do basic walkthroughs with rough recordings over codebase dictating what's going on along the way and then upload that to tools like AI Studio and then ask it to generate diagrams in a text-based format such as Mermaid that will then generate the flowcharts and diagrams for us. So this video walks us through this process of recording a rough video, uploading it to AI Studio and then asking AI Studio to generate the proper Mermaid diagram syntax.

Generate Mermaid Flow Chart Diagrams with Gemini 2.0 from Rough Screen Recordings

I'm a diehard Karabiner user and anytime I start doing something repetitively I always move it into my Karabiner configuration. Sometimes I'll fall into scenarios where I want to trigger a command, but I also want to know if that command succeeded or failed. Since Karabiner can trigger any command, setting up the command is fairly straightforward, but knowing whether it succeeded or failed became much more difficult. Luckily for me there is a package called terminal-notifier that you can install from homebrew and you can pipe the output of your command to terminal-notifier. And have a seamless way of triggering your keyboard shortcut which runs a command and you can be notified of the results.

Use Karabiner to Trigger a Terminal Command and Get Notified of the Results

There are a lot of scenarios when inspecting a site in Chrome where you don't want any click events to fire and you don't want any scripts to run. Or maybe something is animating in and out of the page and you want to capture it at a certain moment. This is a great use case for pausing script execution, which is kind of using the debugger manually by going into the Chrome DevTools and the Sources tab and clicking the pause button to essentially pause the entire page. This will give you a chance to inspect any of the elements and styles you want to inspect. And you don't have to worry about fire and click events or anything that might interrupt your investigation into the elements and styles that you want to find.

Pause Script Execution in Chrome to Easily Inspect Elements

Gemini 2.0 has a context window of a million tokens, and this means that you can upload hundreds of files and allow it to inspect and analyze massive refactors across entire code bases. 

This lesson demonstrates concatenating an entire code base into a single file and then uploading it to AI Studio. Once within AI Studio, we ask it to find the types of tasks that it can evaluate for us. Then we select one of the tasks and ask it to generate instructions for that task. Once those instructions are complete, we then turn them over to Windsurf's Cascade agent, and we allow Windsurf's Cascade to do all of the work for us as we sit back, relax, and let the AI do our jobs.

Artem Zakharchenko

Search Results