152 lines
8.6 KiB
Python
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()
|