Zero Dependency Testing With Node.js

Rate this content

Node.js recently shipped an experimental test runner. This talk will explore the test runner's architecture and API, and show how to use it with other core modules to create a testing experience with no external dependencies. This talk will also look at potential future additions to the test runner.

10 min
03 Nov, 2022

Video Summary and Transcription

Today's Talk is about zero dependency testing with Node.js. The new test runner in Node.js supports CLI and standalone file execution, and different test runner styles are supported. Writing tests with Node.js is simple using its assert and test modules. The test runner passed one test and failed another, and future work includes implementing a tap parser and adding code coverage and mocking features.

Available in Español

1. Zero Dependency Testing with Node.js

Short description:

Today I'm going to be talking about zero dependency testing with Node.js. Almost all projects need a test runner. Node.js has a good assertion library, reducing dependencies. Many test runners have overlapping functionality. Having a built-in test runner reduces risks and costs. The trend is to include test runners in runtimes. The new test runner in Node supports CLI and standalone file execution. It supports synchronous, promises, async/await, and callback-based tests. Different test runner styles are supported.

Hi everyone! Thanks for coming to my talk. Today I'm going to be talking about zero dependency testing with Node.js, which essentially means that you can start writing your unit tests, integration tests, without having to install anything from NPM.

So before getting into the the nature of Node's new test runner, I wanted to talk a little bit about why a test runner was desired in the first place. So almost all projects need a test runner. So whether you're building an application or a module that you're planning to publish on NPM or whatever, if you're planning to have other people use your code, you almost certainly need tests for it. And then Node.js for years now has shipped with a really good assertion library that's just import assert. This is the assertion library that I've been using for years now. I like it, so that's one less dependency.

And then most test runners overlap a lot in terms of functionality anyway. So, you know, every test runner runs some tests. They generally have features like timeouts, you know, reporting which tests passed and failed, skipping tests, things like that. So, you know, there are differences, so some test runners are more suited to front-end development, some do things like injecting globals into your code without your knowledge, some execute their tests inside of different contexts, so, you might have surprising results whenever you check for equality and things like that. But, you know, so there are these rough edges, but in general, a lot of test runners have a lot of overlap.

And then on top of that, NPM is just really a dangerous place. There's, you know, over the years, there's been a number of incidents, things like left pad, the colors JS thing, even more recently, the minimist package, which I think has like 50 million downloads or something like that, nothing happened to it on NPM, but the GitHub repository went away. So, all of these third party dependencies that you're taking on come with some risk and some cost. And so, that's just, you know, one reason why having a test runner built in, I feel, is useful. And also, there's just a general trend to have more of these batteries included in the runtimes. So, you know, now Node has a built-in test runner. I'm pretty sure Bun has one, I know Deno has one. So, this is becoming more and more common.

And then, you know, here's my tweet from over a year ago, I believe that Node should ship a test runner and, you know, I feel pretty strongly about that. So, some of the features in the new test runner, you can run the test runner through the CLI interface that has the Node chips now with the dash dash test flag. Or you can actually just execute a standalone file containing tests. So, say you have your file foo.js, you can say Node foo.js and if you're using the test runner in there, it will still just work. When it comes to actually writing tests themselves, there's, you know, we support synchronous code, promises or async await based code. And even, you know, because Node still does have a lot of callback-based APIs, we support callback-based tests as well. If you're coming from a test runner like tap or tape, then we do support test style tests, using the test function. If you're coming from a test runner like Mocha or Jest, we have describe and IT functions. So, under the hood, everything uses test, describe and IT are just kind of implemented on top of test.

2. Writing Tests with Node.js

Short description:

If you're looking for that familiar API, it is there. We support nesting tests, skipping tests, and filtering tests by name. Writing a test is simple with Node's assert and test modules. The test runner is published on NPM and supports Node 14, 16, and 18. After executing tests, the output follows the test anything protocol (tap).

But, you know, if you're looking for that familiar API, it is there. We support nesting tests, so you can have, you know, a test with arbitrarily nested tests inside of it. Same if you have describe. You can have suites containing more suites and more tests and things like that.

Skip and to do tests. So, you know, if you just want to skip over a test, there's a few different ways that you can do that. To do is kind of similar to skip in the fact that it won't cause your test suite to fail. But it will still execute the test and kind of don't care about the result. We also have only tests. So if you start the CLI runner with dash dash test only, then any test that you have annotated as being only tests are the only ones that will be executed. And then you can also filter tests by the name of the test. So if you use the dash dash test name pattern, you can actually pass in a regular expression and node will only execute the test whose names match that pattern.

So if you wanted to actually write a test, what would it look like? Here's a very simple example using nothing but node's assert module and node's test module. Here we have two tests. One is a synchronous test that passes and the other is an asynchronous test which fails. The asynchronous test will, even though it looks like synchronous code, it's an async function so it returns a promise. That promise rejects whenever the assertion fails. So two things worth noting here is you'll see here we're using node colon test. The node colon prefix can be used to import any node core module. But starting with the test module and likely with all modules added to node core moving forward, you have to use the node colon prefix. If you just try to use the word test here, it would actually fall back to trying to load from user land. And speaking of user land, the test runner itself is actually published on NPM. So right now the test runner exists in node 18 and 16. Node 14 is still supported, though. So a few people took the code from node core, kind of ported it to work in an NPM module, and published it. So you can just NPM install test if you're on node 14, and you'll still have access to all this functionality. So after you execute your test, this is what the output will look like. So this output is called tap, which stands for test anything protocol. And it's not the most easy for humans to parse, but you can do interesting things like, you know, pipe it into a different reporters and things like that, and have it formatted differently. But you can see here that we have okay 1, that's the first test, that was the synchronous passing test.

3. Test Runner Results and Future Work

Short description:

The test runner passed one test and failed another. The test failure was due to an assertion that expected the value 1 to be equal to 2. The test summary showed that two tests were executed, with one passing and one failing. The entire process took about 11 milliseconds. Future work for the test runner includes implementing a tap parser for better reporting, building out reporters to transform tap output, and adding code coverage and mocking features. The test runner is still experimental, but no major breaking changes are expected. Check out the documentation and give it a try!

It passed in 1.87 milliseconds. And then the second test was not okay. Not okay is how tap indicates a failure. You can see that there was a test code failure. We expected the assertion... we asserted that the value 1 would be equal to 2, and clearly, it's not. So the test failed.

And then at the bottom, we have a little test summary. So there were two tests that were executed. One passed, one failed, zero were canceled, zero skipped. No to-do tests. And then the entire process took about 11 milliseconds.

So just some of the future work for the test runner. We have a pull request that's open right now for a tap parser. So that will allow us to do better reporting inside of the CLI runner. The CLI for every file that it's going to execute, it spawns a child process that generates its own tap. The way it works now is if there's a failure, then we just take all of the standard output and standard error for that file and display it. If no tests fail, then we kind of just say it passed and don't show any output. The tap parser will actually allow us to intelligently parse that output and display things a little more nicely. We also want to use the tap parser to build out reporters. As I said earlier, tap is not the prettiest thing to look at. We want to implement some reporters that can actually transform that into something a little easier for humans to read. Then we'd like to build in code coverage and mocking, just because these are two pretty significant features that really make a test runner feel mature, in my opinion. So the test runner is still listed as experimental, but I don't expect there to be a lot, if many at all, breaking changes in it. I have a link here to the documentation for it. I encourage everyone to go out and at least give it a try. That's everything I had. Thanks for coming.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

Remix Conf Europe 2022Remix Conf Europe 2022
23 min
Scaling Up with Remix and Micro Frontends
Top Content
Do you have a large product built by many teams? Are you struggling to release often? Did your frontend turn into a massive unmaintainable monolith? If, like me, you’ve answered yes to any of those questions, this talk is for you! I’ll show you exactly how you can build a micro frontend architecture with Remix to solve those challenges.
TestJS Summit 2021TestJS Summit 2021
33 min
Network Requests with Cypress
Top Content
Whether you're testing your UI or API, Cypress gives you all the tools needed to work with and manage network requests. This intermediate-level task demonstrates how to use the cy.request and cy.intercept commands to execute, spy on, and stub network requests while testing your application in the browser. Learn how the commands work as well as use cases for each, including best practices for testing and mocking your network requests.
TestJS Summit 2021TestJS Summit 2021
38 min
Testing Pyramid Makes Little Sense, What We Can Use Instead
Top Content
Featured Video
The testing pyramid - the canonical shape of tests that defined what types of tests we need to write to make sure the app works - is ... obsolete. In this presentation, Roman Sandler and Gleb Bahmutov argue what the testing shape works better for today's web applications.
Remix Conf Europe 2022Remix Conf Europe 2022
37 min
Full Stack Components
Top Content
Remix is a web framework that gives you the simple mental model of a Multi-Page App (MPA) but the power and capabilities of a Single-Page App (SPA). One of the big challenges of SPAs is network management resulting in a great deal of indirection and buggy code. This is especially noticeable in application state which Remix completely eliminates, but it's also an issue in individual components that communicate with a single-purpose backend endpoint (like a combobox search for example).
In this talk, Kent will demonstrate how Remix enables you to build complex UI components that are connected to a backend in the simplest and most powerful way you've ever seen. Leaving you time to chill with your family or whatever else you do for fun.
JSNation Live 2021JSNation Live 2021
29 min
Making JavaScript on WebAssembly Fast
Top Content
JavaScript in the browser runs many times faster than it did two decades ago. And that happened because the browser vendors spent that time working on intensive performance optimizations in their JavaScript engines.Because of this optimization work, JavaScript is now running in many places besides the browser. But there are still some environments where the JS engines can’t apply those optimizations in the right way to make things fast.We’re working to solve this, beginning a whole new wave of JavaScript optimization work. We’re improving JavaScript performance for entirely different environments, where different rules apply. And this is possible because of WebAssembly. In this talk, I'll explain how this all works and what's coming next.
React Summit 2023React Summit 2023
24 min
Debugging JS
As developers, we spend much of our time debugging apps - often code we didn't even write. Sadly, few developers have ever been taught how to approach debugging - it's something most of us learn through painful experience.  The good news is you _can_ learn how to debug effectively, and there's several key techniques and tools you can use for debugging JS and React apps.

Workshops on related topic

React Summit 2023React Summit 2023
151 min
Designing Effective Tests With React Testing Library
Featured Workshop
React Testing Library is a great framework for React component tests because there are a lot of questions it answers for you, so you don’t need to worry about those questions. But that doesn’t mean testing is easy. There are still a lot of questions you have to figure out for yourself: How many component tests should you write vs end-to-end tests or lower-level unit tests? How can you test a certain line of code that is tricky to test? And what in the world are you supposed to do about that persistent act() warning?
In this three-hour workshop we’ll introduce React Testing Library along with a mental model for how to think about designing your component tests. This mental model will help you see how to test each bit of logic, whether or not to mock dependencies, and will help improve the design of your components. You’ll walk away with the tools, techniques, and principles you need to implement low-cost, high-value component tests.
Table of contents- The different kinds of React application tests, and where component tests fit in- A mental model for thinking about the inputs and outputs of the components you test- Options for selecting DOM elements to verify and interact with them- The value of mocks and why they shouldn’t be avoided- The challenges with asynchrony in RTL tests and how to handle them
Prerequisites- Familiarity with building applications with React- Basic experience writing automated tests with Jest or another unit testing framework- You do not need any experience with React Testing Library- Machine setup: Node LTS, Yarn
TestJS Summit 2022TestJS Summit 2022
146 min
How to Start With Cypress
Featured WorkshopFree
The web has evolved. Finally, testing has also. Cypress is a modern testing tool that answers the testing needs of modern web applications. It has been gaining a lot of traction in the last couple of years, gaining worldwide popularity. If you have been waiting to learn Cypress, wait no more! Filip Hric will guide you through the first steps on how to start using Cypress and set up a project on your own. The good news is, learning Cypress is incredibly easy. You'll write your first test in no time, and then you'll discover how to write a full end-to-end test for a modern web application. You'll learn the core concepts like retry-ability. Discover how to work and interact with your application and learn how to combine API and UI tests. Throughout this whole workshop, we will write code and do practical exercises. You will leave with a hands-on experience that you can translate to your own project.
React Summit 2022React Summit 2022
117 min
Detox 101: How to write stable end-to-end tests for your React Native application
Top Content
Compared to unit testing, end-to-end testing aims to interact with your application just like a real user. And as we all know it can be pretty challenging. Especially when we talk about Mobile applications.
Tests rely on many conditions and are considered to be slow and flaky. On the other hand - end-to-end tests can give the greatest confidence that your app is working. And if done right - can become an amazing tool for boosting developer velocity.
Detox is a gray-box end-to-end testing framework for mobile apps. Developed by Wix to solve the problem of slowness and flakiness and used by React Native itself as its E2E testing tool.
Join me on this workshop to learn how to make your mobile end-to-end tests with Detox rock.
Prerequisites- iOS/Android: MacOS Catalina or newer- Android only: Linux- Install before the workshop
React Day Berlin 2022React Day Berlin 2022
86 min
Using CodeMirror to Build a JavaScript Editor with Linting and AutoComplete
Top Content
Using a library might seem easy at first glance, but how do you choose the right library? How do you upgrade an existing one? And how do you wade through the documentation to find what you want?
In this workshop, we’ll discuss all these finer points while going through a general example of building a code editor using CodeMirror in React. All while sharing some of the nuances our team learned about using this library and some problems we encountered.
TestJS Summit 2023TestJS Summit 2023
48 min
API Testing with Postman Workshop
In the ever-evolving landscape of software development, ensuring the reliability and functionality of APIs has become paramount. "API Testing with Postman" is a comprehensive workshop designed to equip participants with the knowledge and skills needed to excel in API testing using Postman, a powerful tool widely adopted by professionals in the field. This workshop delves into the fundamentals of API testing, progresses to advanced testing techniques, and explores automation, performance testing, and multi-protocol support, providing attendees with a holistic understanding of API testing with Postman.
1. Welcome to Postman- Explaining the Postman User Interface (UI)2. Workspace and Collections Collaboration- Understanding Workspaces and their role in collaboration- Exploring the concept of Collections for organizing and executing API requests3. Introduction to API Testing- Covering the basics of API testing and its significance4. Variable Management- Managing environment, global, and collection variables- Utilizing scripting snippets for dynamic data5. Building Testing Workflows- Creating effective testing workflows for comprehensive testing- Utilizing the Collection Runner for test execution- Introduction to Postbot for automated testing6. Advanced Testing- Contract Testing for ensuring API contracts- Using Mock Servers for effective testing- Maximizing productivity with Collection/Workspace templates- Integration Testing and Regression Testing strategies7. Automation with Postman- Leveraging the Postman CLI for automation- Scheduled Runs for regular testing- Integrating Postman into CI/CD pipelines8. Performance Testing- Demonstrating performance testing capabilities (showing the desktop client)- Synchronizing tests with VS Code for streamlined development9. Exploring Advanced Features - Working with Multiple Protocols: GraphQL, gRPC, and more
Join us for this workshop to unlock the full potential of Postman for API testing, streamline your testing processes, and enhance the quality and reliability of your software. Whether you're a beginner or an experienced tester, this workshop will equip you with the skills needed to excel in API testing with Postman.
TestJS Summit - January, 2021TestJS Summit - January, 2021
173 min
Testing Web Applications Using Cypress
This workshop will teach you the basics of writing useful end-to-end tests using Cypress Test Runner.
We will cover writing tests, covering every application feature, structuring tests, intercepting network requests, and setting up the backend data.
Anyone who knows JavaScript programming language and has NPM installed would be able to follow along.