Java PowerMockito.when（）.thenReturn（），随机UUID未返回预期值

我正在尝试测试一个Web服务方法，它连接到一个包含JCR节点的SQL Server数据库，就像我们使用JackRabbit一样

该方法如下所示：

public String addDocumentByJson(String fileName, byte[] fileContent, int status, String userName, String jsonProperties) {
    UUID id = UUID.randomUUID();
    // It does a bunch of operations here
    return jsonResult;
}

其中

jsonResult

是一个类似于此的对象：

{
    "id" : "<A random UUID>"
    "version" : 1
}

但是，当我测试此方法时，它给出了以下结果：

Results :

Failed tests: 
    testAddDocumentsByJson(com.optimissa.test.junit.TestJackRabbitService): expected:<{"id":"[1efaf3b8-ca7c-4e6f-878f-102d9a7a92d9]","version":1}> but was:<{"id":"[cfa1a8b0-be6a-46b1-90f5-d2f6d230796a]","version":1}>

从我读到（但我不明白）也许我需要从我试图测试的类中创建一个新对象？我在测试类的一开始就注入了依赖关系，我对

JUnit

测试非常陌生，英语不是我的母语，但是我可以理解大部分内容，但是这个答案让我很难理解它（因为我缺乏JUnit测试方面的知识）

如何使我的

JUnit

测试检索方法内部生成的相同ID（或拦截对

UUID.randomUUD（）

的调用以返回我的

JUnit

测试内部的值）

---

编辑 尝试@hammerfest的答案后，进行以下更改：

UUID uuid = PowerMockito.mock(UUID.class);

mockStatic(UUID.class);
when(UUID.randomUUID()).thenReturn(uuid);

String jsonToCompare = "{\"id\":\"" + uuid + "\",\"version\":1}";
String jsonFromJRS = jackRabbitService.addDocumentByJson(nameFile, bytes, nameApp, 5, jsonproperties);

assertEquals(jsonFromJRS, jsonToCompare);

我仍然得到这个结果：

testAddDocumentsByJson(com.optimissa.test.junit.TestJackRabbitService): expected:<{"id":"[493410b3-dd0b-4b78-97bf-289f50f6e74f]","version":1}> but was:<{"id":"[00000000-0000-0000-0000-000000000000]","version":1}>

testAddDocumentsByJson（com.optimisa.test.junit.TestJackRabbitService）：应为：但为：

我重新使用并修改了@hammerfest的示例，该示例在我的机器上运行

第一种情况只是模拟UUID类的静态调用，并断言SUT返回的UUID等于模拟的UUID：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import java.util.UUID;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.when;

@PrepareForTest({ UUID.class })
@RunWith(PowerMockRunner.class)
public class StaticMockTest {

  @Test
  public void test() {
    MyClass sut = new MyClass();

    UUID uuidLocal = UUID.randomUUID();
    mockStatic(UUID.class);
    when(UUID.randomUUID()).thenReturn(uuidLocal);

    assertThat(sut.getUUID(), is(equalTo(uuidLocal)));
  }

  private class MyClass {

    public UUID getUUID() {
      return UUID.randomUUID();
    }
  }
}

import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.BootstrapWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import org.springframework.test.context.support.DefaultTestContextBootstrapper;

import java.util.UUID;

import javax.annotation.Resource;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.when;

@PrepareForTest({ UUID.class })
@RunWith(PowerMockRunner.class)
@PowerMockRunnerDelegate(SpringRunner.class)
@BootstrapWith(DefaultTestContextBootstrapper.class)
@ContextConfiguration(classes = {StaticMockTest2.ContextConfig.class},
    loader= AnnotationConfigContextLoader.class)
@PowerMockIgnore({"javax.management.*"})
public class StaticMockTest2 {

  @Resource
  private MyClass sut;

  @Test
  public void test() {

    UUID uuidLocal = UUID.randomUUID();
    mockStatic(UUID.class);
    when(UUID.randomUUID()).thenReturn(uuidLocal);

    assertThat(sut.getUUID(), is(equalTo(uuidLocal)));
  }

  private static class MyClass {

    public UUID getUUID() {
      return UUID.randomUUID();
    }
  }

  @Configuration
  public static class ContextConfig {

    @Bean
    public MyClass myClass() {
      return new MyClass();
    }
  }
}

第二种情况调用Spring托管bean的方法，该方法返回模拟的UUID：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import java.util.UUID;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.when;

@PrepareForTest({ UUID.class })
@RunWith(PowerMockRunner.class)
public class StaticMockTest {

  @Test
  public void test() {
    MyClass sut = new MyClass();

    UUID uuidLocal = UUID.randomUUID();
    mockStatic(UUID.class);
    when(UUID.randomUUID()).thenReturn(uuidLocal);

    assertThat(sut.getUUID(), is(equalTo(uuidLocal)));
  }

  private class MyClass {

    public UUID getUUID() {
      return UUID.randomUUID();
    }
  }
}

import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.BootstrapWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import org.springframework.test.context.support.DefaultTestContextBootstrapper;

import java.util.UUID;

import javax.annotation.Resource;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.when;

@PrepareForTest({ UUID.class })
@RunWith(PowerMockRunner.class)
@PowerMockRunnerDelegate(SpringRunner.class)
@BootstrapWith(DefaultTestContextBootstrapper.class)
@ContextConfiguration(classes = {StaticMockTest2.ContextConfig.class},
    loader= AnnotationConfigContextLoader.class)
@PowerMockIgnore({"javax.management.*"})
public class StaticMockTest2 {

  @Resource
  private MyClass sut;

  @Test
  public void test() {

    UUID uuidLocal = UUID.randomUUID();
    mockStatic(UUID.class);
    when(UUID.randomUUID()).thenReturn(uuidLocal);

    assertThat(sut.getUUID(), is(equalTo(uuidLocal)));
  }

  private static class MyClass {

    public UUID getUUID() {
      return UUID.randomUUID();
    }
  }

  @Configuration
  public static class ContextConfig {

    @Bean
    public MyClass myClass() {
      return new MyClass();
    }
  }
}

这两个测试都在我的机器上工作，不过我建议将UUID生成重构为一个实用程序类，您可以通过Spring实例化并注入该类。然后，您可以简单地用普通的Mockito mock替换PowerMock，并避免处理此类问题：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;

import java.util.UUID;

import javax.annotation.Resource;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.powermock.api.mockito.PowerMockito.when;

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = {MockTest3.ContextConfig.class},
    loader= AnnotationConfigContextLoader.class)
public class MockTest3 {

  @Resource
  private Util mockUtil;
  @Resource
  private MyClass sut;

  @Test
  public void test() {

    UUID uuidLocal = UUID.randomUUID();
    when(mockUtil.generateUUID()).thenReturn(uuidLocal);

    assertThat(sut.getUUID(), is(equalTo(uuidLocal)));
  }

  private static class MyClass {

    private Util util;

    public MyClass(Util util) {
      this.util = util;
    }

    public UUID getUUID() {
      return util.generateUUID();
    }
  }

  private static class Util {

    public UUID generateUUID() {
      return UUID.randomUUID();
    }
  }

  @Configuration
  public static class ContextConfig {

    @Bean
    public Util mockUtil() {
      return mock(Util.class);
    }

    @Bean
    public MyClass myClass() {
      return new MyClass(mockUtil());
    }
  }
}

如果您不想依赖Spring进行测试（以进一步加快速度），您可以自己通过构造函数注入或通过

Whitebox.setInternalState（sut，“fieldName”，mockObject）注入依赖项或弹簧<代码>ReflectionUtils.setField（sut，“fieldName”，mockObject）

import org.junit.Test;
import org.mockito.internal.util.reflection.Whitebox;

import java.util.UUID;

import javax.annotation.Resource;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.powermock.api.mockito.PowerMockito.when;

public class MockTest4 {

  @Test
  public void test() {

    Util mockUtil = mock(Util.class);
    MyClass sut = new MyClass(mockUtil);

//    MyClass sut = new MyClass();
//    Whitebox.setInternalState(sut, "util", mockUtil);

    UUID uuidLocal = UUID.randomUUID();
    when(mockUtil.generateUUID()).thenReturn(uuidLocal);

    assertThat(sut.getUUID(), is(equalTo(uuidLocal)));
  }

  private class MyClass {

    @Resource
    private Util util;

    public MyClass() {}
    public MyClass(Util util) {
      this.util = util;
    }

    public UUID getUUID() {
      return util.generateUUID();
    }
  }

  private class Util {

    public UUID generateUUID() {
      return UUID.randomUUID();
    }
  }
}

最后一个测试包含两个选项，构造函数或字段注入，您可以使用它们


由于@hammerfest的评论，我在这里添加了一个进一步的示例，展示了如果
MyClass
是外部定义的，该怎么办。注意：这个例子基本上是在我阅读@ArthurZagretdinov的答案之前，他可能是这个测试的作者（正如@hammerfest在评论中指出的）。首先是独立的
MyClass
实现：

import java.util.UUID;

public class MyClass {

  public UUID getUUID() {
    return UUID.randomUUID();
  }
}

接下来，使用外部
MyClass
定义的测试：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import java.util.UUID;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.when;

@PrepareForTest({ MyClass.class })
@RunWith(PowerMockRunner.class)
public class StaticMockTest3 {

  @Test
  public void test() {
    MyClass sut = new MyClass();

    final String id = "493410b3-dd0b-4b78-97bf-289f50f6e74f";
    UUID uuid = UUID.fromString(id);

    // UUID uuidLocal = UUID.randomUUID();
    mockStatic(UUID.class);
    when(UUID.randomUUID()).thenReturn(uuidLocal);
    // when(UUID.randomUUID()).thenReturn(uuidLocal);

    assertThat(sut.getUUID().toString(), is(equalTo(uuid.toString())));
  }
}

如果您在上面的cenario中注释掉了两个注释行，您将发现由于UUID不相等，测试将失败。这意味着
MyClass
的准备工作也尊重使用声明的UUID mock，因此可以用于模拟静态类。
模拟系统类的常见错误是将它们添加到
@PrepareForTest
，但不幸的是，无法直接模拟最终的Java系统类。但是PowerMock提供了。PowerMock通过调用PowerMock类来替换对系统类的调用。应将使用最终系统类的类添加到
@PrepareForTest

我已经添加了如何模拟UUID

public class DocumentService {

  public JsonDocument saveDocument(JsonDocument document){
    UUID uuid = UUID.randomUUID();
    document.setId(uuid.toString());
    return document;
  }
}

试验

您可以在中找到更多信息。
@JarrodRoberson这不是dup，因为链接的问题是问“如何使用UUID进行单元测试”。在我的案例中，我明确表示，我尝试了该问题的公认答案，该答案导致我的测试失败，我问的是一个特殊的问题，而不是一般性的问题。与我的示例相比，本质上的区别似乎是，您已经将MyClass作为测试本身的一个内部类。这似乎确实有效，但我怀疑OP在现实生活环境中是否也能做到这一点。@hammerfest与其准备UUID进行测试，不如准备MyClass进行该特定情况下的测试。此外，我的答案还包含了如何完全避免PowerMock甚至Spring的方法，这对于测试IMOWell更为可取，因为它不是一个“特殊”的情况，而是一个“真实”的情况，而假设SUT是测试的一个内部类基本上改变了您正在测试的环境；不过，让我们看看这对OP.Btw来说是否可以接受。复制Arthur Zagretdinov答案的精髓（即使UUID值是相同的）而不给他任何荣誉的出色工作。@hammerfest我从github（可能是他的）示例，可以通过您发布的链接访问，在我更新我的帖子之前，我没有读到他的答案。我承认我复制了源代码并对其进行了轻微修改，我的缺点是没有链接到github示例。不过，我这篇文章的实质是有多种方法可以测试UUID（我更喜欢在可能的情况下避免使用PowerMock）。顺便说一句，@RomanVottner，如果将生成UUID提取到单独的类并提供接口，那么就没有理由使用Spring或WhiteBox类。Mockito有
InjectMocks
，EasyMock有
TestSubject
用于这些目的。这一个似乎有效，并且由于您是PowerMock的贡献者，我假设这是预期的解决方案。我不明白的是，你链接的2009年文章显然来自同一位作者，他随后宣布“不可能解决”，并在我链接的2015年github票证中提出了所有0解决方案。还是我误解了什么？你链接的票证是在2015年从Google Source导入GitHub的。但无论如何，它是创建和回答后，然后张贴。我认为，这是误解。正如您可以从示例中看到的，它现在起作用了。
@RunWith(PowerMockRunner.class)
@PrepareForTest(DocumentService.class)
public class DocumentServiceTest {
@Test
public void should_set_id() throws Exception {
    final String id = "493410b3-dd0b-4b78-97bf-289f50f6e74f";
    UUID uuid = UUID.fromString(id);

    mockStatic(UUID.class);
    when(UUID.randomUUID()).thenReturn(uuid);

    DocumentService documentService = new DocumentService();

    JsonDocument document = new JsonDocument();
    documentService.saveDocument(document);

    assertThat(document.getId())
        .as("Id is set")
        .isEqualTo(id);
  }
}