Add helpful 🚨 error messages to test assertions

Each expect() now includes a message that guides learners when tests fail,
helping them understand what might be wrong without giving away the answer.

Author: kentcdodds

exercises/01.classes/01.solution.class-basics/index.test.ts

@@ -3,20 +3,20 @@ import { Product, ShoppingCart } from './index.ts'
 
 await testStep('Product class should create instances with name and price', async () => {
 	const laptop = new Product('Laptop', 999.99)
-	expect(laptop.name).toBe('Laptop')
-	expect(laptop.price).toBe(999.99)
+	expect(laptop.name, '🚨 Product.name should be "Laptop" - check your class property definition').toBe('Laptop')
+	expect(laptop.price, '🚨 Product.price should be 999.99 - check your class property definition').toBe(999.99)
 })
 
 await testStep('Product getDescription should return formatted string', async () => {
 	const mouse = new Product('Mouse', 29.99)
 	const description = mouse.getDescription()
-	expect(description).toBe('Product: Mouse - $29.99')
+	expect(description, '🚨 getDescription() should return "Product: Mouse - $29.99" - check your method implementation and formatting').toBe('Product: Mouse - $29.99')
 })
 
 await testStep('ShoppingCart should initialize with empty items array', async () => {
 	const cart = new ShoppingCart()
-	expect(cart.items).toEqual([])
-	expect(cart.items.length).toBe(0)
+	expect(cart.items, '🚨 ShoppingCart.items should be an empty array - check your class property initialization').toEqual([])
+	expect(cart.items.length, '🚨 ShoppingCart.items.length should be 0 - check your class property initialization').toBe(0)
 })
 
 await testStep('ShoppingCart addItem should add products to cart', async () => {
@@ -25,12 +25,12 @@ await testStep('ShoppingCart addItem should add products to cart', async () => {
 	const mouse = new Product('Mouse', 29.99)
 
 	cart.addItem(laptop)
-	expect(cart.items.length).toBe(1)
-	expect(cart.items[0]).toBe(laptop)
+	expect(cart.items.length, '🚨 After adding one item, items.length should be 1 - check your addItem method implementation').toBe(1)
+	expect(cart.items[0], '🚨 items[0] should be the laptop product - check your addItem method implementation').toBe(laptop)
 
 	cart.addItem(mouse)
-	expect(cart.items.length).toBe(2)
-	expect(cart.items[1]).toBe(mouse)
+	expect(cart.items.length, '🚨 After adding two items, items.length should be 2 - check your addItem method implementation').toBe(2)
+	expect(cart.items[1], '🚨 items[1] should be the mouse product - check your addItem method implementation').toBe(mouse)
 })
 
 await testStep('ShoppingCart getTotal should calculate sum of all item prices', async () => {
@@ -42,5 +42,5 @@ await testStep('ShoppingCart getTotal should calculate sum of all item prices',
 	cart.addItem(mouse)
 
 	const total = cart.getTotal()
-	expect(total).toBe(1029.98)
+	expect(total, '🚨 getTotal() should return 1029.98 (sum of 999.99 + 29.99) - check your method implementation and price calculation').toBe(1029.98)
 })

exercises/01.classes/02.solution.constructors/index.test.ts

@@ -3,42 +3,42 @@ import { User, BankAccount, Config } from './index.ts'
 
 await testStep('User constructor should set name, email, and default role', async () => {
 	const user = new User('Alice', '[email protected]')
-	expect(user.name).toBe('Alice')
-	expect(user.email).toBe('[email protected]')
-	expect(user.role).toBe('user')
+	expect(user.name, '🚨 User.name should be "Alice" - check your constructor parameter assignment').toBe('Alice')
+	expect(user.email, '🚨 User.email should be "[email protected]" - check your constructor parameter assignment').toBe('[email protected]')
+	expect(user.role, '🚨 User.role should default to "user" - check your constructor default parameter value').toBe('user')
 })
 
 await testStep('User constructor should accept custom role', async () => {
 	const admin = new User('Bob', '[email protected]', 'admin')
-	expect(admin.name).toBe('Bob')
-	expect(admin.email).toBe('[email protected]')
-	expect(admin.role).toBe('admin')
+	expect(admin.name, '🚨 User.name should be "Bob" - check your constructor parameter assignment').toBe('Bob')
+	expect(admin.email, '🚨 User.email should be "[email protected]" - check your constructor parameter assignment').toBe('[email protected]')
+	expect(admin.role, '🚨 User.role should be "admin" when provided as third parameter - check your constructor parameter handling').toBe('admin')
 })
 
 await testStep('BankAccount constructor should set accountNumber and default balance', async () => {
 	const account = new BankAccount('12345')
-	expect(account.accountNumber).toBe('12345')
-	expect(account.getBalance()).toBe(0)
+	expect(account.accountNumber, '🚨 BankAccount.accountNumber should be "12345" - check your constructor parameter assignment').toBe('12345')
+	expect(account.getBalance(), '🚨 BankAccount.getBalance() should return 0 initially - check your constructor initialization').toBe(0)
 })
 
 await testStep('BankAccount deposit should increase balance', async () => {
 	const account = new BankAccount('12345')
 	account.deposit(100)
-	expect(account.getBalance()).toBe(100)
+	expect(account.getBalance(), '🚨 After depositing 100, getBalance() should return 100 - check your deposit method implementation').toBe(100)
 	account.deposit(50)
-	expect(account.getBalance()).toBe(150)
+	expect(account.getBalance(), '🚨 After depositing another 50, getBalance() should return 150 - check your deposit method accumulates correctly').toBe(150)
 })
 
 await testStep('Config constructor should use default values', async () => {
 	const config = new Config()
-	expect(config.host).toBe('localhost')
-	expect(config.port).toBe(3000)
-	expect(config.debug).toBe(false)
+	expect(config.host, '🚨 Config.host should default to "localhost" - check your constructor default parameter values').toBe('localhost')
+	expect(config.port, '🚨 Config.port should default to 3000 - check your constructor default parameter values').toBe(3000)
+	expect(config.debug, '🚨 Config.debug should default to false - check your constructor default parameter values').toBe(false)
 })
 
 await testStep('Config constructor should accept custom values', async () => {
 	const customConfig = new Config('example.com', 8080, true)
-	expect(customConfig.host).toBe('example.com')
-	expect(customConfig.port).toBe(8080)
-	expect(customConfig.debug).toBe(true)
+	expect(customConfig.host, '🚨 Config.host should be "example.com" when provided - check your constructor parameter assignment').toBe('example.com')
+	expect(customConfig.port, '🚨 Config.port should be 8080 when provided - check your constructor parameter assignment').toBe(8080)
+	expect(customConfig.debug, '🚨 Config.debug should be true when provided - check your constructor parameter assignment').toBe(true)
 })

exercises/02.access-modifiers/01.solution.public-private/index.test.ts

@@ -3,17 +3,17 @@ import { User } from './index.ts'
 
 await testStep('User should have public username property', async () => {
 	const user = new User('alice', 'secret123')
-	expect(user.username).toBe('alice')
+	expect(user.username, '🚨 User.username should be "alice" - check your public property definition').toBe('alice')
 })
 
 await testStep('User login should return true for correct password', async () => {
 	const user = new User('alice', 'secret123')
 	const result = user.login('secret123')
-	expect(result).toBe(true)
+	expect(result, '🚨 login() should return true for correct password - check your login method implementation and password comparison').toBe(true)
 })
 
 await testStep('User login should return false for incorrect password', async () => {
 	const user = new User('alice', 'secret123')
 	const result = user.login('wrong')
-	expect(result).toBe(false)
+	expect(result, '🚨 login() should return false for incorrect password - check your login method implementation and password comparison').toBe(false)
 })

exercises/02.access-modifiers/02.solution.protected/index.test.ts

@@ -4,10 +4,10 @@ import { Car } from './index.ts'
 await testStep('Car should inherit from Vehicle and access protected fields', async () => {
 	const car = new Car('Toyota', 'Camry')
 	const info = car.getInfo()
-	expect(info).toBe('Toyota Camry')
+	expect(info, '🚨 getInfo() should return "Toyota Camry" - check that Car extends Vehicle and accesses protected properties').toBe('Toyota Camry')
 })
 
 await testStep('Car should be instance of Vehicle', async () => {
 	const car = new Car('Honda', 'Civic')
-	expect(car instanceof Car).toBe(true)
+	expect(car instanceof Car, '🚨 car should be an instance of Car - check your class definition').toBe(true)
 })

exercises/03.interfaces-and-classes/01.solution.implementing-interfaces/index.test.ts

@@ -3,22 +3,22 @@ import { CreditCard, PayPal } from './index.ts'
 
 await testStep('CreditCard should implement PaymentMethod interface', async () => {
 	const creditCard = new CreditCard('1234-5678-9012-3456')
-	expect(creditCard.cardNumber).toBe('1234-5678-9012-3456')
+	expect(creditCard.cardNumber, '🚨 CreditCard.cardNumber should be "1234-5678-9012-3456" - check your class property definition').toBe('1234-5678-9012-3456')
 	const result = creditCard.pay(100)
-	expect(result).toBe('Paid $100 with credit card 1234-5678-9012-3456')
+	expect(result, '🚨 pay() should return "Paid $100 with credit card 1234-5678-9012-3456" - check your PaymentMethod interface implementation').toBe('Paid $100 with credit card 1234-5678-9012-3456')
 })
 
 await testStep('PayPal should implement PaymentMethod interface', async () => {
 	const paypal = new PayPal('[email protected]')
-	expect(paypal.email).toBe('[email protected]')
+	expect(paypal.email, '🚨 PayPal.email should be "[email protected]" - check your class property definition').toBe('[email protected]')
 	const result = paypal.pay(50)
-	expect(result).toBe('Paid $50 with PayPal [email protected]')
+	expect(result, '🚨 pay() should return "Paid $50 with PayPal [email protected]" - check your PaymentMethod interface implementation').toBe('Paid $50 with PayPal [email protected]')
 })
 
 await testStep('Both payment methods should have pay method', async () => {
 	const creditCard = new CreditCard('1234-5678-9012-3456')
 	const paypal = new PayPal('[email protected]')
 
-	expect(typeof creditCard.pay).toBe('function')
-	expect(typeof paypal.pay).toBe('function')
+	expect(typeof creditCard.pay, '🚨 CreditCard.pay should be a function - check that you implemented the PaymentMethod interface').toBe('function')
+	expect(typeof paypal.pay, '🚨 PayPal.pay should be a function - check that you implemented the PaymentMethod interface').toBe('function')
 })

exercises/03.interfaces-and-classes/02.solution.programming-to-abstractions/index.test.ts

@@ -4,13 +4,13 @@ import { CreditCard, PayPal, processPayment } from './index.ts'
 await testStep('processPayment should work with CreditCard', async () => {
 	const creditCard = new CreditCard('1234-5678-9012-3456')
 	const result = processPayment(creditCard, 100)
-	expect(result).toBe('Paid $100 with credit card 1234-5678-9012-3456')
+	expect(result, '🚨 processPayment() should return "Paid $100 with credit card 1234-5678-9012-3456" - check your function accepts PaymentMethod type').toBe('Paid $100 with credit card 1234-5678-9012-3456')
 })
 
 await testStep('processPayment should work with PayPal', async () => {
 	const paypal = new PayPal('[email protected]')
 	const result = processPayment(paypal, 50)
-	expect(result).toBe('Paid $50 with PayPal [email protected]')
+	expect(result, '🚨 processPayment() should return "Paid $50 with PayPal [email protected]" - check your function accepts PaymentMethod type').toBe('Paid $50 with PayPal [email protected]')
 })
 
 await testStep('processPayment should accept any PaymentMethod implementation', async () => {
@@ -20,6 +20,6 @@ await testStep('processPayment should accept any PaymentMethod implementation',
 	const result1 = processPayment(creditCard, 75)
 	const result2 = processPayment(paypal, 25)
 
-	expect(result1).toContain('credit card')
-	expect(result2).toContain('PayPal')
+	expect(result1, '🚨 CreditCard payment result should contain "credit card" - check your processPayment function accepts PaymentMethod interface').toContain('credit card')
+	expect(result2, '🚨 PayPal payment result should contain "PayPal" - check your processPayment function accepts PaymentMethod interface').toContain('PayPal')
 })

exercises/04.inheritance/01.solution.extends/index.test.ts

@@ -3,25 +3,25 @@ import { Circle, Rectangle, Shape } from './index.ts'
 
 await testStep('Circle should inherit color from Shape', async () => {
 	const circle = new Circle('red', 5)
-	expect(circle.color).toBe('red')
-	expect(circle.radius).toBe(5)
+	expect(circle.color, '🚨 Circle.color should be "red" - check that Circle extends Shape and inherits the color property').toBe('red')
+	expect(circle.radius, '🚨 Circle.radius should be 5 - check your Circle constructor parameter assignment').toBe(5)
 })
 
 await testStep('Rectangle should inherit color from Shape', async () => {
 	const rectangle = new Rectangle('blue', 10, 20)
-	expect(rectangle.color).toBe('blue')
-	expect(rectangle.width).toBe(10)
-	expect(rectangle.height).toBe(20)
+	expect(rectangle.color, '🚨 Rectangle.color should be "blue" - check that Rectangle extends Shape and inherits the color property').toBe('blue')
+	expect(rectangle.width, '🚨 Rectangle.width should be 10 - check your Rectangle constructor parameter assignment').toBe(10)
+	expect(rectangle.height, '🚨 Rectangle.height should be 20 - check your Rectangle constructor parameter assignment').toBe(20)
 })
 
 await testStep('Circle should be instance of Shape', async () => {
 	const circle = new Circle('green', 3)
-	expect(circle instanceof Circle).toBe(true)
-	expect(circle instanceof Shape).toBe(true)
+	expect(circle instanceof Circle, '🚨 circle should be an instance of Circle - check your class definition').toBe(true)
+	expect(circle instanceof Shape, '🚨 circle should be an instance of Shape - check that Circle extends Shape').toBe(true)
 })
 
 await testStep('Rectangle should be instance of Shape', async () => {
 	const rectangle = new Rectangle('yellow', 5, 5)
-	expect(rectangle instanceof Rectangle).toBe(true)
-	expect(rectangle instanceof Shape).toBe(true)
+	expect(rectangle instanceof Rectangle, '🚨 rectangle should be an instance of Rectangle - check your class definition').toBe(true)
+	expect(rectangle instanceof Shape, '🚨 rectangle should be an instance of Shape - check that Rectangle extends Shape').toBe(true)
 })

exercises/04.inheritance/02.solution.method-overriding/index.test.ts

@@ -3,20 +3,20 @@ import { Circle, Rectangle, Shape } from './index.ts'
 
 await testStep('Shape getArea should return 0', async () => {
 	const shape = new Shape('red')
-	expect(shape.getArea()).toBe(0)
+	expect(shape.getArea(), '🚨 Shape.getArea() should return 0 - check your base class method implementation').toBe(0)
 })
 
 await testStep('Circle should override getArea to calculate circle area', async () => {
 	const circle = new Circle('red', 5)
 	const area = circle.getArea()
-	expect(area).toBeCloseTo(Math.PI * 25, 2)
-	expect(area).toBeCloseTo(78.54, 2)
+	expect(area, '🚨 Circle.getArea() should be approximately Math.PI * 25 - check that you override getArea() with the circle area formula').toBeCloseTo(Math.PI * 25, 2)
+	expect(area, '🚨 Circle.getArea() should be approximately 78.54 - check your circle area calculation (π * radius²)').toBeCloseTo(78.54, 2)
 })
 
 await testStep('Rectangle should override getArea to calculate rectangle area', async () => {
 	const rectangle = new Rectangle('blue', 10, 20)
 	const area = rectangle.getArea()
-	expect(area).toBe(200)
+	expect(area, '🚨 Rectangle.getArea() should return 200 (10 * 20) - check that you override getArea() with the rectangle area formula').toBe(200)
 })
 
 await testStep('Different shapes should have different area calculations', async () => {
@@ -26,7 +26,7 @@ await testStep('Different shapes should have different area calculations', async
 	const circleArea = circle.getArea()
 	const rectangleArea = rectangle.getArea()
 
-	expect(circleArea).toBeGreaterThan(0)
-	expect(rectangleArea).toBeGreaterThan(0)
-	expect(circleArea).not.toBe(rectangleArea)
+	expect(circleArea, '🚨 Circle area should be greater than 0 - check your getArea() override implementation').toBeGreaterThan(0)
+	expect(rectangleArea, '🚨 Rectangle area should be greater than 0 - check your getArea() override implementation').toBeGreaterThan(0)
+	expect(circleArea, '🚨 Circle and Rectangle areas should be different - check that each class overrides getArea() with its own calculation').not.toBe(rectangleArea)
 })

exercises/05.polymorphism/01.solution.substitutability/index.test.ts

@@ -5,21 +5,21 @@ await testStep('MediaPlayer should accept MediaFile instances', async () => {
 	const mediaFile = new MediaFile('file.mp3')
 	const player = new MediaPlayer()
 	const result = player.playFile(mediaFile)
-	expect(result).toBe('Playing file.mp3')
+	expect(result, '🚨 playFile() should return "Playing file.mp3" - check your MediaPlayer.playFile method accepts MediaFile type').toBe('Playing file.mp3')
 })
 
 await testStep('MediaPlayer should accept AudioFile instances (polymorphism)', async () => {
 	const audio = new AudioFile('song.mp3')
 	const player = new MediaPlayer()
 	const result = player.playFile(audio)
-	expect(result).toBe('Playing audio: song.mp3')
+	expect(result, '🚨 playFile() should return "Playing audio: song.mp3" - check that AudioFile extends MediaFile and playFile accepts the base type').toBe('Playing audio: song.mp3')
 })
 
 await testStep('MediaPlayer should accept VideoFile instances (polymorphism)', async () => {
 	const video = new VideoFile('movie.mp4')
 	const player = new MediaPlayer()
 	const result = player.playFile(video)
-	expect(result).toBe('Playing video: movie.mp4')
+	expect(result, '🚨 playFile() should return "Playing video: movie.mp4" - check that VideoFile extends MediaFile and playFile accepts the base type').toBe('Playing video: movie.mp4')
 })
 
 await testStep('AudioFile and VideoFile should be substitutable for MediaFile', async () => {
@@ -30,8 +30,8 @@ await testStep('AudioFile and VideoFile should be substitutable for MediaFile',
 	const audioResult = player.playFile(audio)
 	const videoResult = player.playFile(video)
 
-	expect(audioResult).toContain('audio')
-	expect(videoResult).toContain('video')
-	expect(audio instanceof MediaFile).toBe(true)
-	expect(video instanceof MediaFile).toBe(true)
+	expect(audioResult, '🚨 AudioFile result should contain "audio" - check that AudioFile extends MediaFile and overrides playFile behavior').toContain('audio')
+	expect(videoResult, '🚨 VideoFile result should contain "video" - check that VideoFile extends MediaFile and overrides playFile behavior').toContain('video')
+	expect(audio instanceof MediaFile, '🚨 AudioFile should be an instance of MediaFile - check that AudioFile extends MediaFile').toBe(true)
+	expect(video instanceof MediaFile, '🚨 VideoFile should be an instance of MediaFile - check that VideoFile extends MediaFile').toBe(true)
 })