There is no great test without a great test name. Here are five tips to help you name your test cases in JavaScript.

1. **Start with a verb**: A test is there to check how something works. So, start its name with a verb. This is one of the simplest ways to introduce consistency to your test names.

```javascript
//❌ Tests validate behaviors.
// Behaviors are actions, actions are verbs!
it("homepage");
it("greeting message");

// ✅ Starting with a verb sets the rest
// of the test name on the right path.
it("navigates to the homepage");
it("displays the greeting message");
```

2. **Use subject-less third person**: In other words, imagine there is "it" before the test name. So, it becomes "fetches the user by ID," "displays the greeting message." Not only will the test names read more naturally this way, but it will also improve their consistency and predictability across the entire code base.

```javascript
//🧐 This is a stylistic tip.
it("fetch the user by id");
it("display the greeting message");

// ✅ Following this tip helps you stay
// consistent in your naming and allows
// to disambiguate between nouns and verbs
it("fetches the user by id");
it("displays the greeting message");
```

3. **Omit implied verbs**: Verbs like "tests," "should," "must," "asserts," and "validates" bring no value to the test name because they're implied. Instead, focus on what it is the test is doing. "Navigates to the homepage," "displays the greeting message," "validates the request headers." This way, you can reduce the visual clutter of the test name and help the test focus on what matters – the intention behind the system.

```javascript
// ❌ Omit verbs like "tests", "should",
// "must", "checks", etc. Those are implied.
it("tests the homepage");
it("should display the greeting message");
it("must validate the request headers");

// ✅ Focus on what the system does.
it("navigates to the homepage");
it("displays the greeting message");
it("validates the request headers");
```

4. **Describe the intention, not the implementation**: I know it may be tempting to put a lot of technical details into the test name. It may even seem useful sometimes, but it's not. Those details bring no value to the test name. They only harm the test.

```javascript
// ❌ Implementation details have no place in tests,
// and that includes the test names.
it("performs a GET request to the /user endpoint");

// ✅ Focus on WHAT the system does, not HOW.
it("fetches the user");
```

5. **Keep it short:** Long sentences can be really great to convey a lot of information, to give a lot of detail and context, but it's not what you want from your test name. Neither is it what you want from your test. You really want it to be focused on one particular thing, one behavior.

In fact, if you have a really long test name, perhaps that's an indication that this test does way too much and should be split in multiple smaller tests.

```javascript
// ❌ Watch out for phrases and flavors
// that bring little value to the test name.
it("redirects the user back to the product detail page");

// ✅ Rephrase, remove repetition, and utilize
// domain-specific terms to keep test names short.
// e.g. PDP = product detail page

it("redirects to the PDP");
```


Discover the importance of well-named test cases and learn five tips to help improve your test naming strategy in JavaScript.

How to Write Better Test Names

It's great that there are so many options in web development, but choosing between tools and frameworks can lead to decision fatigue.

Kent C. Dodds addresses this issue by introducing the Epic Stack, an opinionated yet flexible stack designed to streamline the development process.

The Epic Stack aims to strike a balance between flexibility and over-abstraction by minimizing third-party services, minimizing setup friction, and optimizing for offline development. 

It's not just a project starter kit, but also a reference implementation with comprehensive documentation covering the "why and how" of each part of the stack.

Understanding the Epic Stack will equip you with a structured and adaptable approach to making more informed decisions in your development work, wheter you adopt the stack as-is or use it as a reference in creating your own!

Kent C. Dodds introduces the Epic Stack, a starter kit and reference implementation for building web applications.

The Epic Stack

In this talk, Kent C. Dodds discusses how adopting the philosophy of "Don't solve problems, eliminate them!" can lead to better long-term outcomes.

The concept of the Problem Tree is introduced as a way to think through a problem and its potential approaches to finding solutions (and more potential problems along the way).

Through "real life" examples like electric vehicles eliminating emissions to better air quality as well as code-specific examples including the role of React Hooks in evolving how components are built, Kent makes the case for shifting your problem-solving approach.

Kent C. Dodds discusses how adopting the philosophy of "Don't solve problems, eliminate them!" can lead to better long-term outcomes.

In this talk, Kent C. Dodds discusses the topic of problem-solving in both code and "real life" scenarios. Through a continuous cycle of identifying problems and eliminating them, software is able to evolve to become more ergonomic for the developer and give a better user experience.

Don't Solve Problems, Eliminate Them!

There are two ways to make code faster: Either deleting code, or reducing the amount of operations it is doing. But since deleting code isn't the most practical solution, reducing operations by caching is the preferred approach.

In this talk, Kent C. Dodds explores the fundamentals of caching through a series of illustrated examples.

Topics include working cache keys, cache management, rendering strategy tradeoffs, and other best practices.

Caching is a deep area, but after this talk you'll be prepared to dig in further to determine the best course of action for your own applications!

Kent C. Dodds discusses the fundamentals of caching including vocabulary, solid practices, general considerations, and recommendations.

Talks

A Collection of Epic Web Development talks.

How to Write Better Test Names

The Epic Stack

Don't Solve Problems, Eliminate Them!

Caching for Cash