282 lines
11 KiB
Python
282 lines
11 KiB
Python
import os
|
|
import tempfile
|
|
from datetime import timedelta
|
|
|
|
import pytest
|
|
from django.contrib.auth import get_user_model
|
|
from django.core.files import File
|
|
|
|
from locations.models import GeoLocation
|
|
from scrobbles.importers.trail_gpx import (
|
|
compute_trail_stats,
|
|
find_route_waypoint,
|
|
import_trail_gpx,
|
|
parse_trackpoints,
|
|
)
|
|
from scrobbles.models import Scrobble, TrailGPXImport
|
|
from trails.models import Trail, TrailLogData
|
|
|
|
User = get_user_model()
|
|
|
|
SAMPLE_GPX = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "data", "sample_trail.gpx"
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def user(db):
|
|
return User.objects.create(email="trailblazer@example.com")
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_gpx_path():
|
|
return SAMPLE_GPX
|
|
|
|
|
|
class TestParseTrackpoints:
|
|
def test_parses_gpx(self, sample_gpx_path):
|
|
result = parse_trackpoints(sample_gpx_path)
|
|
points = result["points"]
|
|
assert len(points) == 837
|
|
assert result["name"] == "Morning Run ⛅"
|
|
assert result["description"] == "Run"
|
|
lat, lon, ele, t = points[0]
|
|
assert round(lat, 6) == 34.190598
|
|
assert round(lon, 6) == -118.844015
|
|
assert ele == 305.3
|
|
assert t is not None
|
|
|
|
def test_first_and_last_times(self, sample_gpx_path):
|
|
result = parse_trackpoints(sample_gpx_path)
|
|
points = result["points"]
|
|
first_time = points[0][3]
|
|
last_time = points[-1][3]
|
|
duration = (last_time - first_time).total_seconds()
|
|
assert duration == pytest.approx(3770, abs=5)
|
|
|
|
def test_gpx_extra_metadata(self, sample_gpx_path):
|
|
result = parse_trackpoints(sample_gpx_path)
|
|
extra = result["extra"]
|
|
assert extra["avg_heartrate"] == 159
|
|
assert extra["max_heartrate"] == 183
|
|
assert extra["avg_speed_kmh"] == pytest.approx(9.82, abs=0.1)
|
|
assert extra["activity_type"] == "Run"
|
|
assert extra["moving_time_seconds"] == 3008
|
|
assert extra["total_elevation_gain_m"] == 246.4
|
|
|
|
|
|
class TestImportTrailGPX:
|
|
def test_creates_trail(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
assert Trail.objects.filter(title="Morning Run ⛅").exists()
|
|
|
|
def test_creates_geolocation(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
assert GeoLocation.objects.filter(lat=34.190598, lon=-118.844015).exists()
|
|
|
|
def test_sets_trailhead(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
trail = Trail.objects.filter(title="Morning Run ⛅").first()
|
|
assert trail.trailhead_location is not None
|
|
assert round(trail.trailhead_location.lat, 6) == 34.190598
|
|
|
|
def test_creates_scrobble(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
assert Scrobble.objects.filter(source="GPX Import").count() == 1
|
|
|
|
def test_scrobble_timestamps(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
scrobble = Scrobble.objects.filter(source="GPX Import").first()
|
|
assert scrobble.timestamp.isoformat().startswith("2022-06-05T13:55:09")
|
|
assert scrobble.stop_timestamp.isoformat().startswith("2022-06-05T14:57:59")
|
|
assert scrobble.media_type == Scrobble.MediaType.TRAIL
|
|
|
|
def test_scrobble_has_trail_fk(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
scrobble = Scrobble.objects.filter(source="GPX Import").first()
|
|
assert scrobble.trail is not None
|
|
assert scrobble.trail.title == "Morning Run ⛅"
|
|
|
|
def test_scrobble_has_gpx_file(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
scrobble = Scrobble.objects.filter(source="GPX Import").first()
|
|
assert scrobble.gpx_file
|
|
assert scrobble.gpx_file.name.endswith(".gpx")
|
|
|
|
def test_lookup_existing_trail_by_trailhead(self, user, sample_gpx_path):
|
|
geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
|
|
trail = Trail.objects.create(title="Existing Trail", trailhead_location=geo)
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
scrobble = Scrobble.objects.filter(source="GPX Import").first()
|
|
assert scrobble.trail.id == trail.id
|
|
|
|
def test_dedup(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
assert Scrobble.objects.filter(source="GPX Import").count() == 1
|
|
|
|
def test_scrobble_log_has_stats(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
scrobble = Scrobble.objects.filter(source="GPX Import").first()
|
|
log = scrobble.log
|
|
assert log["distance_km"] == pytest.approx(8.2, abs=0.2)
|
|
assert log["elevation_gain_m"] == pytest.approx(260, abs=20)
|
|
assert log["moving_time_seconds"] == pytest.approx(3770, abs=10)
|
|
assert log["avg_speed_kmh"] == pytest.approx(7.8, abs=0.5)
|
|
assert log["description"] == "Run"
|
|
|
|
def test_scrobble_playback_position(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
scrobble = Scrobble.objects.filter(source="GPX Import").first()
|
|
assert scrobble.playback_position_seconds == pytest.approx(3770, abs=5)
|
|
|
|
def test_scrobble_has_timezone(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
scrobble = Scrobble.objects.filter(source="GPX Import").first()
|
|
assert scrobble.timezone is not None
|
|
assert isinstance(scrobble.timezone, str)
|
|
|
|
def test_scrobble_log_extra_metadata(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
scrobble = Scrobble.objects.filter(source="GPX Import").first()
|
|
log = scrobble.log
|
|
assert log["avg_heartrate"] == 159
|
|
assert log["max_heartrate"] == 183
|
|
assert log["activity_type"] == "Run"
|
|
|
|
def test_scrobble_log_no_calories_in_gpx(self, user, sample_gpx_path):
|
|
import_trail_gpx(sample_gpx_path, user.id)
|
|
scrobble = Scrobble.objects.filter(source="GPX Import").first()
|
|
assert scrobble.log.get("calories") is None
|
|
|
|
|
|
class TestComputeTrailStats:
|
|
def test_computes_distance_and_elevation(self, sample_gpx_path):
|
|
result = parse_trackpoints(sample_gpx_path)
|
|
stats = compute_trail_stats(result["points"])
|
|
assert stats["distance_km"] == pytest.approx(8.2, abs=0.2)
|
|
assert stats["elevation_gain_m"] == pytest.approx(260, abs=20)
|
|
assert stats["moving_time_seconds"] == pytest.approx(3770, abs=10)
|
|
assert stats["avg_speed_kmh"] == pytest.approx(7.8, abs=0.5)
|
|
|
|
|
|
class TestTrailGPXImportModel:
|
|
def test_create_import_model(self, db, user, sample_gpx_path):
|
|
imp = TrailGPXImport.objects.create(
|
|
user=user,
|
|
original_filename="test_trail.gpx",
|
|
)
|
|
assert imp.uuid is not None
|
|
assert imp.import_type == "Trail GPX"
|
|
|
|
@pytest.mark.django_db(transaction=True)
|
|
def test_process_via_model(self, user, sample_gpx_path):
|
|
imp = TrailGPXImport.objects.create(
|
|
user=user,
|
|
original_filename="Morning Run.gpx",
|
|
)
|
|
with open(sample_gpx_path, "rb") as f:
|
|
imp.gpx_file.save("Morning Run.gpx", File(f), save=True)
|
|
imp.process()
|
|
imp.refresh_from_db()
|
|
assert imp.process_count == 1
|
|
assert imp.processed_finished is not None
|
|
|
|
|
|
class TestFindRouteWaypoint:
|
|
def test_returns_halfway_point(self, sample_gpx_path):
|
|
result = parse_trackpoints(sample_gpx_path)
|
|
pt = find_route_waypoint(result["points"])
|
|
assert pt is not None
|
|
lat, lon = pt
|
|
assert lat == pytest.approx(34.177853, abs=0.001)
|
|
assert lon == pytest.approx(-118.829944, abs=0.001)
|
|
|
|
def test_returns_last_point_for_short_track(self):
|
|
points = [(34.0, -118.0, None, None), (34.001, -118.001, None, None)]
|
|
pt = find_route_waypoint(points)
|
|
assert pt == (34.001, -118.001)
|
|
|
|
def test_returns_none_for_empty_points(self):
|
|
assert find_route_waypoint([]) is None
|
|
|
|
|
|
class TestFindByTrailhead:
|
|
def test_exact_match(self, db):
|
|
geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
|
|
trail = Trail.objects.create(title="Test Trail", trailhead_location=geo)
|
|
found = Trail.find_by_trailhead(34.190598, -118.844015)
|
|
assert found == trail
|
|
|
|
def test_within_tolerance(self, db):
|
|
geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
|
|
trail = Trail.objects.create(title="Nearby Trail", trailhead_location=geo)
|
|
found = Trail.find_by_trailhead(34.191000, -118.844000, tolerance_m=100)
|
|
assert found == trail
|
|
|
|
def test_beyond_tolerance(self, db):
|
|
geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
|
|
Trail.objects.create(title="Far Trail", trailhead_location=geo)
|
|
found = Trail.find_by_trailhead(34.200000, -118.850000, tolerance_m=50)
|
|
assert found is None
|
|
|
|
def test_no_trailhead_returns_none(self, db):
|
|
Trail.objects.create(title="No Location")
|
|
found = Trail.find_by_trailhead(34.190598, -118.844015)
|
|
assert found is None
|
|
|
|
def test_same_trailhead_same_route_matches(self, db):
|
|
geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
|
|
trail = Trail.objects.create(
|
|
title="Same Route Trail",
|
|
trailhead_location=geo,
|
|
route_lat=34.192167,
|
|
route_lon=-118.843143,
|
|
)
|
|
found = Trail.find_by_trailhead(
|
|
34.190598, -118.844015,
|
|
route_lat=34.192167, route_lon=-118.843143,
|
|
tolerance_m=100,
|
|
)
|
|
assert found == trail
|
|
|
|
def test_same_trailhead_different_route_does_not_match(self, db):
|
|
geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
|
|
Trail.objects.create(
|
|
title="Different Route Trail",
|
|
trailhead_location=geo,
|
|
route_lat=34.200000,
|
|
route_lon=-118.850000,
|
|
)
|
|
found = Trail.find_by_trailhead(
|
|
34.190598, -118.844015,
|
|
route_lat=34.192167, route_lon=-118.843143,
|
|
tolerance_m=100,
|
|
)
|
|
assert found is None
|
|
|
|
def test_legacy_trail_without_route_still_matches(self, db):
|
|
geo = GeoLocation.objects.create(lat=34.190598, lon=-118.844015)
|
|
trail = Trail.objects.create(
|
|
title="Legacy Trail",
|
|
trailhead_location=geo,
|
|
)
|
|
found = Trail.find_by_trailhead(
|
|
34.190598, -118.844015,
|
|
route_lat=34.192167, route_lon=-118.843143,
|
|
tolerance_m=100,
|
|
)
|
|
assert found == trail
|
|
|
|
|
|
class TestFindOrCreate:
|
|
def test_find_existing(self, db):
|
|
Trail.objects.create(title="Existing Trail")
|
|
trail = Trail.find_or_create("Existing Trail")
|
|
assert trail.title == "Existing Trail"
|
|
|
|
def test_create_new(self, db):
|
|
trail = Trail.find_or_create("New Trail")
|
|
assert trail.title == "New Trail"
|
|
assert Trail.objects.count() == 1
|