Writing tests for their own sake is a pointless chore:
describe('add numbers', () => { it('should add two numbers', () => { expect(add(1, 2)).toBe(3) }) it('should add two other numbers', () => { expect(add(3, 4)).toBe(7) })});
Another annoying testing problem is when tests are too brittle, and paint your logs red even though the application seems to work just fine.
When your tests lack real purpose or seem to fail for no good reason, it's no wonder you start to question their value.
Tests are supposed to give you confidence in your code, and save you from shipping broken stuff to prod. So why does writing them feel like such a burden?
The problem is that tests like these are focused on implementation details instead of the underlying behavior. Everyone talks about the importance of testing, but there's a lack of understanding about how to write tests that are actually useful.
How would it feel to have 100% trust in your tests, knowing that any failures are not a false alarm? What if you could seamlessly translate the underlying behavior of your application into tests that are easy (and even fun) to write?
It's possible, but it requires you to take a step back from just syntax.
In order to have the confidence you're testing the right things in the right ways, you need to dig into the underlying patterns behind the scenes of a testing framework.
This is exactly what you will do in Testing Fundamentals.
In this workshop, Artem Zakharchenko, testing expert and creator of the Mock Service Worker API mocking library, will guide you through creating your own version of the Vitest testing framework.
Building a testing framework from scratch will give you a deep understanding of how the pieces fit together, and change the way you think about testing for the better.
What You'll Learn
The workshop is broken out into four parts, each with its own challenges and exercises that build upon the last:
Principles
First, you'll explore the principles and mental models that underlie testing strategies. This is where you will begin to distinguish between the intention of your code and its implementation details. When you focus the intention of what your code should accomplish, you can write tests that are more resilient to change.
Test Structure
Next, you'll do a deep dive into the structure of the testing framework. You'll create your own expect and test functions, configure your test environment, and use hooks to manage side effects in your tests.
Testing Asynchronous Code
Testing asynchronous code requires a slightly different approach when compared to testing synchronous code. Here you'll practice with testing promises and async functions, as well as handling errors and rejections.
Moving to Vitest
Once you've learned the fundamentals of testing and built your own mini-framework, you will migrate your tests to the Vitest framework. This process will cement your understanding of not just the "hows", but also the "whys" of testing.
Who This Workshop Is For
This workshop is for developers who have some testing experience, but feel like they're missing the bigger picture. If you're tired of writing tests that feel like a chore, and want to understand how to write tests that are actually useful, this workshop is for you.