Test-driven development workflow in Ruby - Step-by-Step Execution

Concept Flow - Test-driven development workflow

Write a failing test

↓

Run the test suite

↓

Test fails as expected

↓

Write code to pass test

↓

Run the test suite again

↓

Test passes

↓

Refactor code if needed

↓

Repeat cycle for next feature

This flow shows the cycle of writing a test first, running it to see it fail, then writing code to pass the test, running tests again to confirm success, and finally refactoring.

Execution Sample

Ruby

require 'minitest/autorun'

def add(a, b)
  a + b
end

class TestAdd < Minitest::Test
  def test_addition
    assert_equal 5, add(2, 3)
  end
end

This Ruby code defines a simple add method and a test that checks if add(2, 3) returns 5.

Execution Table

Step	Action	Evaluation	Result
1	Write test 'test_addition' expecting add(2,3) == 5	No code yet	Test will fail if run
2	Run tests	TestAdd#test_addition runs	Fails (method add not defined or incorrect)
3	Write method add(a,b) returning a + b	Method defined	Ready to pass test
4	Run tests again	TestAdd#test_addition runs	Passes (5 == 5)
5	Refactor code if needed	No change in behavior	Tests still pass
6	Cycle repeats for next feature	New test written	Process repeats

💡 Tests pass and code is clean, cycle repeats for new features

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
add method	undefined	defined as a + b	same	same

Key Moments - 3 Insights

Why do we write the test before the code?

Writing the test first ensures we know exactly what the code should do. As shown in execution_table step 1 and 2, the test fails initially, guiding us to write just enough code to pass it.

What does it mean when the test fails at first?

The failure confirms the test is valid and the feature is not yet implemented. This is shown in execution_table step 2 where the test fails before the method is defined.

Why do we run tests again after writing code?

Running tests again (step 4) confirms the new code meets the test requirements and works correctly before moving on.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what is the test result?

A Test passes successfully

B Test fails because code is missing or incorrect

C Test is skipped

D Test crashes the program

💡 Hint

See execution_table row with Step 2 showing test failure due to missing or incorrect code

At which step does the test pass?

A Step 1

B Step 3

C Step 4

D Step 6

💡 Hint

Check execution_table row Step 4 where tests run and pass after code is written

If we skip writing the test first, how would the execution_table change?

A Step 1 would be missing and tests might pass or fail unpredictably

B Step 2 would show test failure as usual

C Step 3 would be writing the test instead of code

D Step 5 would be refactoring before writing code

💡 Hint

Look at the flow: test first guides the process; skipping it removes step 1

Concept Snapshot

Test-driven development (TDD) workflow:
1. Write a failing test for new feature.
2. Run tests to confirm failure.
3. Write minimal code to pass test.
4. Run tests to confirm success.
5. Refactor code while tests pass.
6. Repeat cycle for next feature.

Full Transcript

Test-driven development is a cycle where you first write a test that fails because the feature is not implemented. Then you write just enough code to pass that test. After that, you run the tests again to confirm the code works. Finally, you can clean up the code without changing its behavior. This cycle repeats for every new feature or fix. The example Ruby code shows a test for an add method that initially fails, then passes after the method is defined. This approach helps ensure your code does exactly what you want and makes it easier to catch mistakes early.