Java 8的java.time API中的模拟时间

Answers:

72

最接近的东西是Clock物体。您可以使用任意时间（或从系统当前时间开始）创建Clock对象。所有date.time对象都有重载的now方法，这些方法采用时钟对象代替当前时间。因此，您可以使用依赖项注入来注入具有特定时间的Clock：

public class MyBean {
    private Clock clock;  // dependency inject
    ...
    public void process(LocalDate eventDate) {
      if (eventDate.isBefore(LocalDate.now(clock)) {
        ...
      }
    }
  }

有关更多详细信息，请参见Clock JavaDoc。

— dkatzel
source
11
是。特别Clock.fixed是在测试中很有用，而在应用程序中Clock.system或Clock.systemUTC可能会使用。
— Matt Johnson-Pint 2014年
8
遗憾的是，没有一个可变的时钟可以让我将其设置为非计时时间，但以后可以修改该时间（您可以使用joda进行设置）。这对于测试对时间敏感的代码（例如具有基于时间的到期时间的缓存或将来计划事件的类）将很有用。
— bacar 2015年
2
@bacar Clock是抽象类，您可以创建自己的测试Clock实现
— BjarneBoström2016-02-17
我相信这就是我们最终要做的。
— bacar '16
23

我使用了一个新类来隐藏Clock.fixed创建并简化测试：

public class TimeMachine {

    private static Clock clock = Clock.systemDefaultZone();
    private static ZoneId zoneId = ZoneId.systemDefault();

    public static LocalDateTime now() {
        return LocalDateTime.now(getClock());
    }

    public static void useFixedClockAt(LocalDateTime date){
        clock = Clock.fixed(date.atZone(zoneId).toInstant(), zoneId);
    }

    public static void useSystemDefaultZoneClock(){
        clock = Clock.systemDefaultZone();
    }

    private static Clock getClock() {
        return clock ;
    }
}

public class MyClass {

    public void doSomethingWithTime() {
        LocalDateTime now = TimeMachine.now();
        ...
    }
}

@Test
public void test() {
    LocalDateTime twoWeeksAgo = LocalDateTime.now().minusWeeks(2);

    MyClass myClass = new MyClass();

    TimeMachine.useFixedClockAt(twoWeeksAgo);
    myClass.doSomethingWithTime();

    TimeMachine.useSystemDefaultZoneClock();
    myClass.doSomethingWithTime();

    ...
}
— 路易斯·Signorelli
source
4
如果并行运行多个测试并更改TimeMachine时钟，线程安全又如何？
— youri
您必须将时钟传递给被测对象，并在调用与时间相关的方法时使用它。您可以删除该getClock()方法并直接使用该字段。此方法仅添加几行代码。
— 迪蒙
1
银行时间或TimeMachine？
— Emanuele
11

我用了一个领域

private Clock clock;

然后

LocalDate.now(clock);

在我的生产代码中。然后我在单元测试中使用Mockito使用Clock.fixed（）模拟了Clock：

@Mock
private Clock clock;
private Clock fixedClock;

模拟：

fixedClock = Clock.fixed(Instant.now(), ZoneId.systemDefault());
doReturn(fixedClock.instant()).when(clock).instant();
doReturn(fixedClock.getZone()).when(clock).getZone();

断言：

assertThat(expectedLocalDateTime, is(LocalDate.now(fixedClock)));
— 克拉斯·威尔克
source
9

我发现使用Clock混乱的生产代码。

您可以使用JMockit或PowerMock在测试代​​码中模拟静态方法调用。JMockit的示例：

@Test
public void testSth() {
  LocalDate today = LocalDate.of(2000, 6, 1);

  new Expectations(LocalDate.class) {{
      LocalDate.now(); result = today;
  }};

  Assert.assertEquals(LocalDate.now(), today);
}

编辑：在阅读了关于乔恩·斯凯特（Jon Skeet）对类似问题的回答的评论后，我不同意过去的自己。最重要的是，该论点使我确信，在模拟静态方法时不能使测试并行化。

但是，如果必须处理遗留代码，则可以/必须仍然使用静态模拟。

— 斯蒂芬·哈伯尔
source
1
+1表示“对旧代码使用静态模拟”。因此，对于新代码，应鼓励依赖注入并注入一个Clock（用于测试的固定Clock，用于生产运行时的系统Clock）。
— David Groomes
1

我需要LocalDate实例而不是LocalDateTime。
因此，我创建了以下实用程序类：

public final class Clock {
    private static long time;

    private Clock() {
    }

    public static void setCurrentDate(LocalDate date) {
        Clock.time = date.toEpochDay();
    }

    public static LocalDate getCurrentDate() {
        return LocalDate.ofEpochDay(getDateMillis());
    }

    public static void resetDate() {
        Clock.time = 0;
    }

    private static long getDateMillis() {
        return (time == 0 ? LocalDate.now().toEpochDay() : time);
    }
}

用法如下：

class ClockDemo {
    public static void main(String[] args) {
        System.out.println(Clock.getCurrentDate());

        Clock.setCurrentDate(LocalDate.of(1998, 12, 12));
        System.out.println(Clock.getCurrentDate());

        Clock.resetDate();
        System.out.println(Clock.getCurrentDate());
    }
}

输出：

2019-01-03
1998-12-12
2019-01-03

将所有创建替换LocalDate.now()为Clock.getCurrentDate()项目中的。

因为它是spring boot应用程序。在test执行配置文件之前，只需为所有测试设置一个预定义的日期：

public class TestProfileConfigurer implements ApplicationListener<ApplicationPreparedEvent> {
    private static final LocalDate TEST_DATE_MOCK = LocalDate.of(...);

    @Override
    public void onApplicationEvent(ApplicationPreparedEvent event) {
        ConfigurableEnvironment environment = event.getApplicationContext().getEnvironment();
        if (environment.acceptsProfiles(Profiles.of("test"))) {
            Clock.setCurrentDate(TEST_DATE_MOCK);
        }
    }
}

并添加到spring.factories：

org.springframework.context.ApplicationListener = com.init.TestProfileConfigurer

— catch23
source
1

这是一种使用EasyMock在Java 8 Web应用程序中将当前系统时间覆盖到特定日期以进行JUnit测试的一种工作方法

Joda Time确实不错（谢谢Stephen，Brian，您使我们的世界变得更好了），但是我不允许使用它。

经过一些试验，我最终想出了一种使用EasyMock在Java 8的java.time API中将时间模拟到特定日期的方法。

  • 没有Joda Time API
  • 没有PowerMock。

这是需要做的：

在经过测试的课程中需要做什么

步骤1

java.time.Clock向测试的类中添加新属性，MyService并确保使用实例化块或构造函数将新属性正确初始化为默认值：

import java.time.Clock;
import java.time.LocalDateTime;

public class MyService {
  // (...)
  private Clock clock;
  public Clock getClock() { return clock; }
  public void setClock(Clock newClock) { clock = newClock; }

  public void initDefaultClock() {
    setClock(
      Clock.system(
        Clock.systemDefaultZone().getZone() 
        // You can just as well use
        // java.util.TimeZone.getDefault().toZoneId() instead
      )
    );
  }
  { initDefaultClock(); } // initialisation in an instantiation block, but 
                          // it can be done in a constructor just as well
  // (...)
}

第2步

将新属性clock注入到需要当前日期时间的方法中。例如，在我的情况下，我必须检查数据库中存储的日期是否发生在之前LocalDateTime.now()，然后替换为LocalDateTime.now(clock)，如下所示：

import java.time.Clock;
import java.time.LocalDateTime;

public class MyService {
  // (...)
  protected void doExecute() {
    LocalDateTime dateToBeCompared = someLogic.whichReturns().aDate().fromDB();
    while (dateToBeCompared.isBefore(LocalDateTime.now(clock))) {
      someOtherLogic();
    }
  }
  // (...) 
}

测试班需要做什么

第三步

在测试类中，创建一个模拟时钟对象，并在调用被测试方法之前将其注入到测试类的实例中doExecute()，然后立即将其重置，如下所示：

import java.time.Clock;
import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import org.junit.Test;

public class MyServiceTest {
  // (...)
  private int year = 2017;  // Be this a specific 
  private int month = 2;    // date we need 
  private int day = 3;      // to simulate.

  @Test
  public void doExecuteTest() throws Exception {
    // (...) EasyMock stuff like mock(..), expect(..), replay(..) and whatnot
 
    MyService myService = new MyService();
    Clock mockClock =
      Clock.fixed(
        LocalDateTime.of(year, month, day, 0, 0).toInstant(OffsetDateTime.now().getOffset()),
        Clock.systemDefaultZone().getZone() // or java.util.TimeZone.getDefault().toZoneId()
      );
    myService.setClock(mockClock); // set it before calling the tested method
 
    myService.doExecute(); // calling tested method 

    myService.initDefaultClock(); // reset the clock to default right afterwards with our own previously created method

    // (...) remaining EasyMock stuff: verify(..) and assertEquals(..)
    }
  }

在调试模式下进行检查，您会看到2017年2月3日的日期已正确注入myService实例并在比较指令中使用，然后使用正确地将其重置为当前日期initDefaultClock()。

— 基里·萨科
source
0

这个示例甚至展示了如何结合使用Instant和LocalTime（有关转换问题的详细说明）

被测课程

import java.time.Clock;
import java.time.LocalTime;

public class TimeMachine {

    private LocalTime from = LocalTime.MIDNIGHT;

    private LocalTime until = LocalTime.of(6, 0);

    private Clock clock = Clock.systemDefaultZone();

    public boolean isInInterval() {

        LocalTime now = LocalTime.now(clock);

        return now.isAfter(from) && now.isBefore(until);
    }

}

Groovy测试

import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.Parameterized

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

import static java.time.ZoneOffset.UTC
import static org.junit.runners.Parameterized.Parameters

@RunWith(Parameterized)
class TimeMachineTest {

    @Parameters(name = "{0} - {2}")
    static data() {
        [
            ["01:22:00", true,  "in interval"],
            ["23:59:59", false, "before"],
            ["06:01:00", false, "after"],
        ]*.toArray()
    }

    String time
    boolean expected

    TimeMachineTest(String time, boolean expected, String testName) {
        this.time = time
        this.expected = expected
    }

    @Test
    void test() {
        TimeMachine timeMachine = new TimeMachine()
        timeMachine.clock = Clock.fixed(Instant.parse("2010-01-01T${time}Z"), UTC)
        def result = timeMachine.isInInterval()
        assert result == expected
    }

}
— 戏ter
source
0

在PowerMockito的帮助下进行弹簧启动测试，您可以模拟ZonedDateTime。您需要以下内容。

注解

在测试类上，您需要准备使用的服务ZonedDateTime。

@RunWith(PowerMockRunner.class)
@PowerMockRunnerDelegate(SpringRunner.class)
@PrepareForTest({EscalationService.class})
@SpringBootTest
public class TestEscalationCases {
  @Autowired
  private EscalationService escalationService;
  //...
}

测试用例

在测试中，您可以准备所需的时间，并根据方法调用获得时间。

  @Test
  public void escalateOnMondayAt14() throws Exception {
    ZonedDateTime preparedTime = ZonedDateTime.now();
    preparedTime = preparedTime.with(DayOfWeek.MONDAY);
    preparedTime = preparedTime.withHour(14);
    PowerMockito.mockStatic(ZonedDateTime.class);
    PowerMockito.when(ZonedDateTime.now(ArgumentMatchers.any(ZoneId.class))).thenReturn(preparedTime);
    // ... Assertions 
}
— 帕斯夸莱
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.