0Pricing
Testing Mastery: JUnit, Mockito & Integration Tests · レッスン

先にテストを書く

プロダクションコードを実装する前に、望ましい振る舞いを定義する失敗するテストを書く練習をします。

「先にテストを書く」はCoddyKit上の無料Testing Mastery: JUnit, Mockito & Integration Testsレッスンです。 これはレッスン2/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはTesting Mastery: JUnit, Mockito & Integration Tests学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Testing Mastery: JUnit, Mockito & Integration Testsコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

TDD's 'Red' Phase

Welcome to the core of Test-Driven Development (TDD)! In this lesson, we'll dive into the crucial first step: writing a failing test first.

This is often called the 'Red' phase of the TDD cycle, because when you run your tests, you expect to see a 'red bar' indicating a failure.

Why Test First?

It might feel counter-intuitive to write a test for code that doesn't exist yet, or isn't fully implemented. But this approach offers great benefits:

  • Clarity: It forces you to think about what the code should *do* before you think about *how* to do it.
  • Proof of Failure: It proves your test works correctly by showing it can fail. If it passes without any code, your test might be faulty!
  • Focus: It gives you a clear, immediate goal: make this one test pass.

Tests as Specifications

Think of your failing test as a precise specification or a mini-requirement. It describes a specific behavior your future code must exhibit.

  • It defines the input.
  • It defines the expected output or outcome.
  • It's concrete and executable.

This helps prevent misunderstandings and ensures your code delivers exactly what's needed for that specific scenario.

Scenario: Simple Calculator

Let's practice by building a simple Calculator class. For our first piece of functionality, we want it to be able to add two numbers.

Our goal is to write a test for an add method that will fail before we even write the correct implementation of add.

Designing the Failing Test

Before writing code, let's think:

  • What input? We'll add 2 and 3.
  • What output? We expect the result to be 5.
  • What method? A method called add on a Calculator object.

We'll write a test that calls calculator.add(2, 3) and asserts that the result is 5.

Code Demo: The Failing Test

Here's a simulated example of writing a test first. Notice the Calculator's add method is intentionally incorrect (it returns 0). This makes our 'test' fail, demonstrating the 'Red' phase.

Run this code to see the simulated failure!

public class Main {
    public static void main(String[] args) {
        System.out.println("Running a simulated test...");
        Calculator calculator = new Calculator();

        // Our test scenario: 2 + 3 should be 5
        int expected = 5;
        int actual = calculator.add(2, 3);

        if (expected == actual) {
            System.out.println("Test PASSED: 2 + 3 = " + actual);
        } else {
            System.out.println("Test FAILED: Expected " + expected + " but got " + actual);
            System.out.println("This is our 'Red' phase!");
        }
    }
}

// The production code (intentionally incorrect for 'Red' phase)
class Calculator {
    public int add(int a, int b) {
        return 0; // Wrong implementation to make the test fail
    }
}

Analyzing the 'Red'

After running the previous code, you saw a 'Test FAILED' message. This is exactly what we wanted!

  • Expected: 5
  • Actual: 0

This failure confirms two things: our test is correctly written, and the production code (the add method) does not yet meet the specified behavior.

The 'Minimum Code' Mindset

Once you have a failing test, the next step in TDD (the 'Green' phase) is to write the *simplest possible code* to make that test pass.

  • Don't over-engineer.
  • Don't add extra features.
  • Just focus on satisfying the current failing test.

This keeps your code clean and focused, building functionality incrementally.

Advantages of Test-First

Embracing the 'Red' phase of TDD leads to:

  • Better Design: Tests guide you towards more modular and testable code.
  • Increased Confidence: Each passing test gives you confidence in your code's correctness.
  • Reduced Bugs: Catch issues early, before they become complex problems.
  • Living Documentation: Your tests serve as up-to-date examples of how your code should be used.

Quick Check on TDD Red

Let's test your understanding of the 'Red' phase in Test-Driven Development.

Recap: The 'Red' Phase

You've explored the crucial first step of TDD: writing a failing test.

  • The 'Red' phase means writing a test that fails.
  • This test acts as a clear specification for new functionality.
  • Seeing the test fail confirms its validity and that the code isn't yet correct.
  • This methodical approach leads to clearer requirements and more robust code.

Next, we'll learn how to make that failing test pass – the 'Green' phase!

よくある質問

「先にテストを書く」レッスンは無料ですか？

はい。「先にテストを書く」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Testing Mastery: JUnit, Mockito & Integration Testsコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Testing Mastery: JUnit, Mockito & Integration Testsコースには全4レッスンが含まれています。

「先にテストを書く」で何を学びますか？

プロダクションコードを実装する前に、望ましい振る舞いを定義する失敗するテストを書く練習をします。 ブラウザで直接実行するハンズオンコードでTesting Mastery: JUnit, Mockito & Integration Testsを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Testing Mastery: JUnit, Mockito & Integration Testsを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのTesting Mastery: JUnit, Mockito & Integration Testsは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン2/4です。

「先にテストを書く」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このTesting Mastery: JUnit, Mockito & Integration Testsレッスンでコードを書いて実行できますか？

はい。すべてのTesting Mastery: JUnit, Mockito & Integration Testsレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. TDDサイクル入門
  2. 先にテストを書く
  3. テスト容易性のためのリファクタリング
  4. TDDの3つの法則
← Testing Mastery: JUnit, Mockito & Integration Testsに戻る