Testing Mastery: JUnit, Mockito & Integration Tests · 课时

实现步骤定义

通过使用 BDD 框架编写步骤定义，将 Gherkin 功能文件连接到可执行代码。

实现步骤定义 是 CoddyKit 上的免费 Testing Mastery: JUnit, Mockito & Integration Tests 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Testing Mastery: JUnit, Mockito & Integration Tests 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Testing Mastery: JUnit, Mockito & Integration Tests 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Step Definitions: The Code Bridge

In Behavior-Driven Development (BDD), Gherkin feature files describe behavior in plain language. But how does your application understand these instructions?

This is where Step Definitions come in! They are the crucial link, translating each Gherkin step (Given, When, Then) into executable code.

They are methods that match Gherkin patterns.
BDD frameworks (like Cucumber) find and run these methods.

Our Example: A Simple Calculator

Let's use a basic Calculator to demonstrate how step definitions work. This class will hold the state and logic that our steps will interact with.

Try running this simple calculator:

public class Calculator {
  private int result;

  public void add(int a, int b) {
    this.result = a + b;
  }

  public int getResult() {
    return result;
  }

  public void clear() {
    this.result = 0;
  }

  public static void main(String[] args) {
    Calculator calc = new Calculator();
    calc.add(10, 5);
    System.out.println("10 + 5 = " + calc.getResult());
  }
}

The @Given Annotation

The @Given annotation is used for methods that establish the initial context or preconditions for a scenario. It sets up the 'world' before an action takes place.

We'll create a StepDefinitions class to house our step methods. Notice how the string in @Given matches a Gherkin step.

import io.cucumber.java.en.Given;

public class StepDefinitions {
  private Calculator calculator;

  @Given("I have a calculator")
  public void iHaveACalculator() {
    calculator = new Calculator();
    System.out.println("Given: Calculator initialized.");
  }

  public static void main(String[] args) {
    StepDefinitions steps = new StepDefinitions();
    steps.iHaveACalculator();
  }
}

The @When Annotation

The @When annotation marks methods that describe an action or event. This is typically where the system under test is interacted with or triggered.

Our calculator will perform an 'add' operation here.

import io.cucumber.java.en.Given;
import io.cucumber.java.en.When;

public class StepDefinitions {
  private Calculator calculator;

  @Given("I have a calculator")
  public void iHaveACalculator() {
    calculator = new Calculator();
    System.out.println("Given: Calculator initialized.");
  }

  @When("I add two numbers")
  public void iAddTwoNumbers() {
    // For now, let's hardcode values. We'll make it dynamic soon!
    calculator.add(10, 20);
    System.out.println("When: Added two numbers (10, 20).");
  }

  public static void main(String[] args) {
    StepDefinitions steps = new StepDefinitions();
    steps.iHaveACalculator();
    steps.iAddTwoNumbers();
  }
}

The @Then Annotation

The @Then annotation is for methods that observe the outcome of the action. This is where you assert that the system behaved as expected.

We'll check if the calculator's result is correct.

import io.cucumber.java.en.Given;
import io.cucumber.java.en.When;
import io.cucumber.java.en.Then;

public class StepDefinitions {
  private Calculator calculator;

  @Given("I have a calculator")
  public void iHaveACalculator() {
    calculator = new Calculator();
    System.out.println("Given: Calculator initialized.");
  }

  @When("I add two numbers")
  public void iAddTwoNumbers() {
    calculator.add(10, 20);
    System.out.println("When: Added two numbers (10, 20).");
  }

  @Then("the result should be 30")
  public void theResultShouldBe30() {
    if (calculator.getResult() == 30) {
      System.out.println("Then: Result is 30. Test PASSED!");
    } else {
      System.out.println("Then: Expected 30, got " + calculator.getResult() + ". Test FAILED!");
    }
  }

  public static void main(String[] args) {
    StepDefinitions steps = new StepDefinitions();
    steps.iHaveACalculator();
    steps.iAddTwoNumbers();
    steps.theResultShouldBe30();
  }
}

Passing Data with Arguments

Hardcoding values isn't flexible. BDD frameworks allow you to capture data from the Gherkin step and pass it as arguments to your step definition method.

We use regular expressions or Cucumber Expressions (like {int}) to define placeholders.

import io.cucumber.java.en.Given;
import io.cucumber.java.en.When;
import io.cucumber.java.en.Then;

public class StepDefinitions {
  private Calculator calculator;

  @Given("I have a calculator")
  public void iHaveACalculator() {
    calculator = new Calculator();
    System.out.println("Given: Calculator initialized.");
  }

  @When("I add {int} and {int}")
  public void iAddTwoNumbers(int num1, int num2) {
    calculator.add(num1, num2);
    System.out.println("When: Added " + num1 + " and " + num2 + ".");
  }

  @Then("the result should be {int}")
  public void theResultShouldBe(int expectedResult) {
    if (calculator.getResult() == expectedResult) {
      System.out.println("Then: Result is " + expectedResult + ". Test PASSED!");
    } else {
      System.out.println("Then: Expected " + expectedResult + ", got " + calculator.getResult() + ". Test FAILED!");
    }
  }

  public static void main(String[] args) {
    StepDefinitions steps = new StepDefinitions();
    steps.iHaveACalculator();
    steps.iAddTwoNumbers(5, 7); // Simulating Gherkin "When I add 5 and 7"
    steps.theResultShouldBe(12); // Simulating Gherkin "Then the result should be 12"
  }
}

Flexible Step Matching with Regex

While {int} and {string} are convenient, you can use full regular expressions for more complex matching patterns.

For example, if your Gherkin step was Given I have an (empty|full) wallet, your step definition pattern might be "^I have an (empty|full) wallet$" to capture 'empty' or 'full'.

Use \\d+ for one or more digits.
Use "(.*)" to capture any text.

This allows a single step definition to match several slightly different Gherkin phrases.

BDD Hooks: Setup & Teardown

Sometimes, you need to perform actions before or after each scenario, or even before/after all features. BDD frameworks provide Hooks for this.

@Before: Runs before each scenario. Useful for resetting state.
@After: Runs after each scenario. Good for cleanup.

import io.cucumber.java.en.Given;
import io.cucumber.java.en.When;
import io.cucumber.java.en.Then;
import io.cucumber.java.Before;
import io.cucumber.java.After;

public class StepDefinitions {
  private Calculator calculator;

  @Before
  public void setupScenario() {
    System.out.println("\n--- Scenario Setup (@Before) ---");
    calculator = new Calculator(); // Ensure a fresh calculator for each scenario
  }

  @After
  public void teardownScenario() {
    System.out.println("--- Scenario Teardown (@After) ---");
    // Optional: add cleanup if needed, e.g., closing resources
  }

  @Given("I have a calculator")
  public void iHaveACalculator() {
    System.out.println("Given: Calculator initialized.");
  }

  @When("I add {int} and {int}")
  public void iAddTwoNumbers(int num1, int num2) {
    calculator.add(num1, num2);
    System.out.println("When: Added " + num1 + " and " + num2 + ".");
  }

  @Then("the result should be {int}")
  public void theResultShouldBe(int expectedResult) {
    if (calculator.getResult() == expectedResult) {
      System.out.println("Then: Result is " + expectedResult + ". Test PASSED!");
    } else {
      System.out.println("Then: Expected " + expectedResult + ", got " + calculator.getResult() + ". Test FAILED!");
    }
  }

  public static void main(String[] args) {
    StepDefinitions steps = new StepDefinitions();
    // Simulate a scenario run
    steps.setupScenario();
    steps.iHaveACalculator();
    steps.iAddTwoNumbers(8, 4); // Simulating Gherkin "When I add 8 and 4"
    steps.theResultShouldBe(12); // Simulating Gherkin "Then the result should be 12"
    steps.teardownScenario();

    // Simulate another scenario run
    steps.setupScenario();
    steps.iHaveACalculator();
    steps.iAddTwoNumbers(10, 0); // Simulating Gherkin "When I add 10 and 0"
    steps.theResultShouldBe(10); // Simulating Gherkin "Then the result should be 10"
    steps.teardownScenario();
  }
}

Running Your Feature Files

In a real BDD project, you wouldn't manually call step definition methods like we did in main.

Instead, you'd have a Test Runner (often a JUnit test class) that tells the BDD framework (e.g., Cucumber) where to find your feature files and step definitions.

The runner then parses the Gherkin, finds matching step definitions, and executes them in order, reporting the results.

Quick Check: Step Definition Roles

Match the BDD annotation to its primary role in a step definition.

Recap: Implementing Step Definitions

You've learned how to connect human-readable Gherkin steps to executable code!

Step Definitions are Java methods annotated with @Given, @When, or @Then.
They use regular expressions or Cucumber Expressions (like {int}) to match Gherkin text.
Arguments can be captured from the Gherkin step and passed to the method.
Hooks like @Before and @After help manage scenario setup and teardown.

This bridge between language and code is fundamental to BDD, ensuring tests are understandable by everyone involved in the project!

常见问题解答

「实现步骤定义」课时是免费的吗？

是的 — 「实现步骤定义」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Testing Mastery: JUnit, Mockito & Integration Tests 课程的其余内容，请升级到 CoddyKit PRO。 Testing Mastery: JUnit, Mockito & Integration Tests 课程共包含 4 节课。

「实现步骤定义」这节课中我会学到什么？

通过使用 BDD 框架编写步骤定义，将 Gherkin 功能文件连接到可执行代码。你通过在浏览器中直接运行的动手代码来练习 Testing Mastery: JUnit, Mockito & Integration Tests，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Testing Mastery: JUnit, Mockito & Integration Tests 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Testing Mastery: JUnit, Mockito & Integration Tests 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「实现步骤定义」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Testing Mastery: JUnit, Mockito & Integration Tests 课中编写并运行代码吗？

能。每节 Testing Mastery: JUnit, Mockito & Integration Tests 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Testing Mastery: JUnit, Mockito & Integration Tests