使用Intellij IDEA和JUnit5练习FizzBuzz TDD Kata

╰+哭是因爲堅強的太久メ 2022-10-19 12:40 212阅读 0赞

### 文章目录 ###

*  使用Intellij IDEA和JUnit5练习FizzBuzz TDD Kata
 *   *  前言
     *  配置IDE
     *   *  配置Intellij IDEA的live template
         *  安装SonarLint插件
     *  创建和配置项目
     *   *  创建Maven项目
         *  引入JUnit5
         *  引入AssertJ
     *  FizzBuzz Kata介绍
     *  TDD Kata过程
     *   *  创建测试类
         *  编写测试方法
         *  首次运行测试
         *  Test Case 1: 如果该整数为0，则返回“0”
         *   *  编写测试代码
             *  测试失败（红）
             *  编写实现代码
             *  测试成功（绿）
         *  Test Case 2: 如果该整数可以被3整除，则返回"Fizz"
         *   *  编写测试代码
             *  测试失败（红）
             *  编写实现代码
             *  测试部分成功（部分绿）
             *  修改实现代码
             *  测试成功（绿）
         *  Test Case3: 如果该整数可以被5整除，则返回"Buzz"
         *   *  编写测试代码
             *  测试失败（红）
             *  编写实现代码
             *  测试成功（绿）
         *  Test Case 4: 如果该整数可以同时被3和5整除，则返回 "FizzBuzz"
         *   *  编写测试代码
             *  测试失败（红）
             *  编写实现代码
             *  测试成功（绿）
         *  Test Case5: 除了上述情况外，返回该整数的字符串
         *   *  编写测试代码
             *  测试成功
         *  重构代码
         *   *  精简代码
             *  抽取代码到方法中
             *  逻辑优化
         *  参数化测试
     *  本地代码质量检查
     *  本地测试覆盖率检查
     *  切分窗口
     *  快捷方式
     *  摒弃不必要的心理压力
     *  扩展阅读

# 使用Intellij IDEA和JUnit5练习FizzBuzz TDD Kata #

## 前言 ##

本文描述了使用Intellij IDEA和JUnit5练习FizzBuzz TDD Kata的详细过程。

工具：

*  Intellij IDEA Ultimate
 *  JUnit5
 *  Maven
 *  Java 8+

示例代码：

*  [code-kata][]

## 配置IDE ##

### 配置Intellij IDEA的live template ###

在Intellj中，配置一个名为`test`的live tempalte，用来输入`test`后回车自动生成JUnit5的测试方法。

在Intellij中，打开 File / References，打开Editor / Live Tempaltes。

点击+号，创建一个Template Group名为`user`，再在该group下创建一个Live Template。

*  Abbreviation： `test`
 *  Description: `JUnit 5 test method`
 *  Template text:
    
        @org.junit.jupiter.api.Test
        @org.junit.jupiter.api.DisplayName("$TEST_NAME$")
        void $METHOD_NAME$() { 
            $END$
            $BODY$
        }
 *  勾选“Reformat according to style", “Use static import if possible” 和 “Shorten FQ names"。
 *  点击“Define”按钮，选择Java / Declaration。
 *  点击”Edit varibales“按钮，编辑相关变量：

TEST_NAME:
    Expression=<leave blank>
    Default value="Test name"
    
    METHOD_NAME:
    Expression=camelCase(TEST_NAME)
    Default value="methodName"
    
    BODY:
    Expression=<leave blank>
    Default value="org.junit.jupiter.api.Assertions.fail(\"Not implemented\");"
    Tick "Skip if defined"

保存新创建的live tempalte。

### 安装SonarLint插件 ###

在Intellij中安装SoanrLinit插件用于本地代码质量检查。

虽然Intellij也自带Inspection的代码质量检查功能，但是SonarLint插件可以和SonarQube配套使用。所以这里还是推荐使用SonarLint插件。

## 创建和配置项目 ##

### 创建Maven项目 ###

在Intellij中按照向导创建Maven项目，或执行以下命令创建Maven项目：

mvn -B archetype:generate \
    			-DarchetypeGroupId=org.apache.maven.archetypes \
    			-DarchetypeArtifactId=maven-archetype-quickstart \
    			-DarchetypeVersion=RELEASE \
    			-DgroupId=cn.xdevops.kata \
    			-DartifactId=code-kata

执行命令前先替换`groupdId`和`artifactId`.

打开pom.xml，确保`maven.compiler`的值为`1.8`。

在Intellij中，打开File / Project Structure，确保module的Language level为8。打开Maven菜单，点击Reimport。

### 引入JUnit5 ###

相比JUnit4，JUnit5引入了一些比较好用的新特性。

在pom.xml中添加dependency:

<dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <scope>test</scope>
    </dependency>

并添加dependencyManagement：

<dependencyManagement>
        <dependencies>
          <dependency>
            <groupId>org.junit</groupId>
            <artifactId>junit-bom</artifactId>
            <version>5.7.2</version>
            <type>pom</type>
            <scope>import</scope>
          </dependency>
        </dependencies>
      </dependencyManagement>

### 引入AssertJ ###

相比JUnit自带的asserstion，AssertJ的流式断言更加强大和方便输入。

在pom.xml中添加dependency:

<dependency>
      <groupId>org.assertj</groupId>
      <artifactId>assertj-core</artifactId>
      
      <version>3.20.1</version>
      <scope>test</scope>
    </dependency>

## FizzBuzz Kata介绍 ##

**规则:**

给一个大于或等于0的整数。

1.  如果该整数为0，则返回“0”
2.  如果该整数可以被3整除，则返回"Fizz"
3.  如果该整数可以被5整除，则返回"Buzz"
4.  如果该整数可以同时被3和5整除，则返回 “FizzBuzz”
5.  除了上述情况外，返回该整数的字符串

**示例:**

0 # 0
    1 # 1
    2 # 2
    3 # Fizz
    4 # 4
    5 # Buzz
    6 # Fizz
    7 # 7
    8 # 8
    9 # Fizz
    10 # Buzz
    11 # 11
    12 # Fizz
    13 # 13
    14 # 14
    15 # FizzBuzz
    16 # 16
    17 # 17
    18 # Fizz
    19 # 19
    20 # Buzz

## TDD Kata过程 ##

### 创建测试类 ###

按照TDD的实践，先写测试代码，后写实现代码。

在src/test目录下创建`fizzbuzz`的package，然后再创建`FizzBuzzTest`的类。

### 编写测试方法 ###

输入`test`回车，Intellj会根据上面配置号的live template自动生成JUnit5的测试方法代码。

@Test
    @DisplayName("Test name")
    void testName() { 
    
      fail("Not implemented");
    }

修改`@DisplayName`中的测试方法描述，会同步修改测试方法名。比如：

@Test
    @DisplayName("should return 0 when 0")
    void shouldReturn0When0() { 
    
      fail("Not implemented");
    }

自动生成的测试方法代码中包含fail语句，在编写assert语句后，需要手动删除该fail语句。

包含该fail语句是为了避免忘记实现测试代码，也是TDD从测试失败开始的实践。

### 首次运行测试 ###

首次运行测试时会失败，因为还没有实现测试代码。

### Test Case 1: 如果该整数为0，则返回“0” ###

#### 编写测试代码 ####

@Test
    @DisplayName("should return 0 when 0")
    void shouldReturn0When0() { 
      assertThat(FizzBuzz.of(0)).isEqualTo("0");
    }

本文的测试代码都是用AssertJ的assertThat流式断言。

通过`Alt` \+ `Enter` 键来引入包、创建类和创建方法，以消除代码编译错误。

此时创建的`FizzBuzz`类如下：

public class FizzBuzz { 
        public static String of(int i) { 
            return null;
        }
    }

#### 测试失败（红） ####

测试失败，因为实现代码还未实现功能。

#### 编写实现代码 ####

public static String of(int i) { 
      return String.valueOf(i);
    }

#### 测试成功（绿） ####

测试成功。

### Test Case 2: 如果该整数可以被3整除，则返回"Fizz" ###

#### 编写测试代码 ####

@Test
    @DisplayName("should return Fizz when divisible by 3")
    void shouldReturnFizzWhenDivisibleBy3() { 
      assertThat(FizzBuzz.of(3)).isEqualTo("Fizz");
    }

#### 测试失败（红） ####

测试失败，因为实现代码还未实现功能。

#### 编写实现代码 ####

public static String of(int i) { 
      if (i % 3 == 0) { 
        return "Fizz";
      }
      return String.valueOf(i);
    }

#### 测试部分成功（部分绿） ####

Test Case 2测试成功，但是原来成功的Test Case 1失败了。

#### 修改实现代码 ####

public static String of(int i) { 
      if (i == 0) { 
        return "0";
      }
      if (i % 3 == 0) { 
        return "Fizz";
      }
      return String.valueOf(i);
    }

#### 测试成功（绿） ####

全部测试案例测试成功。

### Test Case3: 如果该整数可以被5整除，则返回"Buzz" ###

#### 编写测试代码 ####

@Test
    @DisplayName("should return Buzz when divisible by 5")
    void shouldReturnBuzzWhenDivisibleBy5() { 
      assertThat(FizzBuzz.of(5)).isEqualTo("Buzz");
    }

#### 测试失败（红） ####

测试失败，因为实现代码还未实现功能。

#### 编写实现代码 ####

public static String of(int i) { 
      if (i == 0) { 
        return "0";
      }
      if (i % 3 == 0) { 
        return "Fizz";
      }
      if (i % 5 == 0) { 
        return "Buzz";
      }
      return String.valueOf(i);
    }

#### 测试成功（绿） ####

测试成功。

### Test Case 4: 如果该整数可以同时被3和5整除，则返回 “FizzBuzz” ###

#### 编写测试代码 ####

@Test
    @DisplayName("should return FizzBuzz when divisible by 3 and 5")
    void shouldReturnFizzBuzzWhenDivisibleBy3And5() { 
      assertThat(FizzBuzz.of(15)).isEqualTo("FizzBuzz");
    }

#### 测试失败（红） ####

测试失败，因为实现代码还未实现功能。

#### 编写实现代码 ####

public static String of(int i) { 
      if (i == 0) { 
        return "0";
      }
      if (i % 3 == 0 && i % 5 == 0) { 
        return "FizzBuzz";
      }
      if (i % 3 == 0) { 
        return "Fizz";
      }
      if (i % 5 == 0) { 
        return "Buzz";
      }
      return String.valueOf(i);
    }

#### 测试成功（绿） ####

测试成功。

### Test Case5: 除了上述情况外，返回该整数的字符串 ###

#### 编写测试代码 ####

@Test
    @DisplayName("should return its string when not divisible by 3 and 5")
    void shouldReturnItsStringWhenNotDivisibleBy3And5() { 
      assertThat(FizzBuzz.of(1)).isEqualTo("1");
    }

#### 测试成功 ####

因为前面已经考虑到这种情况，所以测试成功。

### 重构代码 ###

重构`FizzBuzz`类的代码，让代码更加整洁。

#### 精简代码 ####

public static String of(int i) { 
      if (i == 0) { 
        return "0";
      }
    
      String s = "";
      if (i % 3 == 0) { 
        s += "Fizz";
      }
      if (i % 5 == 0) { 
        s += "Buzz";
      }
      return s.isEmpty() ? String.valueOf(i) : s;
    }

确保精简后，重新测试通过。

#### 抽取代码到方法中 ####

选中要精简的代码，右键，选择Refactor / Extract Method。

public static String of(int i) { 
       if (i == 0) { 
         return "0";
       }
    
       return ofInt(i);
     }
    
    private static String ofInt(int i) { 
      String s = "";
      if (i % 3 == 0) { 
        s += "Fizz";
      }
      if (i % 5 == 0) { 
        s += "Buzz";
      }
      return s.isEmpty() ? String.valueOf(i) : s;
    }

确保抽取代码后，重新测试通过。

#### 逻辑优化 ####

将`s.isEmpty() ? String.valueOf(i) : s` 改为 `!s.isEmpty() ? s : String.valueOf(i)`，使得逻辑更容易理解。

确保重新测试通过。

### 参数化测试 ###

相比JUunit4，JUnit5的参数化测试更为简单。

下面演示对Test Case5作参数化测试。

@ParameterizedTest
    @DisplayName("should return its string when not divisible by 3 and 5")
    @ValueSource(ints = { 1, 2, 4, 7, 8})
    void shouldReturnItsStringWhenNotDivisibleBy3And5(int value) { 
      assertThat(FizzBuzz.of(value)).isEqualTo(String.valueOf(value));
    }

## 本地代码质量检查 ##

在Intellij中，打开SoanrLint窗口，在Curent File中查看代码质量检查结果。

`FizzBuzzTest`类中有一个提醒（Info）：

*  JUnit5 test classes and methods should have default package visibility

`FizzBuzz`类有一个Major的警告：

*  Utility classes should not have public constructors

消除这些SonarLint警告。

在`FizzBuzzTest`类中去掉类声明前面的`public`关键字。

class FizzBuzzTest

在`FizzBuzz`类中添加一个私有的构造方法，并且不允许调用该构造方法。

private FizzBuzz() { 
      throw new IllegalStateException("Utility class");
    }

另外注意类窗口右上角的警告图标，比如需要去掉没有用的import语句。

## 本地测试覆盖率检查 ##

在Intellj中运行Run…with Coverage，可以查看测试覆盖率检查结果，包括类、方法和行的测试覆盖率。

## 切分窗口 ##

为了方便同时查看测试类和实现类，可以在Intellij中切分窗口。

同时打开了`FizzBuzzTest`和`FizzBuzz`类的窗口，右键选择`FizzBuzz`类，点击Split and Move Right。

这样，左边窗口是`FizzBuzzTest` 类，右边窗口是`FizzBuzz`类。

## 快捷方式 ##

在Intellij中，打开Help / Keymap References查看相应的快捷方式。

下面只列出一些常用的快捷方式。

<table> 
 <thead> 
  <tr> 
   <th>快捷键</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>Command</code> + <code>N</code></td> 
   <td>新建</td> 
  </tr> 
  <tr> 
   <td><code>Ctrl</code> + <code>R</code></td> 
   <td>运行程序</td> 
  </tr> 
  <tr> 
   <td><code>Alter</code> + <code>Enter</code></td> 
   <td>解决程序编译错误</td> 
  </tr> 
  <tr> 
   <td><code>Command</code> + <code>Option</code> + <code>M</code></td> 
   <td>重构-抽取方法</td> 
  </tr> 
  <tr> 
   <td><code>Shift</code> + <code>F6</code></td> 
   <td>重构-重命名</td> 
  </tr> 
  <tr> 
   <td><code>Command</code> + <code>Option</code> + <code>O</code></td> 
   <td>去掉没有用的import语句</td> 
  </tr> 
 </tbody> 
</table>

## 摒弃不必要的心理压力 ##

打字速度快，熟记快捷键甚至不用鼠标，虽然对编程有帮助，但是不是决定性因素。

因此如果记不住快捷键，或打字时还是要看一下键盘，也不要心理压力。编程毕竟是脑力劳动，不是体力劳动。

保持清醒的头脑，按照TDD的实践，加以练习，自然可以又快（相对快）又好地编写代码。

## 扩展阅读 ##

*  [Intellij IDEA | Writing Tests with JUnit 5][Intellij IDEA _ Writing Tests with JUnit 5]
 *  [FizzBuzz (Java) - Code Katas Explained][FizzBuzz _Java_ - Code Katas Explained]
 *  [Martin Fowler | Test Driven Development][Martin Fowler _ Test Driven Development]
 *  [使用Intellij来实践测试驱动开发 TDD Kata][Intellij_ TDD Kata]

[code-kata]: https://github.com/cookcodeblog/code-kata
[Intellij IDEA _ Writing Tests with JUnit 5]: https://blog.jetbrains.com/idea/2020/09/writing-tests-with-junit-5/
[FizzBuzz _Java_ - Code Katas Explained]: https://youtu.be/JyRouDwzCoo
[Martin Fowler _ Test Driven Development]: https://martinfowler.com/bliki/TestDrivenDevelopment.html
[Intellij_ TDD Kata]: https://blog.csdn.net/nklinsirui/article/details/107084540