基于Mockito的解决方案，其中代码使用普通的Instant.now()

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.MockedStatic;

import java.time.Clock;
import java.time.Instant;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;

public class MockInstantTest {

  private MockedStatic<Clock> clockMock;

  @BeforeEach
  public void setup() {
    mockInstant(1640000000); // set desired return value 2021-12-20T11:33:20Z
  }

  @AfterEach
  public void destroy() {
    clockMock.close();
  }

  private void mockInstant(long expected) {
    Clock spyClock = spy(Clock.class);
    clockMock = mockStatic(Clock.class);
    clockMock.when(Clock::systemUTC).thenReturn(spyClock);
    when(spyClock.instant()).thenReturn(Instant.ofEpochSecond(expected));
  }

  @Test
  void testWithMockedIstant() {
    // invoking Instant.now() will always return the same value
    assertThat(Instant.now().toString()).isEqualTo("2021-12-20T11:33:20Z");
  }
}

解决方案说明

解决方案依赖于Instant.now()调用Clock.systemUTC().instant()这一事实

• Clock是抽象的，因此我们可以监视非静态方法
• 模拟clock.instant()以返回所需的值
• Clock.systemUTC()是静态的，所以我们需要mockStatic
• 关闭MockedStatic需要使用@Before/@After（或者您可以使用try(MockedStatic<Clock> clockMock = mockStatic(Clock.class)) {...}）

你可以声明一个返回ZoneDateTime的函数：

public ZoneDateTime getCurrentTime () {
    return Instant.now().atZone(ZoneId.of(AMERICA_NEW_YORK));
}

并将该函数的结果分配给current字段：

ZonedDateTime current = getCurrentTime();

现在你可以简单地使用Mockito framework将其替换为所需的值：

doReturn(yourValue).when(yourObject).getCurrentTime();

使用Mockito时，您可以轻松地模仿如下：

ZoneId zoneId = ZoneId.of("America/New_York");
    ZonedDateTime current = ZonedDateTime.now(zoneId);
    Timestamp timestamp = Timestamp.from(Instant.now());
   
    when(timestamp.toInstant()).thenReturn(Instant.from(current));

添加超时测试示例：

@Test
public void testForTimeout() throws InterruptedException {

    ZoneId zoneId = ZoneId.of("America/New_York");
    ZonedDateTime current = ZonedDateTime.now(zoneId);
    Timestamp timestampBeforeCall = Timestamp.from(Instant.now());

    // Call Class.method() or here instead we just introduce an artificial wait time :
    Thread.sleep(3000);

    Timestamp timestampAfterCall = Timestamp.from(Instant.now());
    long timeoutInMilliseconds = 2000;
    long diff = timestampAfterCall.getTime() - timestampBeforeCall.getTime();
    log.info(String.valueOf(diff));
    if(diff > timeoutInMilliseconds) {
        log.error("Call Timed Out!");
    }
}

这里有一个与Java 17一起工作的解决方案，利用Mockito的静态mocking及其CALLS_REAL_METHODS选项来避免mocking所有Instant的静态方法。

var clock = Clock.fixed(Instant.now().minus(10, ChronoUnit.MINUTES), ZoneOffset.UTC);
ClockUtil.setClock(clock);
var mockedInstant = Instant.now(clock);
MockedStatic<Instant> mockedStatic = mockStatic(Instant.class, Mockito.CALLS_REAL_METHODS);
mockedStatic.when(Instant::now).thenReturn(mockedInstant);