Minutes Ago

Relative time formatting (also called "time ago" or "fuzzy timestamps") presents time differences in human-readable terms like "5 minutes ago" or "2 hours ago" instead of absolute timestamps. This approach significantly improves user experience and temporal context in modern applications.

Benefits of Relative Time Formatting:

1. Improved Readability and Context:
• Absolute: "2024-03-15 14:32:18" (requires mental calculation)
• Relative: "2 hours ago" (immediately understandable)
• Users instantly understand recency without parsing exact timestamps

2. Reduced Cognitive Load:
• No timezone conversion needed mentally
• No date format ambiguity (MM/DD vs DD/MM)
• Focus on relevance, not precision

3. Better Mobile Experience:
• Shorter text fits better on small screens
• "3m ago" vs "Mar 15, 2024 at 2:32 PM"
• Particularly valuable in feed-based interfaces

Common Use Cases:

Social Media and Communication:
• Post timestamps: "Posted 5 minutes ago"
• Message timestamps: "Last seen 3 hours ago"
• Comment threads: "Replied 2 days ago"
• Examples: Twitter, Facebook, Slack, Discord

Content Management:
• Article publication: "Published 2 weeks ago"
• Edit history: "Last edited 30 minutes ago"
• User activity: "Updated 1 hour ago"

System Monitoring:
• Service status: "Last check 10 seconds ago"
• Error logs: "Error occurred 5 minutes ago"
• Deployment tracking: "Deployed 3 days ago"

E-commerce and Transactions:
• Order status: "Ordered 2 hours ago"
• Shipping updates: "Shipped 1 day ago"
• Product availability: "Last in stock 3 weeks ago"

When to Use Relative vs Absolute Time:

Use Relative Time When:
✓ Recency matters more than exact time (social feeds, notifications)
✓ Events are recent (within last 7 days typically)
✓ Screen space is limited (mobile, cards)
✓ User timezone is uncertain or varies

Use Absolute Time When:
✓ Precision is critical (financial transactions, legal documents)
✓ Events are old (beyond 1 month)
✓ Scheduling future events (meetings, reminders)
✓ Audit trails and compliance records

Best Practice: Hybrid Approach:
Many applications combine both:
• Display relative time by default
• Show absolute time on hover/tooltip
• Switch to absolute after certain threshold (e.g., 7 days)
• Example: "5 minutes ago (Mar 15, 2024 at 2:32 PM)"

Internationalization Considerations:
• English: "3 minutes ago"
• Spanish: "hace 3 minutos"
• Japanese: "3分前"
• Use libraries like moment.js, date-fns, or Intl.RelativeTimeFormat for proper localization

Implementing relative time formatting requires calculating time differences and converting them to human-readable strings with appropriate granularity. Different platforms and libraries offer various approaches, each with specific considerations for accuracy and performance.

JavaScript Native Implementation:
function timeAgo(timestamp) {
const now = Date.now();
const diffMs = now - timestamp;
const diffSec = Math.floor(diffMs / 1000);

// Less than a minute
if (diffSec < 60) return 'just now';

// Less than an hour
const diffMin = Math.floor(diffSec / 60);
if (diffMin < 60) return \`\${diffMin} minute\${diffMin !== 1 ? 's' : ''} ago\`;

// Less than a day
const diffHours = Math.floor(diffMin / 60);
if (diffHours < 24) return \`\${diffHours} hour\${diffHours !== 1 ? 's' : ''} ago\`;

// Less than a week
const diffDays = Math.floor(diffHours / 24);
if (diffDays < 7) return \`\${diffDays} day\${diffDays !== 1 ? 's' : ''} ago\`;

// Less than a month (approximate)
const diffWeeks = Math.floor(diffDays / 7);
if (diffWeeks < 4) return \`\${diffWeeks} week\${diffWeeks !== 1 ? 's' : ''} ago\`;

// Less than a year
const diffMonths = Math.floor(diffDays / 30);
if (diffMonths < 12) return \`\${diffMonths} month\${diffMonths !== 1 ? 's' : ''} ago\`;

// More than a year
const diffYears = Math.floor(diffDays / 365);
return \`\${diffYears} year\${diffYears !== 1 ? 's' : ''} ago\`;
}

// Usage
const postTime = new Date('2024-03-15T14:30:00').getTime();
console.log(timeAgo(postTime)); // "2 hours ago" (if current time is 16:30)

Modern JavaScript: Intl.RelativeTimeFormat (ES2020):
function timeAgoIntl(timestamp) {
const now = Date.now();
const diffMs = now - timestamp;
const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });

const diffSec = Math.floor(diffMs / 1000);
const diffMin = Math.floor(diffSec / 60);
const diffHours = Math.floor(diffMin / 60);
const diffDays = Math.floor(diffHours / 24);

if (diffDays > 0) return rtf.format(-diffDays, 'day');
if (diffHours > 0) return rtf.format(-diffHours, 'hour');
if (diffMin > 0) return rtf.format(-diffMin, 'minute');
return rtf.format(-diffSec, 'second');
}

// Output examples:
// -5 seconds → "5 seconds ago"
// -1 minute → "1 minute ago"
// -2 hours → "2 hours ago"
// -1 day → "yesterday" (with numeric: 'auto')

React Implementation with Auto-Update:
import { useState, useEffect } from 'react';

function TimeAgo({ timestamp }) {
const [timeAgoText, setTimeAgoText] = useState('');

useEffect(() => {
const updateTimeAgo = () => {
const now = Date.now();
const diffMs = now - timestamp;
const diffMin = Math.floor(diffMs / (1000 * 60));

if (diffMin < 1) setTimeAgoText('just now');
else if (diffMin < 60) setTimeAgoText(\`\${diffMin}m ago\`);
else if (diffMin < 1440) setTimeAgoText(\`\${Math.floor(diffMin / 60)}h ago\`);
else setTimeAgoText(\`\${Math.floor(diffMin / 1440)}d ago\`);
};

updateTimeAgo();
const interval = setInterval(updateTimeAgo, 60000); // Update every minute

return () => clearInterval(interval);
}, [timestamp]);

return {timeAgoText};
}

// Usage:
// // "5m ago"

Python (for Backend/APIs):
from datetime import datetime, timedelta

def time_ago(timestamp):
now = datetime.now()
if isinstance(timestamp, str):
timestamp = datetime.fromisoformat(timestamp)

diff = now - timestamp
seconds = diff.total_seconds()

if seconds < 60:
return "just now"
elif seconds < 3600:
minutes = int(seconds // 60)
return f"{minutes} minute{'s' if minutes != 1 else ''} ago"
elif seconds < 86400:
hours = int(seconds // 3600)
return f"{hours} hour{'s' if hours != 1 else ''} ago"
elif seconds < 604800:
days = int(seconds // 86400)
return f"{days} day{'s' if days != 1 else ''} ago"
else:
weeks = int(seconds // 604800)
return f"{weeks} week{'s' if weeks != 1 else ''} ago"

# Using arrow library (recommended)
import arrow
past = arrow.get('2024-03-15T14:30:00')
print(past.humanize()) # "2 hours ago"

SQL (Database-Level Calculation):
-- PostgreSQL
SELECT
CASE
WHEN age(NOW(), created_at) < INTERVAL '1 minute' THEN 'just now'
WHEN age(NOW(), created_at) < INTERVAL '1 hour' THEN
EXTRACT(MINUTE FROM age(NOW(), created_at))::text || ' minutes ago'
WHEN age(NOW(), created_at) < INTERVAL '1 day' THEN
EXTRACT(HOUR FROM age(NOW(), created_at))::text || ' hours ago'
ELSE
EXTRACT(DAY FROM age(NOW(), created_at))::text || ' days ago'
END AS time_ago
FROM posts;

Performance Considerations:
• Cache calculations for 1-5 minute intervals, not every second
• For lists/feeds, batch calculate all timestamps together
• Consider server-side rendering for initial load, client-side updates
• For very old timestamps (>7 days), switch to absolute dates to avoid recalculation

Timezone-aware relative time calculations are critical for global applications where users are distributed across different timezones. Properly handling timezones ensures accurate "time ago" displays and prevents confusing or incorrect relative timestamps.

Core Principle: Store UTC, Display Local:

Best Practice Storage:
• Always store timestamps in UTC in your database
• Store as Unix timestamp (milliseconds since epoch) or ISO 8601 UTC
• Never store local time without timezone information

Examples:
// Good - UTC timestamp
const timestamp = Date.now(); // 1710509478000 (milliseconds since epoch)
const isoUTC = new Date().toISOString(); // "2024-03-15T14:32:18.000Z"

// Bad - Local time without context
const localTime = "2024-03-15 14:32:18"; // What timezone?

Why Relative Time is Timezone-Friendly:

The beauty of relative time is that it automatically handles timezones when calculated on the client:

// Server sends UTC timestamp: 2024-03-15T14:00:00Z
const serverTimestamp = 1710511200000;

// Client in New York (UTC-5) at 2024-03-15T10:30:00 local
const nowNY = Date.now(); // Client's local "now"
const diff = nowNY - serverTimestamp;
// Result: "30 minutes ago" (correct!)

// Client in Tokyo (UTC+9) at 2024-03-15T23:30:00 local
const nowTokyo = Date.now(); // Same Unix timestamp as nowNY
const diff = nowTokyo - serverTimestamp;
// Result: "30 minutes ago" (also correct!)

Key Insight: Since both timestamps (event time and current time) use the same reference point (Unix epoch), timezone differences cancel out. The calculation happens in timezone-agnostic milliseconds.

Implementation Patterns:

Pattern 1: Client-Side Calculation (Recommended):
// Server API returns UTC timestamp
fetch('/api/posts')
.then(res => res.json())
.then(posts => {
posts.forEach(post => {
// post.created_at is Unix timestamp in milliseconds
const timeAgo = calculateTimeAgo(post.created_at);
// User sees "5 minutes ago" in their timezone automatically
});
});

Pattern 2: Server-Side with User Timezone (Less Common):
// If server must calculate, send user timezone
fetch('/api/posts?timezone=America/New_York')
.then(res => res.json())
.then(posts => {
// Server calculated relative time based on user's timezone
// Less ideal: breaks caching, adds server complexity
});

Common Pitfalls and Solutions:

Pitfall 1: Using Local Time for Comparisons
Problem:
// Wrong - Comparing local date strings
const postTime = "2024-03-15 14:30:00"; // Ambiguous timezone
const now = "2024-03-15 16:30:00"; // Also ambiguous
// If user in different timezone, calculation is wrong

Solution:
// Correct - Use Unix timestamps
const postTime = 1710511800000; // UTC timestamp
const now = Date.now(); // Always UTC internally
const diffMs = now - postTime;

Pitfall 2: Displaying Future Times in Wrong Timezone
Problem:
// Scheduled post for 10:00 AM UTC tomorrow
const scheduledTime = new Date('2024-03-16T10:00:00Z');
// User sees "in 20 hours" but expects "tomorrow at 10 AM their time"

Solution:
// For future events, show absolute time in user's timezone
const scheduledTime = new Date('2024-03-16T10:00:00Z');
const userLocaleTime = scheduledTime.toLocaleString('en-US', {
timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
dateStyle: 'medium',
timeStyle: 'short'
});
// "Mar 16, 2024, 6:00 AM" (if user in UTC-4)

Pitfall 3: Not Accounting for Daylight Saving Time
Problem:
DST transitions can cause "weird" relative times during changeover.

Solution:
• Use standard date libraries (Luxon, date-fns, Day.js with timezone plugin)
• These handle DST transitions automatically
• Don't try to manually calculate timezone offsets

Testing Timezone-Aware Code:

Test Cases to Cover:
✓ User in UTC vs user in UTC+14 (earliest timezone)
✓ User in UTC-12 (latest timezone)
✓ Event during DST transition (spring forward/fall back)
✓ Events around midnight in different timezones
✓ Future events (should they show relative or absolute?)

Testing in Browser:
// Override browser timezone for testing (Chrome DevTools)
// Settings > Sensors > Location > Select timezone

// Or programmatically (limited browser support)
Intl.DateTimeFormat().resolvedOptions().timeZone; // "America/New_York"

Recommended Libraries:
• Luxon: Modern, timezone-aware, immutable
• date-fns-tz: Lightweight timezone support for date-fns
• Day.js with timezone plugin: Small bundle size
• Avoid: Moment.js (deprecated), use Luxon instead

Relative time displays involve numerous edge cases that can create confusing or awkward user experiences if not handled properly. Thoughtful consideration of thresholds, update frequencies, and contextual information significantly improves clarity and usability.

Edge Case 1: "Just Now" vs "0 Seconds Ago"

Problem: Very recent events (< 5-10 seconds) can show "0 seconds ago" or fluctuate rapidly.

Solution:
function timeAgoWithJustNow(timestamp) {
const diffSec = Math.floor((Date.now() - timestamp) / 1000);

// Threshold for "just now" (typical: 5-60 seconds)
if (diffSec < 30) return 'just now';

// Continue with minutes, hours, etc.
if (diffSec < 60) return 'less than a minute ago';
// ...
}

// Alternative: Show "now" for current second only
if (diffSec === 0) return 'now';
if (diffSec < 60) return \`\${diffSec}s ago\`;

Best Practice Thresholds:
• < 30-60 seconds: "just now" (avoid rapid changes)
• < 2-5 minutes: "a few minutes ago" (optional, reduces precision anxiety)
• >= 5 minutes: Show exact minutes

Edge Case 2: Rounding and Precision Transitions

Problem: "59 minutes ago" → "1 hour ago" loses precision. Was it posted 59 minutes ago or 90 minutes ago?

Solution Options:

Option A: Extended Minutes Range:
if (diffMin < 90) return \`\${diffMin} minutes ago\`; // Up to 90 minutes
if (diffHours < 24) return \`\${diffHours} hours ago\`;

Option B: Hybrid Format:
// Show "1 hour, 30 minutes ago" for first few hours
if (diffMin < 120) {
const hours = Math.floor(diffMin / 60);
const minutes = diffMin % 60;
return \`\${hours}h \${minutes}m ago\`;
}

Option C: Tooltip with Exact Time:
// Display: "2 hours ago"
// Tooltip on hover: "March 15, 2024 at 2:32 PM"
{relativeTime}

Edge Case 3: Future Timestamps (Negative Time Difference)

Problem: Scheduled posts, clock skew, or client-side time manipulation can create future timestamps.

Solution:
function timeAgo(timestamp) {
const diffMs = Date.now() - timestamp;

// Handle future times
if (diffMs < 0) {
const absDiffMs = Math.abs(diffMs);
const diffMin = Math.floor(absDiffMs / (1000 * 60));

if (diffMin < 5) {
// Clock skew tolerance: treat as "just now"
return 'just now';
}

// Genuinely scheduled for future
if (diffMin < 60) return \`in \${diffMin} minutes\`;
const diffHours = Math.floor(diffMin / 60);
if (diffHours < 24) return \`in \${diffHours} hours\`;
const diffDays = Math.floor(diffHours / 24);
return \`in \${diffDays} days\`;
}

// Normal past time logic...
}

Clock Skew Tolerance:
• Allow 1-5 minute future grace period (clock differences between server/client)
• Beyond that, treat as genuinely scheduled future event

Edge Case 4: Very Old Timestamps (Months/Years Ago)

Problem: "347 days ago" or "18 months ago" is less useful than absolute date.

Solution: Progressive Disclosure:
function smartTimeDisplay(timestamp) {
const diffDays = Math.floor((Date.now() - timestamp) / (1000 * 60 * 60 * 24));

// Recent: Relative time
if (diffDays < 7) {
return timeAgo(timestamp); // "5 hours ago", "3 days ago"
}

// Medium age: Short date (no year if same year)
if (diffDays < 365) {
return new Date(timestamp).toLocaleDateString('en-US', {
month: 'short',
day: 'numeric'
}); // "Mar 15"
}

// Old: Full date
return new Date(timestamp).toLocaleDateString('en-US', {
year: 'numeric',
month: 'short',
day: 'numeric'
}); // "Mar 15, 2023"
}

Typical Thresholds:
• 0-7 days: Relative ("2 days ago")
• 7-365 days: Short date ("Mar 15")
• 365+ days: Full date ("Mar 15, 2023")

Edge Case 5: Update Frequency and Performance

Problem: Updating every second is wasteful; not updating makes timestamps stale.

Solution: Adaptive Update Intervals:
function getUpdateInterval(timestamp) {
const diffSec = Math.floor((Date.now() - timestamp) / 1000);

if (diffSec < 60) return 10000; // Update every 10 seconds
if (diffSec < 3600) return 60000; // Update every minute
if (diffSec < 86400) return 300000; // Update every 5 minutes
return 3600000; // Update every hour
}

function setupDynamicUpdate(element, timestamp) {
function update() {
element.textContent = timeAgo(timestamp);
const nextInterval = getUpdateInterval(timestamp);
setTimeout(update, nextInterval);
}
update();
}

Performance Tips:
• Batch updates: Update all timestamps at once, not individually
• Use requestAnimationFrame for UI updates
• Pause updates when page is not visible (Page Visibility API)
• Consider IntersectionObserver for timestamps in long lists

Accessibility Considerations:

Provide Accessible Timestamps:


2 hours ago



aria-label="Posted on March 15, 2024 at 2:32 PM"
title="March 15, 2024 at 2:32 PM"
>
2 hours ago


Announce Updates to Screen Readers:

Last updated: {timeAgo}

Context-Specific Considerations:

Social Media Feeds:
• Short format: "5m", "2h", "3d" (space-efficient)
• Fast updates for recent posts (< 1 hour)
• Show dates for posts > 1 week old

System Monitoring Dashboards:
• High precision: "2 minutes 34 seconds ago"
• Frequent updates (every 1-5 seconds)
• Color coding: green (< 5 min), yellow (< 15 min), red (> 15 min)

Email/Message Timestamps:
• Today: "2:32 PM"
• Yesterday: "Yesterday at 2:32 PM"
• This week: "Monday at 2:32 PM"
• Older: "Mar 15, 2024"

Time-ago calculations are deceptively simple but contain numerous subtle bugs that can cause incorrect displays, performance issues, or poor user experiences. Understanding these common mistakes helps avoid frustration and ensures reliable timestamp displays.

Bug 1: Using String Comparison Instead of Timestamp Math

❌ Wrong:
// Comparing ISO date strings directly
const postTime = "2024-03-15T14:30:00Z";
const now = new Date().toISOString();
if (postTime < now) { // String comparison - WRONG!
// This works accidentally for ISO format, but fragile
}

✅ Correct:
const postTime = new Date("2024-03-15T14:30:00Z").getTime();
const now = Date.now();
const diffMs = now - postTime; // Numeric subtraction

Why It Matters:
• String comparison breaks with non-ISO formats
• Timezone information can be lost
• Arithmetic operations fail

Bug 2: Not Handling Negative Differences (Future Times)

❌ Wrong:
function timeAgo(timestamp) {
const diffMin = Math.floor((Date.now() - timestamp) / 60000);
return \`\${diffMin} minutes ago\`; // Negative for future times!
// Output: "-10 minutes ago" 😱
}

✅ Correct:
function timeAgo(timestamp) {
const diffMs = Date.now() - timestamp;

if (diffMs < 0) {
// Handle future times
const futureMin = Math.floor(Math.abs(diffMs) / 60000);
return \`in \${futureMin} minutes\`;
}

const pastMin = Math.floor(diffMs / 60000);
return \`\${pastMin} minutes ago\`;
}

Bug 3: Incorrect Unit Conversions

❌ Wrong:
// Using wrong conversion factors
const diffHours = diffMs / 3600; // Missing 1000 for milliseconds!
const diffDays = diffMs / 86400; // Should be 86400000
const diffMonths = diffDays / 30; // Months vary: 28-31 days

✅ Correct:
const MILLISECONDS_PER_SECOND = 1000;
const SECONDS_PER_MINUTE = 60;
const MINUTES_PER_HOUR = 60;
const HOURS_PER_DAY = 24;

const diffSec = Math.floor(diffMs / MILLISECONDS_PER_SECOND);
const diffMin = Math.floor(diffSec / SECONDS_PER_MINUTE);
const diffHours = Math.floor(diffMin / MINUTES_PER_HOUR);
const diffDays = Math.floor(diffHours / HOURS_PER_DAY);

// For months/years, use date arithmetic, not division
const date1 = new Date(timestamp1);
const date2 = new Date(timestamp2);
const diffMonths = (date2.getFullYear() - date1.getFullYear()) * 12 +
(date2.getMonth() - date1.getMonth());

Bug 4: Forgetting to Floor/Round Values

❌ Wrong:
const diffMin = (Date.now() - timestamp) / 60000;
console.log(\`\${diffMin} minutes ago\`);
// Output: "5.342 minutes ago" (awkward!)

✅ Correct:
const diffMin = Math.floor((Date.now() - timestamp) / 60000);
console.log(\`\${diffMin} minutes ago\`);
// Output: "5 minutes ago"

// Or use Math.round() for "nearest" semantics
const diffMin = Math.round((Date.now() - timestamp) / 60000);

Bug 5: Memory Leaks from Interval Updates

❌ Wrong:
// React component
function TimeAgo({ timestamp }) {
const [text, setText] = useState('');

useEffect(() => {
setInterval(() => {
setText(calculateTimeAgo(timestamp));
}, 1000);
// Missing cleanup! Interval continues after unmount
}, [timestamp]);

return {text};
}

✅ Correct:
function TimeAgo({ timestamp }) {
const [text, setText] = useState('');

useEffect(() => {
const updateText = () => setText(calculateTimeAgo(timestamp));
updateText(); // Initial update

const intervalId = setInterval(updateText, 60000); // Every minute

return () => clearInterval(intervalId); // Cleanup on unmount
}, [timestamp]);

return {text};
}

Bug 6: Inconsistent Pluralization

❌ Wrong:
return \`\${hours} hours ago\`; // Wrong for hours === 1
// Output: "1 hours ago" 😬

✅ Correct:
function pluralize(value, unit) {
return \`\${value} \${unit}\${value !== 1 ? 's' : ''} ago\`;
}

console.log(pluralize(1, 'hour')); // "1 hour ago"
console.log(pluralize(2, 'hour')); // "2 hours ago"

// Or use Intl.RelativeTimeFormat (handles pluralization automatically)
const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });
console.log(rtf.format(-1, 'hour')); // "1 hour ago"
console.log(rtf.format(-2, 'hour')); // "2 hours ago"

Bug 7: Not Handling Millisecond Precision

❌ Wrong:
// Timestamp in seconds (Unix timestamp), not milliseconds
const timestamp = 1710509478; // Seconds since epoch
const diffMs = Date.now() - timestamp; // Comparing ms to seconds!
// Result: Huge incorrect difference

✅ Correct:
// Always convert to milliseconds
const timestampMs = timestamp * 1000; // If timestamp is in seconds
const diffMs = Date.now() - timestampMs;

// Or check format
function normalizeTimestamp(ts) {
// If timestamp < 10 billion, likely seconds (not ms)
return ts < 10000000000 ? ts * 1000 : ts;
}

Bug 8: Ignoring Timezone in Input Parsing

❌ Wrong:
// Parsing without timezone - assumes local time!
const timestamp = new Date("2024-03-15 14:30:00").getTime();
// Interprets as local timezone, not UTC

✅ Correct:
// Always parse with explicit timezone or use UTC
const timestampUTC = new Date("2024-03-15T14:30:00Z").getTime(); // Z = UTC

// Or use Date.UTC()
const timestamp = Date.UTC(2024, 2, 15, 14, 30, 0); // March = month 2

Bug 9: Over-Updating (Performance Issue)

❌ Wrong:
// Updating every 100ms for all timestamps on page
setInterval(() => {
document.querySelectorAll('.timestamp').forEach(el => {
el.textContent = timeAgo(el.dataset.timestamp);
});
}, 100); // Excessive!

✅ Correct:
// Adaptive update based on age
function scheduleUpdate(element, timestamp) {
const age = Date.now() - timestamp;
let interval;

if (age < 60000) interval = 10000; // < 1 min: update every 10s
else if (age < 3600000) interval = 60000; // < 1 hour: every minute
else interval = 300000; // Older: every 5 minutes

setTimeout(() => {
element.textContent = timeAgo(timestamp);
scheduleUpdate(element, timestamp); // Reschedule
}, interval);
}

Testing Best Practices:

Unit Tests to Write:
✓ Test negative differences (future times)
✓ Test boundary values (59 seconds → 1 minute, 23 hours → 1 day)
✓ Test pluralization (1 minute vs 2 minutes)
✓ Test very old dates (> 1 year)
✓ Test "just now" threshold
✓ Test with both seconds and milliseconds timestamps

Example Jest Test:
describe('timeAgo', () => {
const now = Date.now();

it('shows "just now" for recent times', () => {
expect(timeAgo(now - 5000)).toBe('just now');
});

it('shows minutes for < 1 hour', () => {
expect(timeAgo(now - 300000)).toBe('5 minutes ago');
});

it('handles future times', () => {
expect(timeAgo(now + 600000)).toBe('in 10 minutes');
});

it('handles singular units', () => {
expect(timeAgo(now - 60000)).toBe('1 minute ago');
});
});