Question

在我的测试用例中，我需要测试时间敏感方法，在该方法中我们使用java 8类LocalDate，它是而不是Joda 。

当我正在运行测试时，我该怎么做才能改变时间

Answer 1

在您的代码中，将LocalDate.now()替换为LocalDate.now(clock);。

然后，您可以传递Clock.systemDefaultZone()进行制作，并a fixed clock进行测试。

这是一个例子：

首先，注入Clock。如果您使用的是弹簧靴，请执行以下操作：

@Bean
public Clock clock() {
    return Clock.systemDefaultZone();
}

其次，在代码中调用LocalDate.now(clock)：

@Component
public class SomeClass{

    @Autowired
    private Clock clock;

    public LocalDate someMethod(){
         return LocalDate.now(clock);
    }
}

现在，在单元测试类中：

// Some fixed date to make your tests
private final static LocalDate LOCAL_DATE = LocalDate.of(1989, 01, 13);

// mock your tested class
@InjectMocks
private SomeClass someClass;

//Mock your clock bean
@Mock
private Clock clock;

//field that will contain the fixed clock
private Clock fixedClock;


@Before
public void initMocks() {
    MockitoAnnotations.initMocks(this);

    //tell your tests to return the specified LOCAL_DATE when calling LocalDate.now(clock)
    fixedClock = Clock.fixed(LOCAL_DATE.atStartOfDay(ZoneId.systemDefault()).toInstant(), ZoneId.systemDefault());
    doReturn(fixedClock.instant()).when(clock).instant();
    doReturn(fixedClock.getZone()).when(clock).getZone();
}

@Test
public void testSomeMethod(){
    // call the method to test
    LocalDate returnedLocalDate = someClass.someMethod();

    //assert
    assertEquals(LOCAL_DATE, returnedLocalDate);

}

Answer 2

您可以重构代码以使其对测试友好，例如，通过调用某些自定义可模拟非静态类的方法替换LocalDate.now()的所有调用。

或者，您可以使用PowerMock's mockStatic。

Answer 3

您可能还希望在生产中传递固定时钟（其值在事务开始时固定）以避免使用不一致的＆＃34;现在＆＃34;在不同的实体和请求中。有关详细信息，请参阅this question。

Answer 4

如果我们需要模拟像now（）这样的静态方法，我们可以使用多种选择，例如PowerMock：

@RunWith(PowerMockRunner.class)
@PrepareForTest({ LocalDateTime.class })
public class LocalDateTimeUnitTest {

    @Test
    public void givenLocalDateTimeMock_whenNow_thenGetFixedLocalDateTime() {
        Clock clock = Clock.fixed(Instant.parse("2014-12-22T10:15:30.00Z"), ZoneId.of("UTC"));
        LocalDateTime dateTime = LocalDateTime.now(clock);
        mockStatic(LocalDateTime.class);
        when(LocalDateTime.now()).thenReturn(dateTime);
        String dateTimeExpected = "2014-12-22T10:15:30";

        LocalDateTime now = LocalDateTime.now();

        assertThat(now).isEqualTo(dateTimeExpected);
    }
}

或者JMockit，实际上，通过JMockit，我们可以使用MockUp类：

@Test
public void givenLocalDateTimeWithJMock_whenNow_thenGetFixedLocalDateTime() {
    Clock clock = Clock.fixed(Instant.parse("2014-12-21T10:15:30.00Z"), ZoneId.of("UTC"));
    new MockUp<LocalDateTime>() {
        @Mock
        public LocalDateTime now() {
            return LocalDateTime.now(clock);
        }
    };
    String dateTimeExpected = "2014-12-21T10:15:30";

    LocalDateTime now = LocalDateTime.now();

    assertThat(now).isEqualTo(dateTimeExpected);
}

或Expectations类：

@Test
public void givenLocalDateTimeWithExpectations_whenNow_thenGetFixedLocalDateTime() {
    Clock clock = Clock.fixed(Instant.parse("2014-12-23T10:15:30.00Z"), ZoneId.of("UTC"));
    LocalDateTime dateTimeExpected = LocalDateTime.now(clock);
    new Expectations(LocalDateTime.class) {
        {
            LocalDateTime.now();
            result = dateTimeExpected;
        }
    };

    LocalDateTime now = LocalDateTime.now();

    assertThat(now).isEqualTo(dateTimeExpected);
}

我们可以找到更多示例here。

另一个简单的选择是将now()方法与固定的Clock实例一起使用。 当然，java.time包中的大多数类都具有带有Clock参数的now（）方法：

@Test
public void givenFixedClock_whenNow_thenGetFixedLocalDateTime() {
    Clock clock = Clock.fixed(Instant.parse("2014-12-22T10:15:30.00Z"), ZoneId.of("UTC"));
    String dateTimeExpected = "2014-12-22T10:15:30";

    LocalDateTime dateTime = LocalDateTime.now(clock);

    assertThat(dateTime).isEqualTo(dateTimeExpected);
}

Answer 5

使用Spring：

ClockConfiguration类：

@Configuration
public class ClockConfiguration {
    private final static LocalDate LOCAL_DATE = LocalDate.of(2019, 12, 17);

    @Bean
    @ConditionalOnMissingBean
    Clock getSystemDefaultZoneClock() {
        return Clock.systemDefaultZone();
    }

    @Bean
    @Profile("test")
    @Primary
    Clock getFixedClock() {
        return Clock.fixed(LOCAL_DATE.atStartOfDay(ZoneId.systemDefault()).toInstant(), ZoneId.systemDefault());
    }
}

SomeService类：

@Service
@RequiredArgsConstructor
public class SomeService {

    private final Clock clock;

    public void someMethod(){
        ...

        LocalDateTime.now(clock)
        LocalDate.now(clock)

        ...
    }
}

您必须在测试中拥有有效的“测试”资料：

SomeServiceTest类：

@ActiveProfiles("test")
@EnableConfigurationProperties
@SpringBootTest(classes = [YourAppMainClass])
class SomeServiceTest {
    ...
}

Answer 6

您可以简单地将当前日期作为函数参数传递。

fun doSmthng(now: LocalDate = LocalDate.now()) {
    testAnotherService.doSmthng1(TestObj("my message!", now))
}

在测试中，您可以通过一些特定的日期并声明日期。想法是注入依赖关系，而不是在函数主体中显式创建。

Answer 7

您可以在您要测试的班级内部使用供应商，以在使用日期时间的任何地方传递当前时间。

public Supplier<LocalDateTime> localDateTime = () -> LocalDateTime.now();

，并且在测试方法中只需覆盖其值即可：

myClassObj.localDateTime = () -> LocalDateTime.parse("2020-11-24T23:59:59.999");

Answer 8

我们必须在这里模拟一个静态方法。我使用以下依赖项。记住我们所有的测试代码都必须在 try 块中。只要我们调用 LocalDate.now() 或 LocalDate

<!-- https://mvnrepository.com/artifact/org.mockito/mockito-inline -->
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-inline</artifactId>
    <version>3.11.0</version>
    <scope>test</scope>
</dependency>

代码：

 @Test
    void verifykNonLeapYear() {

        LocalDate currentLocalDate = LocalDate.of(2010, 2, 13);
        try (MockedStatic<LocalDate> topDateTimeUtilMock = Mockito.mockStatic(LocalDate.class)) {
            topDateTimeUtilMock.when(() -> LocalDate.now()).thenReturn(currentLocalDate);
            assertThat(TopDateTimeUtil.numberOfDaysInCurrentYear(), is(365));
        }
    }

我怎么能模拟java.time.LocalDate.now（）

8 个答案: