Java8のjava.timeAPIでのモックタイム

回答:

72

最も近いのはClockオブジェクトです。Clockオブジェクトは、いつでも（またはシステムの現在の時刻から）使用して作成できます。すべてのdate.timenowオブジェクトには、現在の時刻の代わりに時計オブジェクトを受け取るオーバーロードされたメソッドがあります。したがって、依存性注入を使用して、特定の時刻で時計を注入できます。

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

詳細については、ClockJavaDocを参照してください。

— dkatzel
ソース
11
はい。特に、アプリケーションで使用されているClock.fixed間、Clock.systemまたはClock.systemUTC使用される可能性があるテストで役立ちます。
— マットジョンソン-パイント2014年
8
刻みのない時間に設定できる可変時計がないのは残念ですが、後でその時間を変更します（これはjodaで行うことができます）。これは、時間に敏感なコードをテストする場合に役立ちます。たとえば、時間ベースの有効期限を持つキャッシュや、将来のイベントをスケジュールするクラスなどです。
— bacar 2015
2
抽象クラスであり、あなたがあなた自身のテストクロック実装を作成することができ@bacar時計
— Bjarneボストロム
それが私たちがやったことだと思います。
— bacar 2016
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();

    ...
}
— LuizSignorelli
ソース
4
複数のテストを並行して実行し、TimeMachineクロックを変更する場合、スレッドセーフはどうですか？
— youri 2016年
テストされたオブジェクトに時計を渡し、時間関連のメソッドを呼び出すときにそれを使用する必要があります。また、getClock()メソッドを削除して、フィールドを直接使用することもできます。このメソッドは、数行のコードしか追加しません。
— デーモン2017年
1
BanktimeまたはTimeMachine？
— エマヌエーレ
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)));
— クラースウィルケ
ソース
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);
}

編集：ここSOで同様の質問に対するジョンスキートの答えに関するコメントを読んだ後、私は私の過去の自己に同意しません。何よりも、静的メソッドをモックするときにテストをパラライズすることはできないと私は確信しました。

ただし、レガシーコードを処理する必要がある場合は、静的モックを使用できます/使用する必要があります。

— ステファン・ハーバー
ソース
1
「レガシーコードに静的モックを使用する」コメントの+1。したがって、新しいコードの場合は、依存性注入に傾倒してクロックを注入することをお勧めします（テスト用の固定クロック、本番ランタイム用のシステムクロック）。
— David Groomes 2018
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()プロジェクト内に。

スプリングブートアプリケーションですので。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
ソース
1

EasyMockを使用したJava8 Webアプリケーションで、JUnitテストの目的で、現在のシステム時刻を特定の日付にオーバーライドする作業方法を次に示します。

Joda Timeは確かに素晴らしいです（Stephen、Brian、あなたは私たちの世界をより良い場所にしてくれました）が、私はそれを使用することを許可されませんでした。

いくつかの実験の後、私は最終的に、EasyMockを使用してJava8のjava.timeAPIで特定の日付に時間をモックする方法を思いつきました。

  • Joda TimeAPIなし
  • 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();
    }
  }
  // (...) 
}

テストクラスで何をする必要があるか

ステップ3

テストクラスで、モッククロックオブジェクトを作成し、テスト済みメソッドを呼び出す直前にテスト済みクラスのインスタンスに挿入し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()。

— キリサコウ
ソース
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
    }

}
— banterCZ
ソース
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 
}
— パスクアーレ
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.