chore: Organized all test scripts into a dedicated tests/ package

tests/test_config.py

@@ -0,0 +1,18 @@
+import sys
+
+def test_imports():
+    try:
+        import ultralytics
+        import cv2
+        import PIL
+        import folium
+        print(f"Ultralytics installed successfully: {ultralytics.__version__}")
+        assert ultralytics.__version__ == '8.2.18', "YOLO Version mismatch"
+        print("Initialization successful.")
+    except Exception as e:
+        print(f"Error during initialization: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    test_imports()
+    print("ALL TESTS PASSED")

tests/test_detector.py

@@ -0,0 +1,47 @@
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import urllib.request
+import numpy as np
+import cv2
+from detector import PotholeDetector
+
+def test_singleton():
+    """Assert singleton prevents memory bloat by persisting strict memory addresses"""
+    det1 = PotholeDetector.get_instance("yolov8n.pt")
+    det2 = PotholeDetector.get_instance("yolov8n.pt")
+    assert det1 is det2, "Singleton instantiation routing failed structurally."
+    print("test_singleton passed.")
+
+def test_inference_shape_and_bgr():
+    """Assert dictionary structures natively mapping BGR and asserting BGR performs distinct from RGB natively."""
+    det = PotholeDetector.get_instance("yolov8n.pt")
+    
+    url = "https://ultralytics.com/images/zidane.jpg"
+    req = urllib.request.urlopen(url)
+    arr = np.asarray(bytearray(req.read()), dtype=np.uint8)
+    img_bgr = cv2.imdecode(arr, -1)  # BGR natively read
+    
+    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+    
+    # Process dynamically natively evaluating constraints natively
+    results_bgr = det.predict(img_bgr, conf_thresh=0.25)
+    results_rgb = det.predict(img_rgb, conf_thresh=0.25)
+    
+    assert isinstance(results_bgr, list), "Output casting payload failed structurally natively."
+    if len(results_bgr) > 0:
+        keys = list(results_bgr[0].keys())
+        assert 'xyxy' in keys and 'confidence' in keys and 'class_id' in keys, "Dictionary boundary keys mismatch."
+    
+    conf_bgr = results_bgr[0]['confidence'] if results_bgr else 0.0
+    conf_rgb = results_rgb[0]['confidence'] if results_rgb else 0.0
+    
+    # Assuming BGR provides exact precision vs RGB variant physically evaluating bounds natively
+    assert conf_bgr != conf_rgb, "Color space translation did not structurally impact physical YOLO tensor bindings (BGR vs RGB)."
+    print("test_inference_shape_and_bgr passed.")
+
+if __name__ == "__main__":
+    test_singleton()
+    test_inference_shape_and_bgr()
+    print("ALL DETECTOR TESTS PASSED")

tests/test_gps.py

@@ -0,0 +1,58 @@
+import os
+import csv
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+from gps import dms_to_decimal, extract_gps_simple, find_nearest_gps, load_gps_log
+
+def test_dms_to_decimal():
+    """Validates mathematical tuple translations natively scaling numeric ranges."""
+    # Standard DMS tuple format mapping
+    tup = ((34, 1), (3, 1), (8, 1))
+    val_n = dms_to_decimal(tup, 'N')
+    assert abs(val_n - 34.052222) < 0.0001, "Positive DMS conversion calculation failed natively."
+    
+    val_w = dms_to_decimal(tup, 'W')
+    assert val_w < 0, "Negative directional scaling failed natively for longitude conversion."
+    
+    # Flat number failure mode test bridging mapping
+    val_flat = dms_to_decimal(34.0522, 'N')
+    assert val_flat == 34.0522, "Non-standard flat EXIF mapping conversion calculation failed natively."
+    print("test_dms_to_decimal passed.")
+
+def test_load_gps_log():
+    """Verify loading constraints targeting dynamic IO boundaries via mock structural datasets."""
+    export_path = Path("test_gps_log.csv")
+    with export_path.open('w', newline='', encoding='utf-8') as f:
+        writer = csv.DictWriter(f, fieldnames=['timestamp', 'latitude', 'longitude'])
+        writer.writeheader()
+        writer.writerow({'timestamp': '2026-04-05T12:00:00', 'latitude': '34.0', 'longitude': '-118.0'})
+        writer.writerow({'timestamp': '2026-04-05T12:05:00', 'latitude': '34.1', 'longitude': '-118.1'})
+        
+    data = load_gps_log(export_path)
+    assert len(data) == 2, "Array length generation bounding issue."
+    assert data[0]['latitude'] == 34.0, "Parsing type casting boundary issue resolving floats physically."
+    
+    export_path.unlink()
+    print("test_load_gps_log passed.")
+
+def test_find_nearest_gps():
+    """Assert minimum bridging bounding gap searches properly evaluate chronology distances natively."""
+    mock_log = [
+        {'timestamp': '2026-04-05T12:00:00', 'latitude': 34.0, 'longitude': -118.0},
+        {'timestamp': '2026-04-05T12:05:00', 'latitude': 34.1, 'longitude': -118.1},
+        {'timestamp': '2026-04-05T12:10:00', 'latitude': 34.2, 'longitude': -118.2}
+    ]
+    
+    # Target precisely in between index 0 and 1, closer to 1
+    target_ts = '2026-04-05T12:02:35'
+    nearest = find_nearest_gps(target_ts, mock_log)
+    
+    assert nearest['latitude'] == 34.1, "Closest relative bounding gap calculation routing execution structurally failed natively."
+    print("test_find_nearest_gps passed.")
+
+if __name__ == "__main__":
+    test_dms_to_decimal()
+    test_load_gps_log()
+    test_find_nearest_gps()
+    print("ALL GPS TESTS PASSED")

tests/test_utils.py

@@ -0,0 +1,62 @@
+import numpy as np
+import base64
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+from utils import draw_boxes, image_to_base64, export_csv
+
+def test_draw_boxes():
+    """Test standard bounding box drawing alters the matrix"""
+    blank_img = np.zeros((100, 100, 3), dtype=np.uint8)
+    
+    detections = [
+        {'xyxy': [10, 10, 50, 50], 'confidence': 0.95, 'class_id': 0}
+    ]
+    
+    annotated = draw_boxes(blank_img, detections)
+    
+    assert not np.array_equal(blank_img, annotated), "Annotated image matches blank image; drawing failed."
+    print("test_draw_boxes passed.")
+
+def test_image_to_base64():
+    """Test image matrix converts robustly to base64 encoding sequences"""
+    blank_img = np.zeros((50, 50, 3), dtype=np.uint8)
+    b64_str = image_to_base64(blank_img)
+    
+    assert isinstance(b64_str, str) and len(b64_str) > 0, "Base64 encoding failed; empty or wrong type returned."
+    
+    decoded_bytes = base64.b64decode(b64_str)
+    assert len(decoded_bytes) > 0, "Decoded bytes are empty; padding issue potentially."
+    print("test_image_to_base64 passed.")
+
+def test_export_csv():
+    """Test rigorous external path creation logic and file integrity checking"""
+    detections = [
+        {'filename': 'test1.jpg', 'confidence': 0.9, 'latitude': 34.0, 'longitude': -118.0},
+        {'filename': 'test2.jpg', 'confidence': 0.8, 'latitude': 34.1, 'longitude': -118.1}
+    ]
+    
+    import tempfile
+    
+    # Store directly in a Path container natively to meet restrictions
+    export_path = Path("test_output.csv")
+    export_csv(detections, export_path)
+    
+    assert export_path.exists(), "CSV file was not successfully created."
+    
+    with export_path.open('r', encoding='utf-8') as f:
+        content = f.read()
+        
+        # Test accurate schema and value integrity locally
+        assert "filename" in content and "confidence" in content, "CSV headers missing from body."
+        assert "test1.jpg" in content and "0.9" in content, "CSV body row is missing expected data slice."
+        
+    # Flush explicit testing payload back
+    export_path.unlink()
+    print("test_export_csv passed.")
+
+if __name__ == "__main__":
+    test_draw_boxes()
+    test_image_to_base64()
+    test_export_csv()
+    print("ALL UTILS TESTS PASSED")