[go: up one dir, main page]

Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Theory

Alternatively : you can watch the slides about the theory

TDD

TDD (Test Driven Development) is cool!

It makes sure we develop the right thing, step by step

Short version

TDD's steps

flowchart TB
    start([Start])
    ==> red([Write only 1 failing test])
    ==> green([Make all tests pass])
    ==> refactor([Refactor])
    ==> finish([Finish])

    refactor -.->|Incomplete ?| red

    classDef red_phase font-weight:bold,color:black,fill:coral;
    class red red_phase

    classDef green_phase font-weight:bold,color:black,fill:#1cba1c;
    class green green_phase

    classDef refactor_phase font-weight:bold,color:black,fill:#668cff;
    class refactor refactor_phase
  1. Write only 1 failing test
  2. Make all tests pass
  3. Refactor
  4. Repeat while it's incomplete
  5. Until finish

Long version

Red step

flowchart TB
    subgraph red[Red]
        direction LR

        fix_layout(( )) ==> write_a_test

        write_a_test[Write only 1 failing test]
        ==> run_tests{{Run tests}}

        run_tests
        -.->|Pass Write another test| write_a_test
    end

    start([Start]) === fix_layout

    run_tests ==>|Fail| green([Green])

    classDef red_phase font-weight:bold,color:black,fill:coral;
    class red red_phase

    classDef green_phase font-weight:bold,color:black,fill:#1cba1c;
    class green green_phase

    classDef refactor_phase font-weight:bold,color:black,fill:#668cff;
    class refactor refactor_phase

    classDef fix_layout stroke:white,fill:transparent;
    class fix_layout fix_layout
  1. Write only 1 failing test
  2. Run tests
  3. If the tests pass then write another test
  4. Else if the tests fail then go to the green step

Green step

flowchart TB
    subgraph green[Green]
        direction LR

        fix_layout(( )) ==> write_the_minimum_code

        write_the_minimum_code[Write the minimum code to make all tests pass]
        ==> run_tests{{Run tests}}

        run_tests
        -.->|Fail Try something else| write_the_minimum_code
    end

    red([Red]) === fix_layout

    run_tests ==>|Pass| refactor([Refactor])

    classDef red_phase font-weight:bold,color:black,fill:coral;
    class red red_phase

    classDef green_phase font-weight:bold,color:black,fill:#1cba1c;
    class green green_phase

    classDef refactor_phase font-weight:bold,color:black,fill:#668cff;
    class refactor refactor_phase

    classDef fix_layout stroke:white,fill:transparent;
    class fix_layout fix_layout
  1. Write the minimum code to make all tests pass
  2. Run tests
  3. If the tests fail then try something else
  4. Else if the tests pass then go to the refactor step

Refactor step

flowchart TB
    subgraph refactor[Refactor]
        direction LR

        rewrite_code[Rewrite code without changing the behavior]
        ==> run_tests{{Run tests}}
        -.->|Pass Another things to refactor ?| rewrite_code

        run_tests
        -->|Fail Change something else| rewrite_code
    end

    green([Green]) ==> rewrite_code

    run_tests ==>|Pass| finish([Finish])
    run_tests -.->|Pass Another feature to add ?| red([Red])

    classDef red_phase font-weight:bold,color:black,fill:coral;
    class red red_phase

    classDef green_phase font-weight:bold,color:black,fill:#1cba1c;
    class green green_phase

    classDef refactor_phase font-weight:bold,color:black,fill:#668cff;
    class refactor refactor_phase

    classDef fix_layout stroke:white,fill:transparent;
    class fix_layout fix_layout
  1. Rewrite code without changing the behavior
  2. Run tests
  3. If the tests fail then change something else and repeat the refactor step
  4. Else if the tests pass and
    1. there is another things to refactor then repeat the refactor step
    2. there is another feature to add then go to the red step
    3. there nothing else to do then it's finished

TCR

TCR (test && commit || revert) is cool!

It encourages doing baby steps, reducing the waste when we are wrong

TCR's single step

flowchart TB
    gamble{{Gambling on test results}}

    gamble ==>|Pass| commit(Commit)

    gamble -->|Fail| revert(Revert)
  1. Gambling on test results
  2. If the tests pass then commit
  3. If the tests fail then revert
flowchart TB
    start([Start])
    ==> green([Change some code])
    ==> finish([Finish])

    green -.->|Incomplete ?| green

    classDef green_phase font-weight:bold,color:black,fill:#1cba1c;
    class green green_phase
  1. Change some code
  2. Repeat while it's incomplete
  3. Until finish

But it doesn't allow us to see the tests failing

So:

  • Maybe we test nothing (assert forgotten)

    def test_should_be_Buzz_given_5():
    input = 5
    actual = fizz_buzz(input)
    # Oops! Assert has been forgotten

  • Maybe we are testing something that is not the thing we should be testing

    it("should be Fizz given 3", () => {
  const input = 3;
  const actual = fizzBuzz(input);
  expect(input).toBe("Fizz");
  // Oops! Asserts on the input value instead of the actual value
});

Detailed view

flowchart TB
    subgraph green[Green]
        direction TB

        start([Start])
        ==> change_code[Change some code]
        ==> run_tests{{"Run tests <code>test && commit || revert</code>"}}
        ==>|Pass| commit(Commit)
        ==> finish([Finish])

        commit
        -->|Another things to change ?| change_code

        run_tests
        -.->|Fail| revert(Revert)
        -.->|Try something else| change_code
    end

    classDef green_phase font-weight:bold,color:black,fill:#1cba1c;
    class green green_phase
  1. Change some code
  2. Run tests
    test && commit || revert
  3. If the tests fail then
    1. Revert
    2. Try something else
    3. Repeat
  4. If the tests pass then
    1. Commit
    2. If there is another things to change then repeat
    3. If there nothing else to do then it's finished

TCRDD

TCRDD = TCR + TDD

TCRDD blends the constraints of the two methods to benefit from their advantages

 Therefore, TCRDD makes sure we develop the right thing, step by step, and we are encouraged to do so by baby steps, reducing the waste when we are wrong

TCRDD's phases

flowchart TB
    red{{Write only 1 failing test}}
    green{{Make all tests pass}}
    refactor{{Refactor}}

    red ~~~ red_commit
    green ~~~ green_commit
    refactor ~~~ refactor_commit

    red ==>|Fail| red_commit(Commit) ==> green
    green ==>|Pass| green_commit(Commit) ==> refactor
    refactor ==>|Pass| refactor_commit(Commit)

    red -->|Pass| red_revert(Revert) --> red
    green -->|Fail| green_revert(Revert) --> green
    refactor -->|Fail| refactor_revert(Revert) --> refactor

    red_revert ~~~ green
    green_revert ~~~ refactor

    classDef red_phase font-weight:bold,color:black,fill:coral;
    class red red_phase

    classDef green_phase font-weight:bold,color:black,fill:#1cba1c;
    class green green_phase

    classDef refactor_phase font-weight:bold,color:black,fill:#668cff;
    class refactor refactor_phase
  1. Red phase
    1. Write only 1 failing test
    2. If the tests pass then
      1. Revert
      2. Retry the red phase
    3. Else if the tests fail then
      1. Commit
      2. Go to the green phase
  2. Green phase
    1. Make all tests pass
    2. If the tests fail then
      1. Revert
      2. Retry the green phase
    3. Else if the tests pass then
      1. Commit
      2. Go to the refactor phase
  3. Refactor phase
    1. Refactor
    2. If the tests fail then
      1. Revert
      2. Retry the refactor phase
    3. Else if the tests pass then
      1. Commit

Red phase

flowchart TB
    subgraph red[Red]
        direction LR

        fix_layout(( )) ==> write_a_test

        write_a_test[Write only 1 test]
        ==> gamble[/Gamble that the test fail <code>git gamble --red</code>/]
        ==> run_tests{{Actually run tests}}
        ==>|Fail| commit(Commit)

        run_tests
        -->|Pass| revert(Revert)
        -->|Write another test| write_a_test
    end

    start([Start]) ==> fix_layout

    commit ==> green([Green])

    classDef red_phase font-weight:bold,color:black,fill:coral;
    class red red_phase

    classDef green_phase font-weight:bold,color:black,fill:#1cba1c;
    class green green_phase

    classDef refactor_phase font-weight:bold,color:black,fill:#668cff;
    class refactor refactor_phase

    classDef fix_layout stroke:white,fill:transparent;
    class fix_layout fix_layout
  1. Write only 1 test
  2. Gamble that the test fail
    git gamble --red
  3. Actually run tests
  4. If the tests pass then
    1. Revert
    2. Write another test
  5. Else if the tests fail then
    1. Commit
    2. Go to the green phase

Green phase

flowchart TB
    subgraph green[Green]
        direction LR

        fix_layout(( )) ==> write_the_minimum_code

        write_the_minimum_code[Write the minimum code]
        ==> gamble[/Gamble that the tests pass <code>git gamble --green</code>/]
        ==> run_tests{{Actually run tests}}
        ==>|Pass| commit(Commit)

        run_tests
        -->|Fail| revert(Revert)
        -->|Try something else| write_the_minimum_code
    end

    red([Red]) ==> fix_layout

    commit ==> refactor([Refactor])

    classDef red_phase font-weight:bold,color:black,fill:coral;
    class red red_phase

    classDef green_phase font-weight:bold,color:black,fill:#1cba1c;
    class green green_phase

    classDef refactor_phase font-weight:bold,color:black,fill:#668cff;
    class refactor refactor_phase

    classDef fix_layout stroke:white,fill:transparent;
    class fix_layout fix_layout
  1. Write the minimum code
  2. Gamble that the tests pass
    git gamble --green
  3. Actually run tests
  4. If the tests fail then
    1. Revert
    2. Try something else
  5. Else if the tests pass then
    1. Commit
    2. Go to the refactor phase

Refactor phase

flowchart TB
    subgraph refactor[Refactor]
        direction LR

        rewrite_code[Rewrite code without changing the behavior]
        ==> gamble[/Gamble that the tests pass <code>git gamble --refactor</code>/]
        ==> run_tests{{Actually run tests}}
        ==>|Pass| commit(Commit)
        -.->|Another things to refactor ?| rewrite_code

        run_tests
        -->|Fail| revert(Revert)
        -->|Change something else| rewrite_code
    end

    green([Green]) ==> rewrite_code

    commit ==> finish([Finish])
    commit -.->|Another feature to add ?| red([Red])

    classDef red_phase font-weight:bold,color:black,fill:coral;
    class red red_phase

    classDef green_phase font-weight:bold,color:black,fill:#1cba1c;
    class green green_phase

    classDef refactor_phase font-weight:bold,color:black,fill:#668cff;
    class refactor refactor_phase

    classDef fix_layout stroke:white,fill:transparent;
    class fix_layout fix_layout
  1. Rewrite code without changing the behavior
  2. Gamble that the tests pass
    git gamble --refactor
  3. Actually run tests
  4. If the tests fail then
    1. Revert
    2. Change something else
  5. Else if the tests pass then
    1. Commit
    2. If there is another things to refactor then go to the refactor phase
    3. Else if there is another feature to add then go to the red phase
    4. Else if there nothing else to do then it's finished

git-gamble is a tool that helps to use the TCRDD method