droboticflow/tests/backend/test_raw_human_normalizer.py

152 lines
8.6 KiB
Python

import json
from types import SimpleNamespace
import pytest
from backend.operators.builtin.orbbec_data_normalize import operator as op
def test_raw_profile_validates_original_files_without_modifying_them(tmp_path, monkeypatch):
contents = {
"capture_camera_left_part0001.mp4": "video",
"capture_camera_left_part0001_pts.csv": "timestamp_us\n100\n200\n",
"capture_imu_part0001.csv": "timestamp_us,x,y,z,type\n90,0,0,1,accel\n90,0,0,1,gyro\n210,0,0,1,accel\n210,0,0,1,gyro\n",
"meta_capture.json": json.dumps({"streams":{"color_left":{"segments":[{"index":1,"frame_count":2}]}}}),
}
entries=[]
for name,text in contents.items():
path=tmp_path/name;path.write_text(text);entries.append({"path":name,"source":{"path":str(path)}})
monkeypatch.setattr(op.subprocess,"run",lambda *a,**k:SimpleNamespace(stdout='{"streams":[{"nb_read_frames":"2","duration":"0.2"}]}',stderr=""))
name="capture_camera_left_part0001.mp4";pairs=op._paired_files(name,entries)
result=op._validate_fallback_pair(name,pairs,entries,str(tmp_path),tmp_path,{"PROCESSING_PROFILE":"raw_human"},{})
assert result["sourceDurationSeconds"]==0.2
assert all((tmp_path/name).read_text()==text for name,text in contents.items())
assert op._validate_fallback_pair(name,pairs,entries,str(tmp_path),tmp_path,{}, {}) is None
@pytest.mark.parametrize("side", ["left", "right"])
def test_raw_profile_checks_imu_content_without_requiring_part_boundary_coverage(tmp_path, monkeypatch, side):
name = f"capture_camera_{side}_part0006_silent_480p_wm.mp4"
pts_name = f"capture_camera_{side}_part0006_pts.csv"
imu_name = "capture_imu_part0006.csv"
# Real part0006 boundaries: last video frame extends 3.471/3.472 ms
# beyond this part's IMU. The next samples belong to part0007.
end = 5647003209 if side == "left" else 5647003210
contents = {
name: "video",
pts_name: f"timestamp_us\n4747034637\n{end}\n",
imu_name: "timestamp_us,x,y,z,type\n4747000287,0,0,1,accel\n4747000287,0,0,1,gyro\n5646999738,0,0,1,accel\n5646999738,0,0,1,gyro\n",
}
entries = []
for filename, text in contents.items():
path = tmp_path / filename
path.write_text(text)
entries.append({"path": filename, "source": {"path": str(path)}})
monkeypatch.setattr(op.subprocess, "run", lambda *a, **k: SimpleNamespace(
stdout='{"streams":[{"nb_read_frames":"2","duration":"900"}]}', stderr=""))
pairs = op._paired_files(name, entries)
validate = lambda: op._validate_fallback_pair(
name, pairs, entries, str(tmp_path), tmp_path, {"PROCESSING_PROFILE": "raw_human"}, {})
assert validate()["endTimestampUs"] == end
assert all((tmp_path / filename).read_text() == text for filename, text in contents.items())
# Part boundary tolerance does not bypass content or video/PTS validation.
(tmp_path / imu_name).write_text(contents[imu_name].replace(",gyro\n", ",gyr\n"))
with pytest.raises(RuntimeError, match="类型无效"):
validate()
(tmp_path / imu_name).write_text(contents[imu_name])
(tmp_path / pts_name).write_text(f"timestamp_us\n4747034637\n5000000000\n{end}\n")
with pytest.raises(RuntimeError, match="视频与 PTS 数量不一致"):
validate()
(tmp_path / pts_name).write_text("timestamp_us\n4747034637\n4747034637\n")
with pytest.raises(RuntimeError, match="未严格递增"):
validate()
(tmp_path / pts_name).write_text(contents[pts_name])
pairs["imu"] = ""
with pytest.raises(RuntimeError, match="缺少 IMU"):
validate()
def _meta_fixture(tmp_path, segments, side="left"):
name = f"part0001/capture_camera_{side}_part0001_silent_480p_wm.mp4"
contents = {
name: "video",
f"part0001/capture_camera_{side}_part0001_pts.csv": "timestamp_us\n100\n200\n",
"part0001/capture_imu_part0001.csv": "timestamp_us,x,y,z,type\n90,0,0,1,accel\n90,0,0,1,gyro\n190,0,0,1,accel\n190,0,0,1,gyro\n",
"meta_capture.json": json.dumps({"streams": {f"color_{side}": {"segments": segments}}}),
}
entries = []
for filename, text in contents.items():
path = tmp_path / filename
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(text)
entries.append({"path": filename, "source": {"path": str(path)}})
return name, entries, contents
@pytest.mark.parametrize("side", ["left", "right"])
@pytest.mark.parametrize("reverse", [False, True])
def test_meta_selects_capture_identity_not_duplicate_part_index(tmp_path, monkeypatch, side, reverse):
segments = [
{"index": 1, "file": f"part0001/previous_camera_{side}_part0001.mp4", "frame_count": 7890},
{"index": 1, "file": f"part0001/capture_camera_{side}_part0001.mp4", "pts_file": f"part0001/capture_camera_{side}_part0001_pts.csv", "frame_count": 2},
]
name, entries, contents = _meta_fixture(tmp_path, segments[::-1] if reverse else segments, side)
monkeypatch.setattr(op.subprocess, "run", lambda *a, **k: SimpleNamespace(stdout='{"streams":[{"nb_read_frames":"2"}]}', stderr=""))
result = op._validate_fallback_pair(name, op._paired_files(name, entries), entries, str(tmp_path), tmp_path, {"PROCESSING_PROFILE": "raw_human"}, {})
assert result["ptsRows"] == 2
assert all((tmp_path / file).read_text() == text for file, text in contents.items())
@pytest.mark.parametrize("segments,error", [
([{"index": 1, "file": "other_camera_left_part0001.mp4", "frame_count": 2}], "匹配失败"),
([{"index": 1, "file": "capture_camera_right_part0001.mp4", "frame_count": 2}], "匹配失败"),
([{"index": 1, "file": "capture_camera_left_part0002.mp4", "frame_count": 2}], "匹配失败"),
([{"index": 1, "file": "capture_camera_left_part0001.mp4", "pts_file": "other_camera_left_part0001_pts.csv", "frame_count": 2}], "匹配失败"),
([{"index": 1, "file": "capture_camera_left_part0001.mp4", "frame_count": 2}] * 2, "不唯一"),
([{"index": 1, "frame_count": 2}] * 2, "不唯一"),
([{"index": 1, "file": "other_camera_left_part0001.mp4", "frame_count": 2}, {"index": 1, "frame_count": 2}], "匹配失败"),
([{"index": 1, "file": "capture_camera_left_part0001.mp4", "frame_count": 3}], "meta 与 PTS"),
])
def test_meta_does_not_guess_or_bypass_validation(tmp_path, monkeypatch, segments, error):
name, entries, _ = _meta_fixture(tmp_path, segments)
monkeypatch.setattr(op.subprocess, "run", lambda *a, **k: SimpleNamespace(stdout='{"streams":[{"nb_read_frames":"2"}]}', stderr=""))
with pytest.raises(RuntimeError, match=error):
op._validate_fallback_pair(name, op._paired_files(name, entries), entries, str(tmp_path), tmp_path, {"PROCESSING_PROFILE": "raw_human"}, {})
def test_meta_identity_with_real_video_decode(tmp_path):
import shutil
import subprocess
if not shutil.which("ffmpeg") or not shutil.which("ffprobe"):
pytest.skip("ffmpeg/ffprobe required")
name, entries, contents = _meta_fixture(tmp_path, [
{"index": 1, "file": "old_camera_left_part0001.mp4", "frame_count": 7890},
{"index": 1, "file": "capture_camera_left_part0001.mp4", "frame_count": 2},
])
subprocess.run(["ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "color=c=black:s=32x32:r=30", "-frames:v", "2", "-c:v", "mpeg4", str(tmp_path / name)], check=True)
result = op._validate_fallback_pair(name, op._paired_files(name, entries), entries, str(tmp_path), tmp_path, {"PROCESSING_PROFILE": "raw_human"}, {})
assert result["videoFrames"] == result["ptsRows"] == 2
for file, text in contents.items():
if file != name:
assert (tmp_path / file).read_text() == text
def test_meta_pts_identity_and_legacy_compatibility():
video = "part0001/capture_camera_left_part0001_silent_480p_wm.mp4"
for records in [
[{"index": "1", "frame_count": "2"}],
[{"index": 1, "pts_file": "part0001/capture_camera_left_part0001_pts.csv", "frame_count": 2}],
]:
assert op._meta_frame_count({"streams": {"color_left": {"segments": records}}}, video) == 2
@pytest.mark.parametrize("count", [None, True, False, 0, -1, 2.5, "2.5", "bad"])
def test_invalid_meta_frame_count_stays_blocking(count):
with pytest.raises(RuntimeError, match="帧数记录无效"):
op._meta_frame_count({"streams": {"color_left": {"segments": [{"index": 1, "frame_count": count}]}}}, "capture_camera_left_part0001.mp4")
def test_runtime_repository_matches_backend_normalizer():
from pathlib import Path
root = Path(__file__).resolve().parents[2]
assert (root / "operator-repos/builtin/orbbec_data_normalize/src/operator.py").read_bytes() == Path(op.__file__).read_bytes()