实体Java单元测试自动化？（JUnit/Hamcrest/…)

Question

我正在寻找以下内容：

• 坚实的单元测试方法
  1. 我的方法缺少了什么？
  2. 我做错了什么？
  3. 我在做什么是不必要的？

null

null

null

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Arrays;
import com.google.common.collect.ImmutableList;
public class MyPath {
  public static final MyPath ROOT = MyPath.ofComponents("ROOT");
  public static final String SEPARATOR = "/";
  public static MyPath ofComponents(String... components) {
    checkNotNull(components);
    checkArgument(components.length > 0);
    checkArgument(!Arrays.asList(components).contains(""));
    return new MyPath(components);
  }
  private final ImmutableList<String> components;
  private MyPath(String[] components) {
    this.components = ImmutableList.copyOf(components);
  }
  public ImmutableList<String> getComponents() {
    return components;
  }
  @Override
  public String toString() {
    StringBuilder stringBuilder = new StringBuilder();
    for (String pathComponent : components) {
      stringBuilder.append("/" + pathComponent);
    }
    return stringBuilder.toString();
  }
}

import static org.hamcrest.Matchers.is;
import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.hamcrest.core.IsNull.notNullValue;
import static org.junit.Assert.assertThat;
import org.junit.Test;
import org.junit.experimental.runners.Enclosed;
import org.junit.runner.RunWith;
import com.google.common.base.Joiner;
@RunWith(Enclosed.class)
public class MyPathTests {
  public static class GetComponents {
    @Test
    public void componentsCorrespondToFactoryArguments() {
      String[] components = { "Test1", "Test2", "Test3" };
      MyPath myPath = MyPath.ofComponents(components);
      assertThat(myPath.getComponents(), contains(components));
    }
  }
  public static class OfComponents {
    @Test
    public void acceptsArrayOfComponents() {
      MyPath.ofComponents("Test1", "Test2", "Test3");
    }
    @Test
    public void acceptsSingleComponent() {
      MyPath.ofComponents("Test1");
    }
    @Test(expected = IllegalArgumentException.class)
    public void emptyStringVarArgsThrows() {
      MyPath.ofComponents(new String[] { });
    }
    @Test(expected = NullPointerException.class)
    public void nullStringVarArgsThrows() {
      MyPath.ofComponents((String[]) null);
    }
    @Test(expected = IllegalArgumentException.class)
    public void rejectsInterspersedEmptyComponents() {
      MyPath.ofComponents("Test1", "", "Test2");
    }
    @Test(expected = IllegalArgumentException.class)
    public void rejectsSingleEmptyComponent() {
      MyPath.ofComponents("");
    }
    @Test
    public void returnsNotNullValue() {
      assertThat(MyPath.ofComponents("Test"), is(notNullValue()));
    }
  }
  public static class Root {
    @Test
    public void hasComponents() {
      assertThat(MyPath.ROOT.getComponents(), is(not(empty())));
    }
    @Test
    public void hasExactlyOneComponent() {
      assertThat(MyPath.ROOT.getComponents(), hasSize(1));
    }
    @Test
    public void hasExactlyOneInboxComponent() {
      assertThat(MyPath.ROOT.getComponents(), contains("ROOT"));
    }
    @Test
    public void isNotNull() {
      assertThat(MyPath.ROOT, is(notNullValue()));
    }
    @Test
    public void toStringIsSlashSeparatedAbsolutePathToInbox() {
      assertThat(MyPath.ROOT.toString(), is(equalTo("/ROOT")));
    }
  }
  public static class ToString {
    @Test
    public void toStringIsSlashSeparatedPathOfComponents() {
      String[] components = { "Test1", "Test2", "Test3" };
      String expectedPath =
          MyPath.SEPARATOR + Joiner.on(MyPath.SEPARATOR).join(components);
      assertThat(MyPath.ofComponents(components).toString(),
          is(equalTo(expectedPath)));
    }
  }
  @Test
  public void testPathCreationFromComponents() {
    String[] pathComponentArguments = new String[] { "One", "Two", "Three" };
    MyPath myPath = MyPath.ofComponents(pathComponentArguments);
    assertThat(myPath.getComponents(), contains(pathComponentArguments));
  }
}

>

是否有用于构建单元测试的技术列表？一些比我上面过于简化的列表更高级的东西（例如检查空值、检查边界、检查预期异常等）也许可以在一本书中购买或一个URL中访问？

一旦我有了一个接受某种类型参数的方法，我可以得到任何Eclipse插件来为我的测试生成存根吗？也许使用Java注释来指定关于方法的元数据，并让工具为我实现相关的检查？（例如@mustbelowercase，@shouldbeofsize(n=3)，...)

我发现必须记住所有这些“QA技巧”和/或应用它们是乏味的，像机器人一样，我发现复制和粘贴容易出错，我发现当我像上面那样编写代码时，它不是自我文档化的。诚然，Hamcrest库朝着专门化测试类型的总体方向前进（例如，使用RegEx对字符串对象、对文件对象等），但显然不会自动生成任何测试存根，也不会反思代码及其属性，并为我准备一套工具。

请不要告诉我，我只是在展示代码，这是一个愚蠢的包装，围绕着从静态工厂方法中提供的路径步骤列表中创建路径的概念。这是一个完全虚构的示例，但它展示了参数验证的“几个”案例...如果我包括一个更长的例子，谁会真正阅读这篇文章？

Answer 1

>

考虑使用ExpectedException而不是@test(Expected...。这是因为，例如，如果您期望出现NullPointerException，并且测试在设置中抛出此异常（在调用测试中的方法之前），那么测试将通过。使用ExpectedException，您将expect放在调用测试中的方法之前，这样就不会出现这种情况。此外，ExpectedException允许您测试异常消息，如果您有两个不同的

考虑将测试中的方法与设置和验证隔离开来，这将简化测试审查和维护。当被测试类上的方法作为设置的一部分被调用时尤其如此，这可能会混淆哪个是被测试的方法。我使用以下格式：

public void test() {
   //setup
   ...

   // test (usually only one line of code in this block)
   ...

   //verify
   ...
}

参考书籍：干净的代码，JUnit在行动，通过示例测试驱动开发

Clean Code有一个很好的测试部分

我所见过的大多数示例（包括Eclipse autogenerates）都在测试标题中包含了正在测试的方法。这便于审查和维护。例如:testofcomponents_nullcase。您的示例是我看到的第一个使用括起来的根据测试中的方法对方法进行分组的示例，这非常好。但是，它增加了一些开销，因为@before和@after不能在封闭的测试类之间共享。

我还没有开始使用它，但是Guava有一个测试库：guava-testlib。我没有机会玩它，但它似乎有一些很酷的东西。例如：NullPointerTest是引号：

null

在测试root时，正如前面所指出的，我建议调用root.getcomponents一次，并对其进行所有三个验证。此外，ITIterableContainingInOrder执行not empty、size和contains中的所有三个操作。测试中的是是额外的（尽管它是语言上的），我觉得不值得使用(IMHO)。

在测试ToString时，我觉得隔离测试中的方法非常有帮助。我应该编写toStringisSlashSeparatedPathofComponents如下所示。请注意，我没有使用测试类中的常量。这是因为在IMHO中，对被测试类的任何功能更改都应该导致测试失败。

@Test     
public void toStringIsSlashSeparatedPathOfComponents() {       
   //setup 
   String[] components = { "Test1", "Test2", "Test3" };       
   String expectedPath =  "/" + Joiner.on("/").join(components);   
   MyPath path = MyPath.ofComponents(components)

   // test
   String value = path.toStrign();

   // verify
   assertThat(value, equalTo(expectedPath));   
} 

封闭将不会运行任何不在内部类中的单元测试。因此TestPathCreationFromComponents不会运行。

最后，使用测试驱动开发。这将确保您的测试以正确的原因通过，并按预期失败。