(Java) 타임머신을 타고 시간 여행 떠나기

public class App {
    // 테스트 하기 어렵게 하기 위해서 일부러 메소드가 메소드를 계속해서 호출하는 형태로 작성함.
    // 현재 시간이 오전인지 알아내는 메소드
    public static boolean isAM() {
        return method();
    }

    private static boolean method() {
        return method2();
    }

    private static boolean method2() {
        return method3();
    }

    private static boolean method3() {
        return LocalTime.now().isBefore(LocalTime.of(12, 0));
    }
}

public class AppTest {
    @Test
    public void testAm() {
        // 이 테스트는 오전에는 통과하고 오후에는 깨지는 테스트가 된다.
        assertTrue(App.isAM());
    }
}

public class App {
    public static boolean isAM(LocalTime now) {
        return method(now);
    }

    private static boolean method(LocalTime now) {
        return method2(now);
    }

    private static boolean method2(LocalTime now) {
        return method3(now);
    }

    private static boolean method3(LocalTime now) {
        return now.isBefore(LocalTime.of(12, 0));
    }
}

public class AppTest {
    @Test
    public void testAm() {
        assertTrue(App.isAM(LocalTime.of(11, 59)));
    }
}

public static LocalDateTime now() {
    return now(Clock.systemDefaultZone());
}
public static LocalDateTime now(Clock clock) {
    Objects.requireNonNull(clock, "clock");
    final Instant now = clock.instant();  // called once
    ZoneOffset offset = clock.getZone().getRules().getOffset(now);
    return ofEpochSecond(now.getEpochSecond(), now.getNano(), offset);
}
public static LocalDateTime ofEpochSecond(long epochSecond, int nanoOfSecond, ZoneOffset offset) {
    Objects.requireNonNull(offset, "offset");
    NANO_OF_SECOND.checkValidValue(nanoOfSecond);
    long localSecond = epochSecond + offset.getTotalSeconds();  // overflow caught later
    long localEpochDay = Math.floorDiv(localSecond, SECONDS_PER_DAY);
    int secsOfDay = (int)Math.floorMod(localSecond, SECONDS_PER_DAY);
    LocalDate date = LocalDate.ofEpochDay(localEpochDay);
    LocalTime time = LocalTime.ofNanoOfDay(secsOfDay * NANOS_PER_SECOND + nanoOfSecond);
    return new LocalDateTime(date, time);
}

public class TimeMachine {
    // 디폴트로 운영체제에 설정된 타임존과 시간을 기준으로 Clock을 반환한다.
    private static Clock clock = Clock.systemDefaultZone();

    // Clock을 모킹할 때 쓸 timezone인데 이 포스트에서는 timezone을 뛰어넘은 모킹은 다루지 않으므로 운영체제에 설정된 UTC 타임존을 사용하겠다.
    private static ZoneOffset zoneOffset = ZoneOffset.UTC;

    // 내가 모킹한, 혹은 현재 시간을 가진 Clock 인스턴스를 가지고 현재 시간을 구하게 된다.
    public static LocalDateTime dateTimeOfNow() {
        return LocalDateTime.now(clock);
    }

    public static LocalTime timeOfNow() {
        return LocalTime.now(clock);
    }

    public static LocalDate dateOfNow() {
        return LocalDate.now(clock);
    }

    // 지정한 날짜/시간으로 현재 시간을 고정시킨다.
    public static void timeTravelAt(LocalDateTime dateTime){
        clock = Clock.fixed(dateTime.atOffset(zoneOffset).toInstant(), zoneOffset);
    }

    public static void timeTravelAt(LocalTime time) {
        // 여기서 중요한 건 시간이고 날짜는 중요치 않다.
        clock = Clock.fixed(time.atDate(LocalDate.now()).atOffset(zoneOffset).toInstant(), zoneOffset);
    }

    public static void timeTravelAt(LocalDate date) {
        // 여기서 중요한 건 날짜고 시간은 중요치 않다.
        clock = Clock.fixed(date.atStartOfDay().atOffset(zoneOffset).toInstant(), zoneOffset);
    }

    // 모킹한 현재 시간을 다시 원래 현재 시간으로 되돌리는 메소드이다.
    public static void reset() {
        clock = Clock.systemDefaultZone();
    }
}

public class ClockTest {
    @Test
    public void testFixedClock() {
        // 2011년 1월 1일 1시 1분 0초
        LocalDateTime dateTime = LocalDateTime.of(2011, 1, 1, 1, 1);

        // UTC +09:00 서울/도쿄 기준 2011년 1월 1일 1시 1분 0초
        Instant instant = dateTime.atOffset(ZoneOffset.ofHours(9)).toInstant();

        // UTC +09:00 2011년 1월 1일 1시 1분 0초를 UTC ±00:00 기준으로 변환한 Clock
        Clock fixedClock = Clock.fixed(instant, ZoneOffset.ofHours(0));

        // UTC +09:00 기준의 시간을 UTC ±00:00 기준의 시간으로 변경했으므로 9시간만 빼면 된다.
        assertThat(LocalDateTime.now(fixedClock), is(LocalDateTime.of(2010, 12, 31, 16, 1)));
    }
}

public class App {
    public static boolean isAM() {
        return method();
    }

    private static boolean method() {
        return method2();
    }

    private static boolean method2() {
        return method3();
    }

    private static boolean method3() {
        return TimeMachine.timeOfNow().isBefore(LocalTime.of(12, 0));
    }
}

public class AppTest {
    @Test
    public void testAm() {
        TimeMachine.timeTravelAt(LocalTime.of(11, 59));
        assertTrue(App.isAM());
        assertThat(TimeMachine.timeOfNow(), not(LocalTime.now()));

        TimeMachine.timeTravelAt(LocalTime.of(12, 59));
        assertFalse(App.isAM());
        assertThat(TimeMachine.timeOfNow(), not(LocalTime.now()));

        TimeMachine.reset();
        assertThat(TimeMachine.timeOfNow(), is(LocalTime.now()));
    }
}