Testing JavaScript ( Kent C. Dodds )

Learn the smart, efficient way to test any JavaScript application.

—YOUR ESSENTIAL Manual for FLAWLESS TESTING —

What is the point of testing your JavaScript?

At the point when a client encounters a bug they seem to be this: 🤬

Bugs grind work to a halt.

Bugs cause financial harm.

Each and every time a bug is encountered, client trust dissolves.

Bugs are bad.

And who gets blamed?

You.

The developer.

You realize you ought to squash bugs before your code is conveyed.

You realize you want to transport code that:

Takes each opportunity to guarantee that it works.

Doesn't rebuff clients with unnecessary bugs.

Doesn't play whack-a-mole with features, fixing one thing just to break another.

Is maintainable and understandable to your co-laborers.

A professional ships working code. Code that works.

We're talking about code that is very much tested. Just through testing can you confidently convey confident, professional code.

For what reason aren't you testing code that clients depend on?

When code fails on your clients, have you failed to take care of your business?

You ought to take care of your business as well as conceivable and test, isn't that so?

Right.

Only one issue...

 

"Testing takes too much time and effort."

Time is running out. You're occupied already.

There's no undeniable ROI. You can't get the up front investment or spending plan for testing efforts.

It's basically impossible to test everything. Most testing is click clicking around each turn of your application. It takes everlastingly and feels like a waste of time — time you want to spend transporting new features, not QAing.

No one has time for that. Be that as it may, somehow, your application will be tested. While possibly not by you, then by your clients.

Cross your fingers and push to goad.

So... click click stay optimistic? That's what we're doing?

To transport superior grade, very much tested JavaScript applications there has to be a superior way.

 

Imagine outsourcing the heavy lifting of testing your application.

You're a developer.

You realize humans are bad at complex, repetitive tasks.

You also realize that computers are incredibly, great at complex, repetitive tasks.

Professional developers use computers to automate testing of critical paths, behaviors, and all the seemingly insignificant details — again and again, all day and all evening.

That's the means by which professional developers finish things... and gotten along nicely.

Automated tests are the expert move.

Automated tests are your backup, your muscle.

Automated tests are your secret weapon...

Be that as it may, before you can fabricate those tests, you really want to be aware:

What would it be advisable for me to test?

When do I test it?

Do I want 100 percent coverage?

What number of tests are sufficient?

You could scour the web to track down the right alchemy of testing tools and techniques — or you could skirt the analysis paralysis and go right to application success with a demonstrated testing strategy.

A four-layer proven method for testing software

The Testing Prize is a bottom-to-top professional technique for testing web applications. It's about composing barely an adequate number of tests — the right tests. There's no need to focus on reaching for 100 percent coverage.

By utilizing this demonstrated testing strategy, you'll layer these techniques:

1. Utilize a static type system and a linter to capture basic mistakes like errors and syntax.
2. Write effective unit tests that target the critical behavior and functionality of your application.
3. Develop integration tests to audit your application holistically and make sure everything cooperates correctly as one.
4. Create end-to-end (e2e) functional tests for automated click-testing of critical paths instead of depending on your clients to do it for you.

These four layers of automated testing give you the playbook to transport professional JavaScript applications with confidence, speed, and cash savings. Without fail.

 

One professional strategy for testing each JavaScript application

This course will apply the four-layer testing technique to a React application, yet this foundational strategy can be applied across any JavaScript framework: Angular, Vue, legacy Backbone apps, even frameworks and libraries we haven't met at this point.

Following this course, you'll be prepared to:

convey strong features that work for clients as expected

choose the most ideal tools to make it happen

communicate all the more effectively with your coworkers

be a more confident, professional JavaScript developer

Learn the professional strategy for JavaScript testing and always transport top notch software like the professional you are.

 

What's in Testing JavaScript?

8 modules loaded with thick testing knowledge

See Course

Fundamentals of Testing in JavaScript

• 7 video illustrations
• code
• transcript
• 8m of learning material

Do you have at least some idea what a testing framework does? Do you have any idea what makes a testing framework unique in relation to a testing or assertion library? The most ideal way to utilize a tool effectively is to understand the way that it works. And the most effective way to understand how a tool functions is by making it yourself!

In this short course, we'll learn how testing frameworks and assertion libraries work by building our own, basic adaptation of each.

 

JavaScript Mocking Fundamentals

• 6 video illustrations
• code
• transcript
• 15m of learning material

While running unit tests, you would rather not actually make network demands or charge real credit cards. That could… wind up being pricey… and also extremely, slow. So instead of running your code exactly as it would run in production, you can change how a portion of your JavaScript modules and functions work during tests to avoid test unreliability (flakiness) and work on the speed of your tests. This sort of modification can come as stubs, mocks, or generally: "test duplicates."

There are a few great libraries and abstractions for mocking your JavaScript modules during tests. The Jest testing framework has great mocking capabilities worked in for functions as well as whole modules. To really understand how things are working however, how about we execute a portion of these features ourselves.

See Course

 

Static Analysis Testing JavaScript Applications

• 15 video illustrations
• code
• transcript
• 43m of learning material

There are a ton of ways your application can break. One of the most common sources of bugs is related to errors and incorrect types. Passing a string to a function that expects a number, or falling prey to a common grammatical error in a logical statement are senseless mistakes that ought to never be made, however this happens all the time.

We could write a comprehensive set-up of automated tests for our whole codebase to make certain mistakes like this never happen, however that would probably be too much work and dial development back to merit the advantage. Luckily for us, there are tools like ESLint, TypeScript, Prettier, and more which we can use to satisfy an entire category of testing with a great developer experience.

See Course

 

Use DOM Testing Library to test any JS framework

• 12 video illustrations
• code
• transcript
• 17m of learning material

The individual utilizing your application components shouldn't have to be aware or care what framework(s) you used to write your application. Think about what: Neither should your tests.

This course investigates the dom-testing-library utilizing 11 distinct frameworks, from React to Svelte. You'll get hands-on experience composing tests for any JavaScript framework, giving you the confidence you want to deliver your JavaScript application with your framework of choice.

Review Course

 

Configure Jest for Testing JavaScript Applications

• 24 video examples
• code
• transcript
• 1h 38m of learning material

Jest is a completely featured testing framework with a developer experience that is second to none. It's remarkably straightforward and adaptable at the same time. For straightforward use cases, you frequently don't have to configure anything, install and partake in the underlying coverage and watch mode support.

In a real-world application however, you'll frequently have needs specific to your application, especially while testing program based applications. You'll have to handle Webpack loaders, dynamic imports, and custom module goal which Node.js doesn't uphold.

In this course we'll go over ways you can improve your Jest configuration to make testing real-world JavaScript applications a joy. We'll cover what's already been referenced in addition to Babel support, code coverage, how to make watch mode significantly more accommodating, and how to run test suites with completely various configurations.

See Course

Test React Components with Jest and React Testing Library

• 42 video illustrations
• code
• transcript
• 2h 24m of learning material

To transport your applications with confidence — and of course you do — you really want an excellent set-up of automated tests to make absolutely certain that when changes reach your clients, nothing gets broken. To get this confidence, your tests need to realistically mimic how clients actually utilize your React components. Any other way, tests could pass when the application is broken in reality.

In this course, we'll write a progression of render techniques and run a range of tests to perceive how we can get the confidence we're searching for, without surrendering maintainability or test run-speed.

 

Install, Configure, and Script Cypress for JavaScript Web Applications

• 20 video illustrations
• code
• transcript
• 53m of learning material

Cypress is an incredibly strong web testing tool. It's capable of testing any web application. Its architecture places it a cut above similar end-to-end testing tools. Its developer experience is top tier. And because Cypress runs your tests in the same context as the remainder of your application, you're able to get speed, reliability, and debuggability that are only a long-distant dream with similar tools. The catch? There is no catch. Cypress is exceptional.

In this course, we'll go over how you can install, configure, and script Cypress to test current, real-world JavaScript web applications.

Test Node.js Backends

• 40 video illustrations
• code
• transcript
• 2h 21m of learning material

Backends hold such a great deal our application's business logic that is in many cases used to help numerous clients (web, versatile, and other native platforms). This logic is critical to get right and sending a breaking change to this can be devastating to your company's goals (also the bottom-line). Increasing your "organization confidence" is crucial and automated testing is the most effective way to do that.

As Node.js continues to fill in usage around the world, learning how to test this strategic code such that increases developer velocity as well as confidence becomes increasingly important. In this studio we utilize an Express.js example and focus on the patterns and practices that you really want to learn so you can apply what you learn to test your code written in any Node.js web framework.

You'll learn:

• Testing Pure Functions
• Testing Middleware
• Testing Controllers
• Testing API routes
• Mocking third party dependencies
• Testing authenticated code