fix: conserve local-day activity evidence
This commit is contained in:
xavierk
+520
-14
@@ -25,6 +25,7 @@ from fenris.store import init_store, SCHEMA_VERSION
|
||||
from fenris.local_day import (
|
||||
derive_local_day_summary,
|
||||
persist_local_day,
|
||||
record_local_activity_interval,
|
||||
query_local_day_summary,
|
||||
query_current_local_day,
|
||||
LocalDaySummary,
|
||||
@@ -135,13 +136,56 @@ class TestSchemaMigration:
|
||||
assert count == 0
|
||||
conn.close()
|
||||
|
||||
def test_v4_totals_keep_values_but_are_not_treated_as_local_precision(
|
||||
self, tmp_path,
|
||||
):
|
||||
db = tmp_path / "v4.db"
|
||||
conn = sqlite3.connect(db)
|
||||
conn.execute(
|
||||
"CREATE TABLE samples (id INTEGER PRIMARY KEY, ts TEXT, device TEXT)"
|
||||
)
|
||||
conn.execute(
|
||||
"CREATE TABLE pending_publications "
|
||||
"(id INTEGER PRIMARY KEY, sample_ts TEXT, payload TEXT)"
|
||||
)
|
||||
conn.execute(
|
||||
"CREATE TABLE local_days ("
|
||||
"id INTEGER PRIMARY KEY, local_date TEXT NOT NULL, tz_name TEXT NOT NULL, "
|
||||
"tz_offset TEXT NOT NULL, utc_start TEXT NOT NULL, utc_end TEXT NOT NULL, "
|
||||
"bytes_written INTEGER DEFAULT 0, bytes_read INTEGER DEFAULT 0, "
|
||||
"coverage REAL DEFAULT 0, sample_count INTEGER DEFAULT 0, "
|
||||
"complete BOOLEAN DEFAULT 0, UNIQUE(local_date, tz_name))"
|
||||
)
|
||||
conn.execute(
|
||||
"INSERT INTO local_days VALUES "
|
||||
"(1, '2026-09-01', 'UTC', '+00:00', "
|
||||
"'2026-09-01T00:00:00+00:00', '2026-09-02T00:00:00+00:00', "
|
||||
"5120000, 2048000, 0.5, 10, 0)"
|
||||
)
|
||||
conn.execute("PRAGMA user_version=4")
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
conn = init_store(db)
|
||||
stored = conn.execute(
|
||||
"SELECT bytes_written, activity_precision FROM local_days"
|
||||
).fetchone()
|
||||
assert stored == (5_120_000, "legacy")
|
||||
visible = query_local_day_summary(conn, "2026-09-01", "UTC")
|
||||
assert visible["bytes_written"] is None
|
||||
assert visible["activity_state"] == "unavailable"
|
||||
assert "local_tz" in {
|
||||
row[1] for row in conn.execute("PRAGMA table_info(samples)")
|
||||
}
|
||||
conn.close()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Local-day derivation from UTC hours
|
||||
# Local-day coverage derivation from UTC hours
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestDeriveLocalDay:
|
||||
"""Derive local-day summaries from UTC hour observations."""
|
||||
"""Derive coverage from UTC hours without allocating local-day bytes."""
|
||||
|
||||
def test_utc_plus_zero(self, tmp_path):
|
||||
"""UTC timezone: local day boundaries = UTC day boundaries."""
|
||||
@@ -158,8 +202,9 @@ class TestDeriveLocalDay:
|
||||
assert summary.local_date == "2026-09-01"
|
||||
assert summary.tz_name == "UTC"
|
||||
assert summary.tz_offset == "+00:00"
|
||||
assert summary.bytes_written == 300
|
||||
assert summary.bytes_read == 130
|
||||
assert summary.bytes_written == 0
|
||||
assert summary.bytes_read == 0
|
||||
assert summary.activity_precision == "unavailable"
|
||||
assert summary.complete is False # not all 24 hours covered
|
||||
conn.close()
|
||||
|
||||
@@ -179,12 +224,13 @@ class TestDeriveLocalDay:
|
||||
assert summary.local_date == "2026-09-01"
|
||||
assert summary.tz_name == "Asia/Kolkata"
|
||||
assert summary.tz_offset == "+05:30"
|
||||
assert summary.bytes_written == 300
|
||||
assert summary.bytes_read == 130
|
||||
assert summary.bytes_written == 0
|
||||
assert summary.bytes_read == 0
|
||||
assert summary.activity_precision == "unavailable"
|
||||
conn.close()
|
||||
|
||||
def test_midnight_spanning_hour_included(self, tmp_path):
|
||||
"""UTC hour straddling local midnight is included in the local day."""
|
||||
def test_hourly_bytes_cannot_be_allocated_to_local_midnight(self, tmp_path):
|
||||
"""UTC-hour totals do not establish exact local-day byte totals."""
|
||||
conn = init_store(tmp_path / "obs.db")
|
||||
|
||||
# For UTC+5:30, local day 2026-09-01 starts at 2026-08-31T18:30 UTC
|
||||
@@ -196,9 +242,9 @@ class TestDeriveLocalDay:
|
||||
summary = derive_local_day_summary(conn, "Asia/Kolkata", clock)
|
||||
|
||||
assert summary is not None
|
||||
# The midnight-spanning hour (18:00) is included
|
||||
assert summary.bytes_written == 300
|
||||
assert summary.bytes_read == 130
|
||||
assert summary.bytes_written == 0
|
||||
assert summary.bytes_read == 0
|
||||
assert summary.activity_precision == "unavailable"
|
||||
conn.close()
|
||||
|
||||
def test_no_hours_returns_none(self, tmp_path):
|
||||
@@ -387,6 +433,411 @@ class TestCollectorIntegration:
|
||||
assert row[1] == 30 * 512000 # reads
|
||||
conn.close()
|
||||
|
||||
def test_interval_crossing_utc_hour_stays_wholly_in_local_day(
|
||||
self, tmp_path, sysfs_tree, monkeypatch,
|
||||
):
|
||||
"""A measured interval inside one local date keeps its full delta."""
|
||||
from fenris.collector import run_collection
|
||||
|
||||
monkeypatch.setenv("TZ", "Asia/Kolkata")
|
||||
store = str(tmp_path / "obs.db")
|
||||
cfg = {"device": "/dev/nvme0", "store_path": store}
|
||||
sysfs_nvme = sysfs_tree / "sys" / "class" / "nvme" / "nvme0"
|
||||
first_at = datetime(2026, 9, 1, 12, 59, tzinfo=timezone.utc)
|
||||
second_at = datetime(2026, 9, 1, 13, 1, tzinfo=timezone.utc)
|
||||
|
||||
first = run_collection(
|
||||
_make_smartctl(10_000_000, 8_000_000),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(first_at),
|
||||
)
|
||||
second = run_collection(
|
||||
_make_smartctl(10_000_010, 8_000_004),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(second_at),
|
||||
)
|
||||
|
||||
assert first["ok"] and second["ok"]
|
||||
conn = sqlite3.connect(store)
|
||||
summary = query_local_day_summary(conn, "2026-09-01")
|
||||
|
||||
assert summary is not None
|
||||
assert summary["bytes_written"] == 5_120_000
|
||||
assert summary["bytes_read"] == 2_048_000
|
||||
assert summary["segments"] == [{
|
||||
"segment_id": 1,
|
||||
"bytes_written": 5_120_000,
|
||||
"bytes_read": 2_048_000,
|
||||
"activity_seconds": 120,
|
||||
"activity_intervals": 1,
|
||||
}]
|
||||
segment_totals = conn.execute(
|
||||
"SELECT segment_id, bytes_written, bytes_read, activity_intervals "
|
||||
"FROM local_day_segment_totals"
|
||||
).fetchone()
|
||||
assert segment_totals == (1, 5_120_000, 2_048_000, 1)
|
||||
|
||||
samples = conn.execute(
|
||||
"SELECT id, ts, bytes_written, bytes_read, local_tz "
|
||||
"FROM samples ORDER BY id"
|
||||
).fetchall()
|
||||
first_sample, second_sample = samples
|
||||
assert record_local_activity_interval(
|
||||
conn,
|
||||
dict(zip(("id", "ts", "bytes_written", "bytes_read", "local_tz"), first_sample)),
|
||||
dict(zip(("id", "ts", "bytes_written", "bytes_read", "local_tz"), second_sample)),
|
||||
start_sample_id=first_sample[0],
|
||||
end_sample_id=second_sample[0],
|
||||
segment_id=1,
|
||||
) == "known"
|
||||
repeated = query_local_day_summary(conn, "2026-09-01", "Asia/Kolkata")
|
||||
assert repeated["bytes_written"] == 5_120_000
|
||||
assert repeated["bytes_read"] == 2_048_000
|
||||
assert conn.execute(
|
||||
"SELECT SUM(bytes_written), SUM(bytes_read), SUM(activity_intervals) "
|
||||
"FROM local_day_segment_totals"
|
||||
).fetchone() == (5_120_000, 2_048_000, 1)
|
||||
conn.close()
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
(
|
||||
"first_at", "second_at", "local_date", "expected_hours",
|
||||
"expected_start", "expected_end", "expected_offset",
|
||||
),
|
||||
[
|
||||
(
|
||||
datetime(2026, 3, 8, 6, 30, tzinfo=timezone.utc),
|
||||
datetime(2026, 3, 8, 7, 30, tzinfo=timezone.utc),
|
||||
"2026-03-08", 23,
|
||||
"2026-03-08T05:00:00+00:00",
|
||||
"2026-03-09T04:00:00+00:00", "-05:00",
|
||||
),
|
||||
(
|
||||
datetime(2026, 11, 1, 5, 30, tzinfo=timezone.utc),
|
||||
datetime(2026, 11, 1, 6, 30, tzinfo=timezone.utc),
|
||||
"2026-11-01", 25,
|
||||
"2026-11-01T04:00:00+00:00",
|
||||
"2026-11-02T05:00:00+00:00", "-04:00",
|
||||
),
|
||||
],
|
||||
ids=("spring-forward", "fall-back-repeated-hour"),
|
||||
)
|
||||
def test_collector_retains_exact_interval_on_dst_local_day(
|
||||
self,
|
||||
tmp_path,
|
||||
sysfs_tree,
|
||||
monkeypatch,
|
||||
first_at,
|
||||
second_at,
|
||||
local_date,
|
||||
expected_hours,
|
||||
expected_start,
|
||||
expected_end,
|
||||
expected_offset,
|
||||
):
|
||||
"""Collection preserves exact activity on short and long local days."""
|
||||
from fenris.collector import run_collection
|
||||
|
||||
zone = "America/New_York"
|
||||
monkeypatch.setenv("TZ", zone)
|
||||
store = str(tmp_path / "obs.db")
|
||||
cfg = {"device": "/dev/nvme0", "store_path": store}
|
||||
sysfs_nvme = sysfs_tree / "sys" / "class" / "nvme" / "nvme0"
|
||||
assert run_collection(
|
||||
_make_smartctl(10_000_000, 8_000_000),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(first_at),
|
||||
)["ok"]
|
||||
assert run_collection(
|
||||
_make_smartctl(10_000_001, 8_000_002),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(second_at),
|
||||
)["ok"]
|
||||
|
||||
conn = sqlite3.connect(store)
|
||||
summary = query_local_day_summary(
|
||||
conn, local_date, zone, second_at + timedelta(minutes=1)
|
||||
)
|
||||
assert summary is not None
|
||||
assert summary["bytes_written"] == 512_000
|
||||
assert summary["bytes_read"] == 1_024_000
|
||||
assert summary["activity_seconds"] == 3_600
|
||||
assert summary["utc_start"] == expected_start
|
||||
assert summary["utc_end"] == expected_end
|
||||
assert summary["tz_offset"] == expected_offset
|
||||
assert (
|
||||
datetime.fromisoformat(summary["utc_end"])
|
||||
- datetime.fromisoformat(summary["utc_start"])
|
||||
).total_seconds() == expected_hours * 3_600
|
||||
conn.close()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_local_midnight_interval_is_shared_once(
|
||||
self, tmp_path, sysfs_tree, monkeypatch,
|
||||
):
|
||||
"""A real counter interval crossing local midnight stays unallocated."""
|
||||
from fenris.collector import run_collection
|
||||
|
||||
monkeypatch.setenv("TZ", "Asia/Kolkata")
|
||||
store = str(tmp_path / "obs.db")
|
||||
cfg = {"device": "/dev/nvme0", "store_path": store}
|
||||
sysfs_nvme = sysfs_tree / "sys" / "class" / "nvme" / "nvme0"
|
||||
first_at = datetime(2026, 9, 1, 18, 25, tzinfo=timezone.utc)
|
||||
second_at = datetime(2026, 9, 1, 18, 35, tzinfo=timezone.utc)
|
||||
|
||||
first = run_collection(
|
||||
_make_smartctl(10_000_000, 8_000_000),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(first_at),
|
||||
)
|
||||
second = run_collection(
|
||||
_make_smartctl(10_000_100, 8_000_060),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(second_at),
|
||||
)
|
||||
assert first["ok"] and second["ok"]
|
||||
|
||||
conn = sqlite3.connect(store)
|
||||
evidence = conn.execute(
|
||||
"SELECT COUNT(*), SUM(bytes_written), SUM(bytes_read) "
|
||||
"FROM local_day_unallocated_evidence"
|
||||
).fetchone()
|
||||
assert evidence == (1, 51_200_000, 30_720_000)
|
||||
assert conn.execute(
|
||||
"SELECT SUM(bytes_written), SUM(bytes_read) FROM local_days"
|
||||
).fetchone() == (0, 0)
|
||||
|
||||
for local_date in ("2026-09-01", "2026-09-02"):
|
||||
summary = query_local_day_summary(
|
||||
conn, local_date, "Asia/Kolkata", second_at
|
||||
)
|
||||
assert summary is not None
|
||||
assert summary["bytes_written"] is None
|
||||
assert summary["shared_bytes_written"] == 51_200_000
|
||||
assert summary["shared_bytes_read"] == 30_720_000
|
||||
assert summary["activity_state"] in ("incomplete", "so_far")
|
||||
conn.close()
|
||||
|
||||
from fenris.status import read_status
|
||||
from fenris.tui import FenrisTuiApp
|
||||
|
||||
app = FenrisTuiApp(store_path=Path(store), refresh_interval_s=999)
|
||||
async with app.run_test(size=(100, 32)):
|
||||
app._browse_date = "2026-09-02"
|
||||
with read_status(
|
||||
Path(store), second_at, query_services=False
|
||||
) as (reader, _):
|
||||
assert reader is not None
|
||||
app._render_local_day(reader)
|
||||
visible = str(app.query_one("#local-day").render())
|
||||
assert "2026-09-02" in visible
|
||||
assert "Asia/Kolkata +05:30" in visible
|
||||
assert "W unavailable" in visible
|
||||
assert "shared at midnight W 0.051 GB" in visible
|
||||
|
||||
def test_synthetic_shared_bytes_conserve_one_hundred_bytes(self, tmp_path):
|
||||
"""Shared evidence conserves byte values before display rounding."""
|
||||
conn = init_store(tmp_path / "obs.db")
|
||||
first_at = datetime(2026, 9, 1, 18, 25, tzinfo=timezone.utc)
|
||||
second_at = datetime(2026, 9, 3, 18, 35, tzinfo=timezone.utc)
|
||||
ensure_period_open(conn, first_at)
|
||||
conn.execute(
|
||||
"INSERT INTO samples (ts, device, bytes_written, bytes_read, local_tz) "
|
||||
"VALUES (?, ?, ?, ?, ?)",
|
||||
(first_at.isoformat(), "/dev/nvme0", 1_000, 2_000, "Asia/Kolkata"),
|
||||
)
|
||||
first_id = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
|
||||
conn.execute(
|
||||
"INSERT INTO samples (ts, device, bytes_written, bytes_read, local_tz) "
|
||||
"VALUES (?, ?, ?, ?, ?)",
|
||||
(second_at.isoformat(), "/dev/nvme0", 1_100, 2_050, "Asia/Kolkata"),
|
||||
)
|
||||
second_id = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
|
||||
|
||||
result = record_local_activity_interval(
|
||||
conn,
|
||||
{
|
||||
"id": first_id,
|
||||
"ts": first_at.isoformat(),
|
||||
"bytes_written": 1_000,
|
||||
"bytes_read": 2_000,
|
||||
"local_tz": "Asia/Kolkata",
|
||||
},
|
||||
{
|
||||
"id": second_id,
|
||||
"ts": second_at.isoformat(),
|
||||
"bytes_written": 1_100,
|
||||
"bytes_read": 2_050,
|
||||
"local_tz": "Asia/Kolkata",
|
||||
},
|
||||
start_sample_id=first_id,
|
||||
end_sample_id=second_id,
|
||||
segment_id=1,
|
||||
)
|
||||
|
||||
assert result == "local_midnight"
|
||||
stored = conn.execute(
|
||||
"SELECT COUNT(*), SUM(bytes_written), SUM(bytes_read) "
|
||||
"FROM local_day_unallocated_evidence"
|
||||
).fetchone()
|
||||
assert stored == (1, 100, 50)
|
||||
record_local_activity_interval(
|
||||
conn,
|
||||
{
|
||||
"id": first_id,
|
||||
"ts": first_at.isoformat(),
|
||||
"bytes_written": 1_000,
|
||||
"bytes_read": 2_000,
|
||||
"local_tz": "Asia/Kolkata",
|
||||
},
|
||||
{
|
||||
"id": second_id,
|
||||
"ts": second_at.isoformat(),
|
||||
"bytes_written": 1_100,
|
||||
"bytes_read": 2_050,
|
||||
"local_tz": "Asia/Kolkata",
|
||||
},
|
||||
start_sample_id=first_id,
|
||||
end_sample_id=second_id,
|
||||
segment_id=1,
|
||||
)
|
||||
assert conn.execute(
|
||||
"SELECT COUNT(*), SUM(bytes_written), SUM(bytes_read) "
|
||||
"FROM local_day_unallocated_evidence"
|
||||
).fetchone() == (1, 100, 50)
|
||||
assert conn.execute(
|
||||
"SELECT SUM(bytes_written), SUM(bytes_read) FROM local_days"
|
||||
).fetchone() == (0, 0)
|
||||
middle_day = query_local_day_summary(
|
||||
conn, "2026-09-03", "Asia/Kolkata", second_at + timedelta(days=1)
|
||||
)
|
||||
assert middle_day["shared_bytes_written"] == 100
|
||||
assert middle_day["shared_bytes_read"] == 50
|
||||
assert middle_day["shared_evidence_count"] == 1
|
||||
conn.close()
|
||||
|
||||
def test_timezone_change_keeps_interval_unallocated(
|
||||
self, tmp_path, sysfs_tree, monkeypatch,
|
||||
):
|
||||
from fenris.collector import run_collection
|
||||
|
||||
store = str(tmp_path / "obs.db")
|
||||
cfg = {"device": "/dev/nvme0", "store_path": store}
|
||||
sysfs_nvme = sysfs_tree / "sys" / "class" / "nvme" / "nvme0"
|
||||
first_at = datetime(2026, 9, 1, 22, 0, tzinfo=timezone.utc)
|
||||
second_at = datetime(2026, 9, 1, 22, 5, tzinfo=timezone.utc)
|
||||
|
||||
monkeypatch.setenv("TZ", "UTC")
|
||||
assert run_collection(
|
||||
_make_smartctl(10_000_000, 8_000_000),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(first_at),
|
||||
)["ok"]
|
||||
monkeypatch.setenv("TZ", "Asia/Kolkata")
|
||||
assert run_collection(
|
||||
_make_smartctl(10_000_010, 8_000_004),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(second_at),
|
||||
)["ok"]
|
||||
|
||||
conn = sqlite3.connect(store)
|
||||
event = conn.execute(
|
||||
"SELECT COUNT(*), SUM(bytes_written), MIN(reason) "
|
||||
"FROM local_day_unallocated_evidence"
|
||||
).fetchone()
|
||||
assert event == (1, 5_120_000, "timezone_change")
|
||||
old_zone = query_local_day_summary(conn, "2026-09-01", "UTC")
|
||||
new_zone = query_local_day_summary(conn, "2026-09-02", "Asia/Kolkata")
|
||||
assert old_zone["bytes_written"] is None
|
||||
assert new_zone["bytes_written"] is None
|
||||
assert old_zone["unallocated_bytes_written"] == 5_120_000
|
||||
assert new_zone["unallocated_bytes_written"] == 5_120_000
|
||||
conn.close()
|
||||
|
||||
def test_pause_boundary_keeps_interval_unallocated(
|
||||
self, tmp_path, sysfs_tree, monkeypatch,
|
||||
):
|
||||
from fenris.collector import run_collection
|
||||
|
||||
monkeypatch.setenv("TZ", "UTC")
|
||||
store = str(tmp_path / "obs.db")
|
||||
cfg = {"device": "/dev/nvme0", "store_path": store}
|
||||
sysfs_nvme = sysfs_tree / "sys" / "class" / "nvme" / "nvme0"
|
||||
first_at = datetime(2026, 9, 1, 12, 0, tzinfo=timezone.utc)
|
||||
second_at = datetime(2026, 9, 1, 12, 10, tzinfo=timezone.utc)
|
||||
assert run_collection(
|
||||
_make_smartctl(10_000_000, 8_000_000),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(first_at),
|
||||
)["ok"]
|
||||
|
||||
conn = sqlite3.connect(store)
|
||||
close_period(conn, first_at + timedelta(minutes=5), "user_disabled")
|
||||
conn.close()
|
||||
|
||||
assert run_collection(
|
||||
_make_smartctl(10_000_010, 8_000_004),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(second_at),
|
||||
)["ok"]
|
||||
|
||||
conn = sqlite3.connect(store)
|
||||
reason = conn.execute(
|
||||
"SELECT reason FROM local_day_unallocated_evidence"
|
||||
).fetchone()
|
||||
summary = query_local_day_summary(conn, "2026-09-01", "UTC")
|
||||
assert reason == ("monitoring_period",)
|
||||
assert summary["bytes_written"] is None
|
||||
assert summary["unallocated_bytes_written"] == 5_120_000
|
||||
assert summary["shared_bytes_written"] == 0
|
||||
conn.close()
|
||||
|
||||
def test_controller_segment_boundary_marks_local_activity_incomplete(
|
||||
self, tmp_path, sysfs_tree, monkeypatch,
|
||||
):
|
||||
from fenris.collector import run_collection
|
||||
|
||||
monkeypatch.setenv("TZ", "UTC")
|
||||
store = str(tmp_path / "obs.db")
|
||||
cfg = {"device": "/dev/nvme0", "store_path": store}
|
||||
sysfs_nvme = sysfs_tree / "sys" / "class" / "nvme" / "nvme0"
|
||||
first_at = datetime(2026, 9, 1, 12, 0, tzinfo=timezone.utc)
|
||||
second_at = datetime(2026, 9, 1, 12, 5, tzinfo=timezone.utc)
|
||||
assert run_collection(
|
||||
_make_smartctl(10_000_000, 8_000_000),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(first_at),
|
||||
)["ok"]
|
||||
assert run_collection(
|
||||
_make_smartctl(10, 8_000_004),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(second_at),
|
||||
)["ok"]
|
||||
|
||||
conn = sqlite3.connect(store)
|
||||
summary = query_local_day_summary(
|
||||
conn, "2026-09-01", "UTC", second_at
|
||||
)
|
||||
assert summary is not None
|
||||
assert summary["bytes_written"] is None
|
||||
assert summary["activity_state"] == "incomplete"
|
||||
assert conn.execute(
|
||||
"SELECT COUNT(*) FROM local_day_unallocated_evidence"
|
||||
).fetchone()[0] == 0
|
||||
conn.close()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# DST handling (23/25-hour days)
|
||||
@@ -402,17 +853,72 @@ class TestDSTHandling:
|
||||
# Simulate a 23-hour day in a timezone with DST
|
||||
# For simplicity, just verify the summary records the correct UTC range
|
||||
clock = datetime(2026, 3, 8, 12, 0, 0, tzinfo=timezone.utc)
|
||||
# US/Eastern springs forward on 2026-03-08
|
||||
# New York springs forward on 2026-03-08
|
||||
# Local day 2026-03-08 is 23 hours: UTC [07:00, 06:00+1d)
|
||||
_insert_hour(conn, "2026-03-08T08:00:00+00:00", bw=100, active=3600)
|
||||
_insert_hour(conn, "2026-03-08T12:00:00+00:00", bw=200, active=3600)
|
||||
|
||||
summary = derive_local_day_summary(conn, "US/Eastern", clock)
|
||||
summary = derive_local_day_summary(conn, "America/New_York", clock)
|
||||
assert summary is not None
|
||||
assert summary.local_date == "2026-03-08"
|
||||
# UTC range should be approximately 23 hours
|
||||
utc_start = datetime.fromisoformat(summary.utc_start)
|
||||
utc_end = datetime.fromisoformat(summary.utc_end)
|
||||
duration = (utc_end - utc_start).total_seconds()
|
||||
assert 22 * 3600 <= duration <= 24 * 3600 # ~23h ± tolerance
|
||||
assert duration == 23 * 3600
|
||||
conn.close()
|
||||
|
||||
def test_long_day_25_hours(self):
|
||||
from fenris.local_day import local_day_boundaries
|
||||
|
||||
start, end, offset = local_day_boundaries(
|
||||
"2026-11-01", "America/New_York"
|
||||
)
|
||||
assert (end - start).total_seconds() == 25 * 3600
|
||||
assert offset == "-04:00"
|
||||
|
||||
def test_half_hour_offset_records_exact_local_boundaries(self):
|
||||
from fenris.local_day import local_day_boundaries
|
||||
|
||||
start, end, offset = local_day_boundaries(
|
||||
"2026-09-01", "Asia/Kolkata"
|
||||
)
|
||||
assert start.isoformat() == "2026-08-31T18:30:00+00:00"
|
||||
assert end.isoformat() == "2026-09-01T18:30:00+00:00"
|
||||
assert offset == "+05:30"
|
||||
|
||||
def test_repeated_local_clock_labels_remain_one_recorded_day(
|
||||
self, tmp_path, sysfs_tree, monkeypatch,
|
||||
):
|
||||
from fenris.collector import run_collection
|
||||
|
||||
monkeypatch.setenv("TZ", "America/New_York")
|
||||
store = str(tmp_path / "obs.db")
|
||||
cfg = {"device": "/dev/nvme0", "store_path": store}
|
||||
sysfs_nvme = sysfs_tree / "sys" / "class" / "nvme" / "nvme0"
|
||||
# Both endpoints display as 01:30 locally, on opposite UTC offsets.
|
||||
first_at = datetime(2026, 11, 1, 5, 30, tzinfo=timezone.utc)
|
||||
second_at = datetime(2026, 11, 1, 6, 30, tzinfo=timezone.utc)
|
||||
assert run_collection(
|
||||
_make_smartctl(10_000_000, 8_000_000),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(first_at),
|
||||
)["ok"]
|
||||
assert run_collection(
|
||||
_make_smartctl(10_000_001, 8_000_002),
|
||||
sysfs_nvme,
|
||||
cfg,
|
||||
_Clock(second_at),
|
||||
)["ok"]
|
||||
|
||||
conn = sqlite3.connect(store)
|
||||
summary = query_local_day_summary(
|
||||
conn, "2026-11-01", "America/New_York", second_at
|
||||
)
|
||||
assert summary is not None
|
||||
assert summary["bytes_written"] == 512_000
|
||||
assert summary["bytes_read"] == 1_024_000
|
||||
assert summary["utc_start"] == "2026-11-01T04:00:00+00:00"
|
||||
assert summary["utc_end"] == "2026-11-02T05:00:00+00:00"
|
||||
conn.close()
|
||||
|
||||
Reference in New Issue
Block a user