Tutorial
타임스탬프 테스트 전략: 전체 가이드
소개
시간 의존적인 코드를 테스트하는 것은 매우 어렵습니다. 시간은 지속적으로 흐르고, 시간대는 변경되며, DST 전환과 같은 극단적인 경우는 복잡한 시나리오를 만듭니다. 이 튜토리얼에서는 시간 모의, 엣지 케이스 테스트, 시간대 전반의 안정성 보장 등 타임스탬프 관련 코드를 테스트하기 위한 포괄적인 전략을 제공합니다.
타임스탬프 테스트가 어려운 이유
주요 과제
- 시간은 계속 움직입니다 - 서로 다른 시간에 테스트를 실행하면 서로 다른 결과가 생성됩니다.
- 시간대 복잡성 - DST 전환, 오프셋 변경, 과거 시간대 데이터
- 특정 사례 - 윤초, 연도 경계, 유효하지 않은 날짜
- 비동기 작업 - 타이머, 지연 및 시간 종속 부작용
- 환경 종속성 - 시스템 시간대, 로케일 설정
일반적인 문제
// ❌ Non-deterministic test - fails at certain times
test('event is in the future', () => {
const event = new Date('2024-12-31T23:59:59Z');
expect(event > new Date()).toBe(true); // Fails after Dec 31, 2024!
});
// ❌ Timezone-dependent test - fails in different timezones
test('gets current day', () => {
const day = new Date().getDay();
expect(day).toBe(2); // Only passes on Tuesdays in local timezone!
});
전략 1: 모의 시간
Jest를 사용한 JavaScript
설치 종속성:
npm install --save-dev jest @sinonjs/fake-timers
기본 시간 조롱
describe('Timestamp Tests with Mocked Time', () => {
beforeEach(() => {
// Set fake time to a fixed date
jest.useFakeTimers();
jest.setSystemTime(new Date('2024-01-15T12:00:00Z'));
});
afterEach(() => {
jest.useRealTimers();
});
test('getCurrentTimestamp returns mocked time', () => {
const timestamp = Date.now();
expect(timestamp).toBe(new Date('2024-01-15T12:00:00Z').getTime());
});
test('time advances with runTimersToTime', () => {
const start = Date.now();
jest.advanceTimersByTime(1000); // Advance 1 second
const end = Date.now();
expect(end - start).toBe(1000);
});
});
고급: 예약된 작업 테스트
function scheduleReport(callback, delayMs) {
setTimeout(() => {
const timestamp = new Date().toISOString();
callback({ timestamp, report: 'Generated' });
}, delayMs);
}
test('schedules report correctly', () => {
jest.useFakeTimers();
jest.setSystemTime(new Date('2024-01-15T12:00:00Z'));
const callback = jest.fn();
scheduleReport(callback, 5000);
// Fast-forward time
jest.advanceTimersByTime(5000);
expect(callback).toHaveBeenCalledWith({
timestamp: '2024-01-15T12:00:05.000Z',
report: 'Generated'
});
jest.useRealTimers();
});
pytest와 Freezegun을 사용하는 Python
설치 종속성:
pip install pytest freezegun
기본 시간 동결
import pytest
from datetime import datetime
from freezegun import freeze_time
@freeze_time("2024-01-15 12:00:00")
def test_current_timestamp():
"""Test with frozen time."""
now = datetime.now()
assert now.year == 2024
assert now.month == 1
assert now.day == 15
assert now.hour == 12
@freeze_time("2024-01-15 12:00:00")
def test_timestamp_calculation():
"""Test calculations with frozen time."""
from datetime import timedelta
now = datetime.now()
future = now + timedelta(hours=1)
assert future.hour == 13
assert (future - now).total_seconds() == 3600
시간 여행 테스트
from freezegun import freeze_time
from datetime import datetime, timedelta
def test_time_travel():
"""Test by moving through time."""
initial_time = datetime(2024, 1, 15, 12, 0, 0)
with freeze_time(initial_time) as frozen_time:
assert datetime.now() == initial_time
# Move forward 1 hour
frozen_time.move_to(initial_time + timedelta(hours=1))
assert datetime.now().hour == 13
# Move forward 1 day
frozen_time.move_to(initial_time + timedelta(days=1))
assert datetime.now().day == 16
시간 인터페이스를 활용하세요
Go에서는 테스트 가능한 시간 코드에 종속성 주입을 사용합니다.
package timeutil
import "time"
// TimeProvider interface allows mocking
type TimeProvider interface {
Now() time.Time
}
// RealTime uses actual system time
type RealTime struct{}
func (RealTime) Now() time.Time {
return time.Now()
}
// MockTime allows setting fixed time
type MockTime struct {
CurrentTime time.Time
}
func (m *MockTime) Now() time.Time {
return m.CurrentTime
}
// EventScheduler uses TimeProvider
type EventScheduler struct {
timer TimeProvider
}
func (es *EventScheduler) IsEventInFuture(eventTime time.Time) bool {
return eventTime.After(es.timer.Now())
}
// Test file
func TestEventScheduler(t *testing.T) {
mockTime := &MockTime{
CurrentTime: time.Date(2024, 1, 15, 12, 0, 0, 0, time.UTC),
}
scheduler := &EventScheduler{timer: mockTime}
futureEvent := time.Date(2024, 1, 15, 13, 0, 0, 0, time.UTC)
pastEvent := time.Date(2024, 1, 15, 11, 0, 0, 0, time.UTC)
if !scheduler.IsEventInFuture(futureEvent) {
t.Error("Future event should be in future")
}
if scheduler.IsEventInFuture(pastEvent) {
t.Error("Past event should not be in future")
}
}
전략 2: DST 전환 테스트
스프링 포워드 테스트
import { zonedTimeToUtc, utcToZonedTime } from 'date-fns-tz';
describe('DST Spring Forward Tests', () => {
test('handles missing hour correctly', () => {
// March 10, 2024, 2:00 AM doesn't exist in New York
const timezone = 'America/New_York';
// Try to create 2:30 AM (missing hour)
const missingHour = new Date('2024-03-10T02:30:00');
const utcTime = zonedTimeToUtc(missingHour, timezone);
const localTime = utcToZonedTime(utcTime, timezone);
// Should be adjusted to 3:30 AM
expect(localTime.getHours()).toBe(3);
expect(localTime.getMinutes()).toBe(30);
});
test('duration calculation on spring forward day', () => {
const start = new Date('2024-03-10T00:00:00-05:00'); // EST
const end = new Date('2024-03-10T23:59:59-04:00'); // EDT
const hours = (end - start) / 3600000;
expect(hours).toBeCloseTo(23, 0); // Day is only 23 hours
});
});
폴백 테스트
import pytest
import pytz
from datetime import datetime
def test_fall_back_duplicate_hour():
"""Test handling of duplicate hour during fall back."""
ny_tz = pytz.timezone('America/New_York')
# November 3, 2024, 1:30 AM occurs twice
# First occurrence (EDT)
first = ny_tz.localize(datetime(2024, 11, 3, 1, 30), is_dst=True)
# Second occurrence (EST)
second = ny_tz.localize(datetime(2024, 11, 3, 1, 30), is_dst=False)
# Should be 1 hour apart
diff = (second - first).total_seconds()
assert diff == 3600 # 1 hour
def test_fall_back_day_duration():
"""Test that fall back day is 25 hours."""
ny_tz = pytz.timezone('America/New_York')
start = ny_tz.localize(datetime(2024, 11, 3, 0, 0, 0))
end = ny_tz.localize(datetime(2024, 11, 3, 23, 59, 59))
duration_hours = (end - start).total_seconds() / 3600
assert duration_hours > 24 # Day is longer than 24 hours
전략 3: 시간대 변환 테스트
매개변수화된 테스트
import pytest
import pytz
from datetime import datetime
@pytest.mark.parametrize("utc_time,timezone,expected_hour", [
("2024-01-15 12:00:00", "America/New_York", 7), # EST: UTC-5
("2024-01-15 12:00:00", "Europe/London", 12), # GMT: UTC+0
("2024-01-15 12:00:00", "Asia/Tokyo", 21), # JST: UTC+9
("2024-01-15 12:00:00", "Australia/Sydney", 23), # AEDT: UTC+11
])
def test_timezone_conversion(utc_time, timezone, expected_hour):
"""Test UTC to timezone conversion."""
utc = pytz.UTC
tz = pytz.timezone(timezone)
dt_utc = datetime.strptime(utc_time, "%Y-%m-%d %H:%M:%S").replace(tzinfo=utc)
dt_local = dt_utc.astimezone(tz)
assert dt_local.hour == expected_hour
전략 4: 엣지 케이스 테스트
연도 경계
describe('Year Boundary Tests', () => {
beforeEach(() => jest.useFakeTimers());
afterEach(() => jest.useRealTimers());
test('handles new year transition', () => {
// Set time to 1 second before new year
jest.setSystemTime(new Date('2023-12-31T23:59:59Z'));
const beforeYear = new Date().getFullYear();
expect(beforeYear).toBe(2023);
// Advance 2 seconds
jest.advanceTimersByTime(2000);
const afterYear = new Date().getFullYear();
expect(afterYear).toBe(2024);
});
test('calculates days correctly across year boundary', () => {
const dec31 = new Date('2023-12-31T12:00:00Z');
const jan1 = new Date('2024-01-01T12:00:00Z');
const days = (jan1 - dec31) / (1000 * 60 * 60 * 24);
expect(days).toBe(1);
});
});
윤년
import pytest
from datetime import datetime
@pytest.mark.parametrize("year,is_leap", [
(2020, True), # Divisible by 4
(2021, False), # Not divisible by 4
(2000, True), # Divisible by 400
(1900, False), # Divisible by 100 but not 400
])
def test_leap_year_detection(year, is_leap):
"""Test leap year detection."""
try:
# Feb 29 exists only in leap years
datetime(year, 2, 29)
assert is_leap
except ValueError:
assert not is_leap
def test_leap_year_calculations():
"""Test calculations involving leap years."""
# 2020 is a leap year (366 days)
year_start = datetime(2020, 1, 1)
year_end = datetime(2020, 12, 31, 23, 59, 59)
days = (year_end - year_start).days
assert days == 365 # .days doesn't include the last partial day
# 2021 is not a leap year (365 days)
year_start = datetime(2021, 1, 1)
year_end = datetime(2021, 12, 31, 23, 59, 59)
days = (year_end - year_start).days
assert days == 364
전략 5: 통합 테스트
실시간 시간대 데이터베이스로 테스트
// Test that uses actual timezone data
describe('Real Timezone Tests', () => {
test('correctly handles all US DST transitions in 2024', () => {
const transitions = [
{ date: '2024-03-10T07:00:00.000Z', type: 'spring forward' },
{ date: '2024-11-03T06:00:00.000Z', type: 'fall back' }
];
transitions.forEach(({ date, type }) => {
const transitionTime = new Date(date);
// Test that we can detect the transition
const before = new Date(transitionTime.getTime() - 3600000);
const after = new Date(transitionTime.getTime() + 3600000);
const beforeOffset = before.getTimezoneOffset();
const afterOffset = after.getTimezoneOffset();
if (type === 'spring forward') {
expect(beforeOffset).toBeGreaterThan(afterOffset);
} else {
expect(beforeOffset).toBeLessThan(afterOffset);
}
});
});
});
모범 사례
1. 내부적으로는 항상 UTC를 사용하세요
class EventManager {
createEvent(localTime, timezone) {
// Store in UTC
const utcTime = zonedTimeToUtc(localTime, timezone);
return {
utc_timestamp: utcTime.getTime(),
display_timezone: timezone
};
}
displayEvent(event, timezone) {
// Convert to display timezone only when needed
const localTime = utcToZonedTime(event.utc_timestamp, timezone);
return localTime;
}
}
// Test
test('events store and display correctly', () => {
const manager = new EventManager();
// Create event in New York time
const event = manager.createEvent(
new Date('2024-01-15T15:00:00'),
'America/New_York'
);
// Display in Tokyo time
const tokyoTime = manager.displayEvent(event, 'Asia/Tokyo');
// Should be next day in Tokyo (14 hours ahead)
expect(tokyoTime.getDate()).toBe(16);
});
2. 데이터 경계 테스트
import pytest
from datetime import datetime
def test_timestamp_boundaries():
"""Test minimum and maximum timestamp values."""
# Unix timestamp epoch
epoch = datetime.fromtimestamp(0)
assert epoch.year == 1970
# Year 2038 problem (32-bit signed int overflow)
max_32bit = datetime.fromtimestamp(2147483647)
assert max_32bit.year == 2038
# Negative timestamps (before epoch)
before_epoch = datetime.fromtimestamp(-86400) # 1 day before epoch
assert before_epoch.year == 1969
3. 테스트 픽스처 사용
import pytest
from datetime import datetime
import pytz
@pytest.fixture
def fixed_time():
"""Provide a fixed time for tests."""
return datetime(2024, 1, 15, 12, 0, 0, tzinfo=pytz.UTC)
@pytest.fixture
def dst_transition_dates():
"""Provide DST transition dates."""
return {
'spring_forward': datetime(2024, 3, 10, 2, 0, 0),
'fall_back': datetime(2024, 11, 3, 2, 0, 0)
}
def test_with_fixtures(fixed_time, dst_transition_dates):
"""Use fixtures in tests."""
assert fixed_time.year == 2024
assert len(dst_transition_dates) == 2
일반적인 함정
❌ 피해야 할 사항:
- 현재 시간으로 테스트(조롱 없이
new Date()) - 특정 시간대에서 테스트가 실행된다고 가정
- 테스트에서 DST 전환을 무시합니다.
- 무효화되는 날짜를 하드코딩합니다.
- 엣지 케이스(윤년, 연도 경계)를 테스트하지 않음
✅ 해야 할 일:
- 테스트에서는 항상 모의 시간을 사용합니다.
- 여러 시간대에 걸쳐 테스트
- 테스트 케이스에 DST 전환 날짜를 포함합니다.
- 가능하다면 상대적인 날짜를 사용하세요.
- 일반 케이스와 엣지 케이스를 모두 테스트합니다.
요약
주요 테스트 전략
- 모의 시간 - Jest 가짜 타이머, 프리즈건 또는 종속성 주입을 사용하세요.
- DST 테스트 - 스프링 포워드 및 폴백 시나리오 포함
- 시간대 테스트 - 여러 시간대에 걸친 변환 확인
- 테스트 엣지 케이스 - 연도 경계, 윤년, 유효하지 않은 날짜
- 내부적으로 UTC 사용 - UTC로 저장하고 표시용으로만 변환
권장 도구
자바스크립트:
@sinonjs/fake-timers을 사용한 농담- 시간대 테스트를 위한
date-fns-tz - 포괄적인 날짜/시간 처리를 위한
luxon
파이썬:
- 테스트 프레임워크용
pytest - 시간 조롱을 위해
freezegun - 시간대 테스트를 위한
pytz
이동:
- 시간 인터페이스를 통한 종속성 주입
- 매개변수화를 위한 테이블 기반 테스트