Make tests more flexible and fix documentation

- Make optional properties test accept any bio string value
- Add note that reduce() is covered later with for-loop alternative
- Make formatUserCard test flexible for any format with required fields
- Fix incorrect callout (spread/rest was Exercise 3, not "next exercise")
- Clarify tuple type alias is optional
- Make enum tests flexible for order values and status messages

Author: kentcdodds

exercises/01.objects/03.solution.optional-properties/index.test.ts

@@ -50,14 +50,13 @@ await test('User with optional properties should work', () => {
 		'[email protected]',
 		'🚨 bob.email should be "[email protected]" - make sure you set the required email property',
 	)
-	assert.strictEqual(
-		solution.bob.bio,
-		'Software developer and TypeScript enthusiast',
-		'🚨 bob.bio should be "Software developer and TypeScript enthusiast" - optional properties can be included when provided',
+	assert.ok(
+		typeof solution.bob.bio === 'string' && solution.bob.bio.length > 0,
+		'🚨 bob.bio should be a non-empty string - include a bio for bob to demonstrate optional properties',
 	)
-	assert.strictEqual(
-		solution.bob.website,
-		'https://bob.dev',
-		'🚨 bob.website should be "https://bob.dev" - optional properties can be included when provided',
+	assert.ok(
+		typeof solution.bob.website === 'string' &&
+			solution.bob.website.startsWith('http'),
+		'🚨 bob.website should be a valid URL string - include a website for bob to demonstrate optional properties',
 	)
 })

exercises/03.spread-rest/02.problem.rest-parameters/README.mdx

@@ -12,6 +12,22 @@ sum(1, 2) // 3
 sum(1, 2, 3, 4, 5) // 15
 ```
 
+<callout-info>
+	The `.reduce()` method shown above is covered later in Exercise 6. For now,
+	you can use a simple `for` loop instead:
+
+```ts
+function sum(...numbers: Array<number>): number {
+	let total = 0
+	for (const n of numbers) {
+		total += n
+	}
+	return total
+}
+```
+
+</callout-info>
+
 ## Rest vs Spread
 
 The `...` syntax means different things in different contexts:

exercises/04.destructuring/01.solution.object-destructuring/index.test.ts

@@ -70,14 +70,17 @@ await test('bio should have a default value', () => {
 })
 
 await test('formatUserCard should use parameter destructuring', () => {
-	assert.strictEqual(
-		solution.formatUserCard({
-			id: 'test',
-			name: 'Bob',
-			email: '[email protected]',
-			role: 'user',
-		}),
-		'Bob (user) - [email protected]',
-		'🚨 formatUserCard should return formatted string with name, role, and email',
+	const result = solution.formatUserCard({
+		id: 'test',
+		name: 'Bob',
+		email: '[email protected]',
+		role: 'user',
+	})
+	assert.ok(
+		typeof result === 'string' &&
+			result.includes('Bob') &&
+			result.includes('user') &&
+			result.includes('[email protected]'),
+		'🚨 formatUserCard should return a string containing the name, role, and email',
 	)
 })

exercises/04.destructuring/02.problem.array-destructuring/README.mdx

@@ -27,8 +27,8 @@ const [head, ...rest] = [1, 2, 3, 4, 5]
 ```
 
 <callout-info>
-	We will cover the full spread/rest syntax in the next exercise. For now, just
-	use the pattern as shown.
+	The spread/rest syntax was covered in Exercise 3. The `...rest` pattern here
+	collects remaining array elements into a new array.
 </callout-info>
 
 ## Swapping Variables

exercises/05.tuples/01.problem.fixed-length/README.mdx

@@ -5,9 +5,16 @@ of numbers: latitude and longitude.
 
 🐨 Open <InlineFile file="index.ts" /> and:
 
-1. Create a `Coordinate` tuple type `[number, number]`
-2. Create several coordinate values
-3. Write a function that calculates distance between coordinates
+1. Create coordinate values typed as `[number, number]` tuples
+2. Write a `formatCoordinate` function that takes a coordinate tuple
+3. Write a `getDistance` function that calculates distance between two coordinates
+
+💰 You can use inline tuple types like `[number, number]` directly, or create a
+type alias if you prefer:
+
+```ts
+type Coordinate = [number, number]
+```
 
 💰 Tuple syntax:
 

exercises/07.enums/01.solution.string-enums/index.test.ts

@@ -47,42 +47,64 @@ await test('OrderStatus enum should have correct values', () => {
 })
 
 await test('Order object should use OrderStatus enum correctly', () => {
-	assert.strictEqual(
-		solution.order.status,
+	const validStatuses = [
+		solution.OrderStatus.Pending,
+		solution.OrderStatus.Processing,
 		solution.OrderStatus.Shipped,
-		'🚨 order.status should be OrderStatus.Shipped - use the enum value when assigning to the status property',
+		solution.OrderStatus.Delivered,
+	]
+	assert.ok(
+		validStatuses.includes(solution.order.status),
+		'🚨 order.status should be one of the OrderStatus enum values',
 	)
-	assert.strictEqual(
-		solution.order.id,
-		'ORD-001',
-		'🚨 order.id should be "ORD-001"',
+	assert.ok(
+		typeof solution.order.id === 'string' && solution.order.id.length > 0,
+		'🚨 order.id should be a non-empty string',
 	)
-	assert.strictEqual(
-		solution.order.customerName,
-		'Alice Johnson',
-		'🚨 order.customerName should be "Alice Johnson"',
+	assert.ok(
+		typeof solution.order.customerName === 'string' &&
+			solution.order.customerName.length > 0,
+		'🚨 order.customerName should be a non-empty string',
 	)
 })
 
-await test('getStatusMessage should return correct messages', () => {
-	assert.strictEqual(
-		solution.getStatusMessage(solution.OrderStatus.Pending),
-		'Your order is pending confirmation',
-		'🚨 getStatusMessage(OrderStatus.Pending) should return the correct message - use a switch statement to handle each enum case',
+await test('getStatusMessage should return a message for each status', () => {
+	// Each status should return a non-empty string message
+	const pendingMsg = solution.getStatusMessage(solution.OrderStatus.Pending)
+	assert.ok(
+		typeof pendingMsg === 'string' && pendingMsg.length > 0,
+		'🚨 getStatusMessage(OrderStatus.Pending) should return a message string',
 	)
-	assert.strictEqual(
-		solution.getStatusMessage(solution.OrderStatus.Processing),
-		'Your order is being processed',
-		'🚨 getStatusMessage(OrderStatus.Processing) should return the correct message - handle the Processing case in your switch',
+
+	const processingMsg = solution.getStatusMessage(
+		solution.OrderStatus.Processing,
 	)
-	assert.strictEqual(
-		solution.getStatusMessage(solution.OrderStatus.Shipped),
-		'Your order has been shipped!',
-		'🚨 getStatusMessage(OrderStatus.Shipped) should return the correct message - handle the Shipped case in your switch',
+	assert.ok(
+		typeof processingMsg === 'string' && processingMsg.length > 0,
+		'🚨 getStatusMessage(OrderStatus.Processing) should return a message string',
 	)
-	assert.strictEqual(
-		solution.getStatusMessage(solution.OrderStatus.Delivered),
-		'Your order has been delivered',
-		'🚨 getStatusMessage(OrderStatus.Delivered) should return the correct message - handle the Delivered case in your switch',
+
+	const shippedMsg = solution.getStatusMessage(solution.OrderStatus.Shipped)
+	assert.ok(
+		typeof shippedMsg === 'string' && shippedMsg.length > 0,
+		'🚨 getStatusMessage(OrderStatus.Shipped) should return a message string',
+	)
+
+	const deliveredMsg = solution.getStatusMessage(solution.OrderStatus.Delivered)
+	assert.ok(
+		typeof deliveredMsg === 'string' && deliveredMsg.length > 0,
+		'🚨 getStatusMessage(OrderStatus.Delivered) should return a message string',
+	)
+
+	// Messages should be different for different statuses
+	const messages = new Set([
+		pendingMsg,
+		processingMsg,
+		shippedMsg,
+		deliveredMsg,
+	])
+	assert.ok(
+		messages.size === 4,
+		'🚨 Each status should return a unique message',
 	)
 })