如何在不重复代码的情况下在 Junit5 中测试接口的不同实现

Question

请问如何为具有不同实现的接口编写junit 5测试？

例如，我有一个接口Solution ，具有不同的实现，如SolutionI ， SolutionII ，我可以只编写一个测试类来测试两者吗？

有一个帖子展示了一个例子，但是如果有多个测试方法需要调用，我必须为每个测试方法传递参数。

请问有没有类似Junit4中使用的优雅方式

在 Junit4 中，我有一个非常优雅的代码示例如下

@RunWith(Parameterized.class)
public class SolutionTest {
  private Solution solution;

  public SolutionTest(Solution solution) {
    this.solution = solution;
  }

  @Parameterized.Parameters
  public static Collection<Object[]> getParameters() {
    return Arrays.asList(new Object[][]{
        {new SolutionI()},
        {new SolutionII()}
    });
  }
  // normal test methods
  @Test
  public void testMethod1() {

  }
}

Junit 5 声称ExtendWith()类似，我尝试了以下代码

@ExtendWith(SolutionTest.SolutionProvider.class)
public class SolutionTest {
  private Solution solution;

  public SolutionTest(Solution solution) {
    System.out.println("Call constructor");
    this.solution = solution;
  }

  @Test
  public void testOnlineCase1() {
    assertEquals(19, solution.testMethod(10));
  }

  @Test
  public void testOnlineCase2() {
    assertEquals(118, solution.testMethod(100));
  }

  static class SolutionProvider implements ParameterResolver {
    private final Solution[] solutions = {
        new SolutionI(),
        new SolutionII()
    };
    private static int i = 0;

    @Override
    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
      return parameterContext.getParameter().getType() == Solution.class;
    }

    @Override
    public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
      System.out.println(i);
      return solutions[i++];
    }
  }
}

不幸的是， testMethod1使用的是SolutionI而testMethod2使用的是SolutionII ，这是有道理的，我不知道这是否有助于启发一点。

我在这里先向您的帮助表示感谢

Answer 1

木星提供的测试接口正是你的目的-测试界面合同。

例如，让我们有一个字符串诊断合约的接口和两个遵循合约但利用不同实现思路的实现：

public interface StringDiagnose {
    /**
     * Contract: a string is blank iff it consists of whitespace chars only
     * */
    boolean isTheStringBlank(String string);
}

public class DefaultDiagnose implements StringDiagnose {

    @Override
    public boolean isTheStringBlank(String string) {
        return string.trim().length() == 0;
    }
}

public class StreamBasedDiagnose implements StringDiagnose {

    @Override
    public boolean isTheStringBlank(String string) {
        return string.chars().allMatch(Character::isWhitespace);
    }
}

根据推荐的方法，您将创建测试接口，以验证default方法中的诊断合同并将依赖于实现的部分公开给钩子：

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertFalse;

public interface StringDiagnoseTest<T extends StringDiagnose> {

    T createDiagnose();

    @Test
    default void blankCheckFollowsContract(){
        assertTrue(createDiagnose().isTheStringBlank("\t\n "));
        assertFalse(createDiagnose().isTheStringBlank("\t\n !  \r\n"));
    }
}

然后为每个特定于解决方案的解决方案实现此测试接口：

class DefaultDiagnoseTest implements StringDiagnoseTest<DefaultDiagnose> {

    @Override
    public DefaultDiagnose createDiagnose() {
        return new DefaultDiagnose();
    }
}

class StreamBasedDiagnoseTest implements StringDiagnoseTest<StreamBasedDiagnose> {

    @Override
    public StreamBasedDiagnose createDiagnose() {
        return new StreamBasedDiagnose();
    }
}

使用更多的钩子和非default接口方法来测试同名解决方案的方面（如性能），并在接口实现中定义新的测试，以获得完全不同的实现特性。

Answer 2

很抱歉有一段时间没有回复这个帖子。 与 lotor 的回答相比，我发现了我目前采用的其他一些方法：

  @ParameterizedTest
  @MethodSource("solutionStream")
  void testCase(Solution solution) {
   // add your test
  }

  static Stream<Solution> solutionStream() {
    return Stream.of(
        new SolutionI(),
        new SolutionII()
    );
  }

构造函数需要参数（非类型安全）

  @ParameterizedTest
  @MethodSource("solutionStream")
  void testOnlineCase(Class<Solution> solutionClass) throws NoSuchMethodException, IllegalAccessException,
      InvocationTargetException, InstantiationException {
    Solution solution = solutionClass.getConstructor(Integer.TYPE).newInstance(2);
  }

  static Stream<Class> solutionStream() {
    return Stream.of(
        SolutionI.class
    );
  }

Answer 3

例如，我有一个接口解决方案，具有不同的实现，如解决方案I、解决方案II，我可以只编写一个测试类来测试两者吗？

简短的回答是你不应该那样做。 对于 UT，最佳实践是每个实现都有自己的测试类，因此如果一个实现发生变化，那么只有相关的测试会受到影响。 请在下面找到一些额外的想法：

• 如果你有同一个接口的两个实现，我猜逻辑是不同的，否则为什么要首先有两个实现呢？ 所以你应该有两组测试；

• 如果您在两个实现之间有共同的逻辑，那么您应该将它放在一个抽象类中，该类将被您的实现扩展。

• ParameterizedTest 不应被滥用以偏离最佳模式；

• 在其他以避免测试的代码复制，根据你的使用情况，在JUnit5你的确可以使用扩展作为解释这里的文件中。