如何编写 JUnit 测试用例来测试线程和事件

Question

我有一个在一个（主）线程中工作的java代码。从主线程中，我生成一个新线程，在其中进行服务器调用。服务器调用完成后，我在新线程中执行一些工作，然后代码加入主线程。

我正在使用 eclipse Jobs 进行服务器调用。

我想知道如何为此编写 JUnit 测试用例。

Answer 1

您可能需要重组代码以便可以轻松测试。

我可以看到几个不同的测试区域：

1. 线程管理代码：启动线程并可能等待结果的代码
2. 在线程中运行的“工作者”代码
3. 当多个线程处于活动状态时可能导致的并发问题

构建您的实现这样您的线程管理代码就无法了解 Worker 的详细信息。然后，您可以使用 Mock Workers 来启用线程管理测试 - 例如，以某些方式失败的 Mock Worker 允许您测试管理代码中的某些路径。

实现 Worker 代码，使其可以独立运行。然后，您可以使用服务器的模拟来独立进行单元测试。

对于并发测试，Abhijeet Kashnia 提供的链接将有所帮助。

Answer 2

这就是我创建 ConcurrentUnit 的目的。一般用法是：

1. 生成一些线程
2. 让主线程等待或睡眠
3. 从工作线程内执行断言（通过 ConcurrentUnit，报告回主线程）
4. 一旦所有断言完成，就从工作线程之一恢复主线程

有关详细信息，请参阅 ConcurrentUnit 页面。

Answer 3

Abhijeet Kashnia 提供的资源可能会有所帮助，但我不确定您想要实现什么目标。

您可以使用模拟进行单元测试来验证您的代码，这不会测试并发性，但会提供覆盖率。
您可以编写集成测试来验证线程是否按照您期望的方式创建和连接。但是，这不能保证不会出现并发问题。大多数并发问题是由不可预测的计时错误引起的，因此无法准确测试。

Answer 4

当您唯一的问题是等待结果时，请使用 ExecutorService 用于生成线程。它可以接受工作作业作为 Runnable和可调用。当您使用后者时，您将获得 Future 返回对象，可用于等待结果。无论如何，您应该考虑使用ExecutorService，据我了解，您创建了许多线程，这是执行程序服务的完美用例。

class AnyClass {
    private ExecutorService threadPool = Executors.newFixedThreadPool(5);

    public List<Future<Integer>> anyMethod() {
        List<Future> futures = new ArrayList<>();

        futures.add(threadPool.submit(() -> {
            // Do your job here
            return anyStatusCode;
        }));

        futures.add(threadPool.submit(() -> {
            // Do your other job here
            return anyStatusCode;
        }));

        return futures;
    }
}

和测试类：

class TestAnyClass {
    @Test
    public void testAnyMethod() {
        AnyClass anyObject = new AnyClass();

        List<Future<Integer>> futures = anyObject.anyMethod();
        CompletableFuture[] completable = futures.toArray(new CompletableFuture[futures.size()]);

        // Wait for all
        CompletableFuture.allOf(completable).join();
    }
}

Answer 5

我建议您使用模拟框架来确认确实进行了服务器调用。至于线程单元测试：对多线程应用程序进行单元测试

Answer 6

我猜您可能已经完成了模拟代码，并且可能需要一个简单的集成测试来确保您的服务器调用正常工作。

测试线程的困难之一来自于它们的本质——它们是并发的。这意味着您被迫编写 JUnit 测试代码，该代码被迫等待线程完成其工作后再测试代码的结果。这不是测试代码的好方法，并且可能不可靠，但通常意味着您对代码是否正常工作有一定的了解。

例如，您的代码可能看起来像这样：

@Test
public void myIntegrationTest() throws Exception {

   // Setup your test


   // call your threading code
   Results result = myServerClient.doThreadedCode();

   // Wait for your code to complete
   sleep(5);

   // Test the results
   assertEquals("some value",result.getSomeValue());

}


private void sleep(int seconds) {

    try {
        TimeUnit.SECONDS.sleep(seconds);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

我真的不喜欢这样做，更喜欢模拟并同意其他答案。但是，如果您需要测试线程，那么这是我认为有效的一种方法。

Answer 7

这是我使用 thread.start 测试异步方法的解决方案：

public class MyClass {      
   public void doSomthingAsynchrone() {
      new Thread(() -> {
         doSomthing();
      }).start();
   }

   private void doSomthing() {
   }
}

@RunWith(PowerMockRunner.class)
@PrepareForTest(MyClass.class)
public class MyClassTest {
   ArgumentCaptor<Runnable> runnables = ArgumentCaptor.forClass(Runnable.class);

   @InjectMocks
   private MyClass myClass;

   @Test
   public void shouldDoSomthingAsynchrone() throws Exception {  

      // create a mock for Thread.class
      Thread mock = Mockito.mock(Thread.class);

      // mock the 'new Thread', return the mock and capture the given runnable
      whenNew(Thread.class).withParameterTypes(Runnable.class)
            .withArguments(runnables.capture()).thenReturn(mock);

      myClass.doSomthingAsynchrone();

      runnables.getValue().run();

      /**
       *  instead of 'runnables.getValue().run();' you can use a real thread.start
       *
       *   MockRepository.remove(Thread.class);
       *   Thread thread = new Thread(runnables.getValue());
       *   thread.start();
       *   thread.join();
       **/

      verify(myClass, times(1)).doSomthing();
   }
}