The Bike Shed

438: Writing abstractions in tests

Sep 3, 2024

Stepha, a skilled tech storyteller, dives into the intriguing parallels between writing abstractions in tests and crafting compelling narratives. She and Joël discuss the delicate balance needed in both fields to avoid overwhelming the audience or leaving them bewildered. They explore motivations for using abstractions, from enhancing readability to simplifying test purposes. The conversation also covers the impact of custom matchers and shared examples in tests, highlighting the trade-offs that come with each approach for clearer, more effective testing.

49:08

Creator website

Episode guests

Stepha

AI Summary

AI Chapters

Episode notes

Podcast summary created with Snipd AI

Quick takeaways

Effective testing abstractions can enhance readability and maintainability, but must be balanced to avoid excessive complexity and confusion.

Understanding user error states is crucial for improving user experience, guiding users back to productive paths after encountering issues.

Deep dives

Collaborative UI Design Process

Designing user interfaces benefits from a collaborative approach between developers and designers. The conversation highlights the importance of mapping out user flows and error states during the design phase using tools like Figma. By visualizing not just the ideal pathway but all potential error conditions, the team can create a finite state machine diagram that serves as a comprehensive model for UI states. This collaboration fosters a deeper understanding of user experiences and leads to the identification of critical transitions back through the user journey.

Intro

2min

Navigating UI Complexity in Searchable Dropdowns

2min

Collaborative Design for Improved User Experience

2min

Exploring Design Perspectives and a New Reading Tool

3min

Enhancing the Reading Experience with Interactive Highlighting

2min

Efficient Test Writing Strategies

5min

Navigating Abstractions in Test Code

14min

Elevating Testing with RSpec Matchers

21min

Writing abstractions in tests can be surprisingly similar to storytelling. The most masterful stories are those where the author has stripped away all of the extra information, and given you just enough knowledge to be immersed and aware of what is going on. But striking that balance can be tricky, both in storytelling and abstractions in tests. Too much information and you risk overwhelming the reader. Too little and they won’t understand why things are operating the way they are. Today, Stephanie and Joël get into some of the more controversial practices around testing, why people use them, and how to strike the right balance with your information. They discuss the most common motivations for introducing abstractions, from improved readability to simplifying the test’s purpose and the types of tests where they are most likely to introduce abstractions. Our hosts also reflect on how they feel about different abstractions in tests – like custom matchers and shared examples – outlining when they reach for them, and the tradeoffs and benefits that come with each. To learn more about how to find the perfect level of abstraction, be sure to tune in!

Key Points From This Episode:

What’s new in Joël’s world; mocking out screens for processes or a new bit of UI.
The new tool Stephanie’s using for reading on the web: Reader by Readwise.
Today’s topic: controversial practices around testing.
How Stephanie and Joël feel about looping through arrays and having IT blocks for each.
The most common motivations for introducing abstractions or helper methods into your tests.
Pros and cons of factories as abstractions in testing.
Types of tests where Joël and Stephanie are more likely to introduce abstractions.
Using page objects in system tests to improve user experience.
Finding the balance between too little and too much information with abstraction in testing.
Why Stephanie has been enjoying fancier matchers like RSpecs.
Top uses of custom matchers, especially for specialized error messaging.
Why Stephanie prefers custom matchers over shared examples.
Using helper methods as a lighter version of abstraction.
Differences and similarities between abstractions in tests versus application code.
A reminder to keep your goals in mind when using abstraction.

Links Mentioned in Today’s Episode: