294 lines
13 KiB
Python
294 lines
13 KiB
Python
"""Tests for issue #77: Show honest qualifying-day progress and confidence.
|
|
|
|
These tests verify that:
|
|
1. Warming progress shows detailed qualifying day breakdown
|
|
2. Confidence state accurately reflects qualifying day progress
|
|
3. Edge cases like zero-delta intervals and unknown daily shares are handled
|
|
4. qualifying_days_progress shows honest qualifying day count
|
|
"""
|
|
import sqlite3
|
|
from datetime import datetime, timedelta, timezone
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
import sys
|
|
sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
|
|
|
|
from fenris.store import init_store
|
|
from fenris.monitoring_periods import ensure_period_open, close_period
|
|
from fenris.projection import (
|
|
compute_projection, ConfidenceState, BaselineTier,
|
|
WARMING_MIN_DAYS, WARMING_COVERAGE_FLOOR, WARMING_MAX_LOW_COVERAGE,
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def store(tmp_path):
|
|
conn = init_store(tmp_path / "test.db")
|
|
yield conn
|
|
conn.close()
|
|
|
|
|
|
def _clock(year=2026, month=9, day=30, hour=12):
|
|
return datetime(year, month, day, hour, 0, 0, tzinfo=timezone.utc)
|
|
|
|
|
|
def _insert_baseline(conn, tbw_tb=1.0, verified=True, model="Samsung SSD 970 EVO Plus 1TB"):
|
|
conn.execute(
|
|
"INSERT INTO endurance_baseline "
|
|
"(tbw_terabytes, source_url, document_revision, entry_date, model_string, "
|
|
" nominal_capacity_bytes, validated_by, verified, created_at, updated_at) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
|
(tbw_tb, "https://example.com/spec", "v1.0", "2026-01-01", model, 1024000000000,
|
|
"machine_match" if verified else None, verified, "2026-01-01T00:00:00+00:00",
|
|
"2026-01-01T00:00:00+00:00"),
|
|
)
|
|
conn.commit()
|
|
|
|
|
|
def _insert_segment(conn, opened_at="2026-09-01T00:00:00+00:00",
|
|
identity_key="nqn.test", degraded=False,
|
|
mn="Samsung SSD 970 EVO Plus 1TB"):
|
|
conn.execute(
|
|
"INSERT INTO controller_segments "
|
|
"(opened_at, identity_key, identity_degraded, subnqn, sn, mn, fr, vid, ssvid, transport) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
|
(opened_at, identity_key, degraded, "nqn.test", "SN123", mn, "FW1", "0x144d", "0x144d", "pcie"),
|
|
)
|
|
conn.commit()
|
|
|
|
|
|
def _insert_day(conn, day, bw=1024*1024*100, coverage=0.95, samples=24):
|
|
conn.execute(
|
|
"INSERT INTO day_aggregates (day, active_seconds, idle_seconds, powered_off_seconds, "
|
|
"unknown_seconds, bytes_written_delta, bytes_read_delta, sample_count, coverage) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
|
(day, 3600, 0, 0, 0, bw, 0, samples, coverage),
|
|
)
|
|
conn.commit()
|
|
|
|
|
|
def _insert_sample(conn, ts, pu=5):
|
|
conn.execute(
|
|
"INSERT INTO samples (ts, device, data_units_written, data_units_read, "
|
|
"percentage_used, bytes_written, bytes_read, power_on_hours) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
|
|
(ts, "/dev/nvme0n1", 1000000, 500000, pu, 512000000000, 256000000000, 8765),
|
|
)
|
|
conn.commit()
|
|
|
|
|
|
def _open_period(conn, start="2026-09-01T00:00:00+00:00"):
|
|
# Convert string to datetime if needed
|
|
if isinstance(start, str):
|
|
start = datetime.fromisoformat(start)
|
|
ensure_period_open(conn, start)
|
|
conn.commit()
|
|
|
|
|
|
def _insert_local_day(conn, local_date, tz_name="UTC", tz_offset="+00:00",
|
|
utc_start=None, utc_end=None, bw=1024*1024*100,
|
|
br=0, coverage=0.95, samples=24, complete=True):
|
|
"""Insert a local_days row (issue #94 gate prerequisite)."""
|
|
if utc_start is None:
|
|
utc_start = local_date + "T00:00:00+00:00"
|
|
if utc_end is None:
|
|
dt = datetime.strptime(local_date, "%Y-%m-%d") + timedelta(days=1)
|
|
utc_end = dt.strftime("%Y-%m-%dT00:00:00+00:00")
|
|
conn.execute(
|
|
"INSERT INTO local_days "
|
|
"(local_date, tz_name, tz_offset, utc_start, utc_end, "
|
|
" bytes_written, bytes_read, coverage, sample_count, complete) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
|
(local_date, tz_name, tz_offset, utc_start, utc_end,
|
|
bw, br, coverage, samples, complete),
|
|
)
|
|
conn.commit()
|
|
|
|
|
|
def _insert_complete_local_days(conn, start_date, count, bw=1024*1024*100):
|
|
"""Insert multiple complete local days to satisfy the issue #94 gate."""
|
|
for i in range(count):
|
|
d = (datetime.strptime(start_date, "%Y-%m-%d") + timedelta(days=i)).strftime("%Y-%m-%d")
|
|
_insert_local_day(conn, d, bw=bw)
|
|
|
|
|
|
class TestHonestQualifyingProgress:
|
|
"""Issue #77: Show honest qualifying-day progress and confidence."""
|
|
|
|
def test_warming_shows_qualifying_vs_nonqualifying(self, store):
|
|
"""Warming progress shows both qualifying and non-qualifying days."""
|
|
_insert_baseline(store, tbw_tb=10.0, verified=True)
|
|
_insert_segment(store, opened_at="2026-09-20T00:00:00+00:00")
|
|
_open_period(store, start="2026-09-20T00:00:00+00:00")
|
|
bw = 100 * 1024 * 1024
|
|
|
|
# 12 qualifying days + 2 non-qualifying (low coverage)
|
|
for i in range(14):
|
|
d = (datetime(2026, 9, 20) + timedelta(days=i)).strftime("%Y-%m-%d")
|
|
cov = 0.30 if i < 2 else 0.95 # First 2 days have low coverage
|
|
_insert_day(store, d, bw=bw, coverage=cov)
|
|
|
|
_insert_sample(store, "2026-09-30T10:00:00+00:00", pu=5)
|
|
_insert_complete_local_days(store, "2026-09-29", 1)
|
|
result = compute_projection(store, _clock())
|
|
|
|
# After warming, qualifying_days_progress shows honest count
|
|
assert result.warming_fact is None # Not warming (14 total, 2 below <= WARMING_MAX_LOW_COVERAGE)
|
|
assert result.qualifying_days_progress is not None
|
|
assert "12 of 14 qualifying days" in result.qualifying_days_progress
|
|
assert "2 below coverage" in result.qualifying_days_progress
|
|
|
|
def test_warming_progress_includes_nonqualifying_reason(self, store):
|
|
"""Warming progress indicates why days don't qualify."""
|
|
_insert_baseline(store, tbw_tb=10.0, verified=True)
|
|
_insert_segment(store, opened_at="2026-09-20T00:00:00+00:00")
|
|
_open_period(store, start="2026-09-20T00:00:00+00:00")
|
|
bw = 100 * 1024 * 1024
|
|
|
|
# 13 qualifying days + 1 non-qualifying (zero samples)
|
|
for i in range(14):
|
|
d = (datetime(2026, 9, 20) + timedelta(days=i)).strftime("%Y-%m-%d")
|
|
samples = 0 if i == 0 else 24 # First day has no samples
|
|
_insert_day(store, d, bw=bw, samples=samples)
|
|
|
|
_insert_sample(store, "2026-09-30T10:00:00+00:00", pu=5)
|
|
_insert_complete_local_days(store, "2026-09-29", 1)
|
|
result = compute_projection(store, _clock())
|
|
|
|
# After warming, qualifying_days_progress shows honest count
|
|
assert result.warming_fact is None # Not warming (14 total, 1 below <= WARMING_MAX_LOW_COVERAGE)
|
|
assert result.qualifying_days_progress is not None
|
|
assert "13 of 14 qualifying days" in result.qualifying_days_progress
|
|
assert "1 below coverage" in result.qualifying_days_progress
|
|
|
|
def test_confidence_updates_as_qualifying_days_increase(self, store):
|
|
"""Confidence state reflects actual qualifying day count."""
|
|
_insert_baseline(store, tbw_tb=10.0, verified=True)
|
|
_insert_segment(store, opened_at="2026-09-20T00:00:00+00:00")
|
|
_open_period(store, start="2026-09-20T00:00:00+00:00")
|
|
bw = 100 * 1024 * 1024
|
|
|
|
# Start with 10 days (below minimum)
|
|
for i in range(10):
|
|
d = (datetime(2026, 9, 20) + timedelta(days=i)).strftime("%Y-%m-%d")
|
|
_insert_day(store, d, bw=bw, coverage=0.95)
|
|
|
|
_insert_sample(store, "2026-09-30T10:00:00+00:00", pu=5)
|
|
_insert_complete_local_days(store, "2026-09-29", 1)
|
|
result = compute_projection(store, _clock())
|
|
|
|
# Should be warming
|
|
assert result.warming_fact is not None
|
|
assert result.confidence_state == ConfidenceState.LIMITED
|
|
|
|
def test_zero_rate_with_qualifying_days(self, store):
|
|
"""Zero rate with qualifying days shows honest state."""
|
|
_insert_baseline(store, tbw_tb=10.0, verified=True)
|
|
_insert_segment(store, opened_at="2026-09-20T00:00:00+00:00")
|
|
_open_period(store, start="2026-09-20T00:00:00+00:00")
|
|
|
|
# 14 days with zero bytes written
|
|
for i in range(14):
|
|
d = (datetime(2026, 9, 20) + timedelta(days=i)).strftime("%Y-%m-%d")
|
|
_insert_day(store, d, bw=0, coverage=0.95)
|
|
|
|
_insert_sample(store, "2026-09-30T10:00:00+00:00", pu=5)
|
|
_insert_complete_local_days(store, "2026-09-29", 1)
|
|
result = compute_projection(store, _clock())
|
|
|
|
# Zero rate should be UNSUPPORTED
|
|
assert result.confidence_state == ConfidenceState.UNSUPPORTED
|
|
assert result.zero_rate_fact is not None
|
|
assert "no finite projection" in result.zero_rate_fact
|
|
|
|
def test_qualifying_days_excludes_low_coverage(self, store):
|
|
"""Days below 50% coverage don't count as qualifying."""
|
|
_insert_baseline(store, tbw_tb=10.0, verified=True)
|
|
_insert_segment(store, opened_at="2026-09-20T00:00:00+00:00")
|
|
_open_period(store, start="2026-09-20T00:00:00+00:00")
|
|
bw = 100 * 1024 * 1024
|
|
|
|
# 14 days total, but 3 have low coverage
|
|
for i in range(14):
|
|
d = (datetime(2026, 9, 20) + timedelta(days=i)).strftime("%Y-%m-%d")
|
|
cov = 0.30 if i < 3 else 0.95
|
|
_insert_day(store, d, bw=bw, coverage=cov)
|
|
|
|
_insert_sample(store, "2026-09-30T10:00:00+00:00", pu=5)
|
|
_insert_complete_local_days(store, "2026-09-29", 1)
|
|
result = compute_projection(store, _clock())
|
|
|
|
# Should still be warming (3 days below coverage > WARMING_MAX_LOW_COVERAGE=2)
|
|
assert result.warming_fact is not None
|
|
assert "warming up" in result.warming_fact.lower()
|
|
|
|
def test_qualifying_days_excludes_zero_samples(self, store):
|
|
"""Days with zero samples don't count as qualifying."""
|
|
_insert_baseline(store, tbw_tb=10.0, verified=True)
|
|
_insert_segment(store, opened_at="2026-09-20T00:00:00+00:00")
|
|
_open_period(store, start="2026-09-20T00:00:00+00:00")
|
|
bw = 100 * 1024 * 1024
|
|
|
|
# 14 days total, but 3 have zero samples
|
|
for i in range(14):
|
|
d = (datetime(2026, 9, 20) + timedelta(days=i)).strftime("%Y-%m-%d")
|
|
samples = 0 if i < 3 else 24
|
|
_insert_day(store, d, bw=bw, samples=samples)
|
|
|
|
_insert_sample(store, "2026-09-30T10:00:00+00:00", pu=5)
|
|
_insert_complete_local_days(store, "2026-09-29", 1)
|
|
result = compute_projection(store, _clock())
|
|
|
|
# Should still be warming
|
|
assert result.warming_fact is not None
|
|
assert "warming up" in result.warming_fact.lower()
|
|
|
|
def test_qualifying_days_progress_after_warming(self, store):
|
|
"""After warming, qualifying_days_progress shows honest count."""
|
|
_insert_baseline(store, tbw_tb=10.0, verified=True)
|
|
_insert_segment(store, opened_at="2026-09-17T00:00:00+00:00")
|
|
_open_period(store, start="2026-09-17T00:00:00+00:00")
|
|
bw = 100 * 1024 * 1024
|
|
|
|
# 14 total days, 12 qualifying (2 below coverage)
|
|
for i in range(14):
|
|
d = (datetime(2026, 9, 17) + timedelta(days=i)).strftime("%Y-%m-%d")
|
|
cov = 0.30 if i < 2 else 0.95 # First 2 days have low coverage
|
|
_insert_day(store, d, bw=bw, coverage=cov)
|
|
|
|
_insert_sample(store, "2026-09-30T10:00:00+00:00", pu=5)
|
|
_insert_complete_local_days(store, "2026-09-29", 1)
|
|
result = compute_projection(store, _clock())
|
|
|
|
# Should not be warming (14 total, 2 below coverage <= WARMING_MAX_LOW_COVERAGE)
|
|
assert result.warming_fact is None
|
|
# But qualifying_days_progress should show the honest count
|
|
assert result.qualifying_days_progress is not None
|
|
assert "12 of 14 qualifying days" in result.qualifying_days_progress
|
|
assert "2 below coverage" in result.qualifying_days_progress
|
|
|
|
def test_qualifying_days_progress_all_qualifying(self, store):
|
|
"""When all days qualify, qualifying_days_progress shows 100%."""
|
|
_insert_baseline(store, tbw_tb=10.0, verified=True)
|
|
_insert_segment(store, opened_at="2026-09-17T00:00:00+00:00")
|
|
_open_period(store, start="2026-09-17T00:00:00+00:00")
|
|
bw = 100 * 1024 * 1024
|
|
|
|
# 14 days, all qualifying
|
|
for i in range(14):
|
|
d = (datetime(2026, 9, 17) + timedelta(days=i)).strftime("%Y-%m-%d")
|
|
_insert_day(store, d, bw=bw, coverage=0.95)
|
|
|
|
_insert_sample(store, "2026-09-30T10:00:00+00:00", pu=5)
|
|
_insert_complete_local_days(store, "2026-09-29", 1)
|
|
result = compute_projection(store, _clock())
|
|
|
|
# Should not be warming
|
|
assert result.warming_fact is None
|
|
# qualifying_days_progress should show all qualifying
|
|
assert result.qualifying_days_progress is not None
|
|
assert "14 of 14 qualifying days" in result.qualifying_days_progress
|
|
# Should not show "below coverage" since all qualify
|
|
assert "below coverage" not in result.qualifying_days_progress
|