单元测试的问题：Junit 和 Mockito 框架

Question

我正在学习使用 Junit 和 Mockito 框架进行单元测试和双重测试，但是在使用“模拟”的特定测试中我没有得到预期的结果。我做了一个assertThat，它应该返回正面测试，相反，它返回一个错误，上面写着Mockito cannot mock this class。它是一个名为“控制台”的类，它必须从用户的键盘打印和收集值，但是当然，在单元测试中，这应该被“模拟”以避免反模式中的“干预测试”，其中测试要求数据开发人员，也就是说，我需要“模拟”用户输入。这个“控制台”类就像典型的 java BufferedReader 类的一个小外观。

我把所涉及的课程传给你：

控制台：

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Console {

    private BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    public String readString(String title) {
        String input = null;
        boolean ok = false;
        do {
            this.write(title);
            try {
                input = this.bufferedReader.readLine();
                ok = true;
            } catch (Exception ex) {
                this.writeError("characte string");
            }
        } while (!ok);
        return input;
    }

    public int readInt(String title) {
        int input = 0;
        boolean ok = false;
        do {
            try {
                input = Integer.parseInt(this.readString(title));
                ok = true;
            } catch (Exception ex) {
                this.writeError("integer");
            }
        } while (!ok);
        return input;
    }

    public char readChar(String title) {
        char charValue = ' ';
        boolean ok = false;
        do {
            String input = this.readString(title);
            if (input.length() != 1) {
                this.writeError("character");
            } else {
                charValue = input.charAt(0);
                ok = true;
            }
        } while (!ok);
        return charValue;
    }

    public void writeln() {
        System.out.println();
    }

    public void write(String string) {
        System.out.print(string);
    }

    public void writeln(String string) {
        System.out.println(string);
    }

    public void write(char character) {
        System.out.print(character);
    }

    public void writeln(int integer) {
        System.out.println(integer);
    }

    private void writeError(String format) {
        System.out.println("FORMAT ERROR! " + "Enter a " + format + " formatted value.");
    }
}

控制台测试：

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import java.io.BufferedReader;
import java.io.IOException;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.*;
import static org.mockito.MockitoAnnotations.initMocks;

public class ConsoleTest {

    @Mock
    private BufferedReader bufferedReader;
    @InjectMocks
    private Console console;

    @BeforeEach
    public void before(){
        initMocks(this);
        //this.console = new Console();
    }
    @Test
    public void givenConsoleWhenReadStringThenValue() throws IOException {
        String string = "yes";
        when(this.bufferedReader.readLine()).thenReturn(string);
        assertThat(this.console.readString("title"), is(string));
    }
}

pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://maven.apache.org/POM/4.0.0"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <modules>

    </modules>

    <artifactId>solution.java.swing.socket.sql</artifactId>
    <groupId>usantatecla.tictactoe</groupId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>

    <name>${project.groupId}.${project.artifactId}</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.6.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-inline</artifactId>
            <version>3.6.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-junit-jupiter</artifactId>
            <version>3.6.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest</artifactId>
            <version>2.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>0.8.3</version>
                <executions>
                    <execution>
                        <id>default-prepare-agent</id>
                        <goals>
                            <goal>prepare-agent</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>default-report</id>
                        <phase>post-integration-test</phase>
                        <goals>
                            <goal>report</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
                <dependencies>
                    <dependency>
                        <groupId>org.junit.platform</groupId>
                        <artifactId>junit-platform-surefire-provider</artifactId>
                        <version>1.2.0</version>
                    </dependency>
                </dependencies>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
                <version>2.22.2</version>
                <dependencies>
                    <dependency>
                        <groupId>org.junit.platform</groupId>
                        <artifactId>junit-platform-surefire-provider</artifactId>
                        <version>1.2.0</version>
                    </dependency>
                </dependencies>
                <executions>
                    <execution>
                        <goals>
                            <goal>integration-test</goal>
                            <goal>verify</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

感谢社区的问候！

Answer 1

我个人不太喜欢 Mockito，我更喜欢使用一个接口和两个实现（一个用于生产，一个用于测试）来完全控制我的类。

因此，这不会直接回答您关于 Mockito 的问题，但它允许您完美控制代码的行为，而无需使用其他框架。

你可以定义一个非常简单的接口：

public interface Reader {
    String readLine();
}

然后，您在类控制台中使用该接口：

public class Console {
    private final Reader reader;

    public Console(Reader reader) {
        this.reader = reader;
    }
    
    //Replace all your this.bufferedReader.readLine() by this.reader.readLine();
   
}

因此，在您的生产代码中，您可以使用带有缓冲阅读器的实际实现：

public class ProductionReader implements Reader {
    
    private final BufferedReader bufferedReader = new BufferedReader(...);

    @Override
    public String readLine() {
        this.bufferedReader.readLine();
    }
     
}

---

Console console = new Console(new ProductionReader());

...在您的测试中，您可以使用测试实现：

public class TestReader implements Reader {
    @Override
    public String readLine() {
        return "Yes";
    }
}

---

Console console = new Console(new TestReader());

请注意，虽然在您的特定情况下，您可以使用 Mockito 模拟行为，但在许多其他情况下，您将需要更复杂的方法，并且可以让您对代码进行完全控制和完全可调试性无需添加任何依赖。